bevy_entitiles 0.2.5

A 2d tilemap library for bevy. With many useful algorithms/tools built in.
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78

use bevy::{
    ecs::{entity::Entity, system::ParallelCommands},
    math::Vec3Swizzles,
    prelude::{Component, Query, ResMut},
    render::camera::OrthographicProjection,
    transform::components::Transform,
    window::Window, reflect::Reflect,
};

use crate::{math::aabb::AabbBox2d, tilemap::map::Tilemap};

use super::{
    chunk::RenderChunkStorage,
    extract::{ExtractedTilemap, ExtractedView},
};

#[derive(Component, Reflect)]
pub struct VisibleTilemap;

pub fn cull_tilemaps(
    commands: ParallelCommands,
    tilemaps: Query<(Entity, &Tilemap)>,
    cameras: Query<(&Transform, &OrthographicProjection)>,
    windows: Query<&Window>,
) {
    let Ok((trans, proj)) = cameras.get_single() else {
        return;
    };

    let Ok(window) = windows.get_single() else {
        return;
    };

    let camera_aabb = AabbBox2d::from_camera(&ExtractedView {
        width: window.width() / 2.,
        height: window.height() / 2.,
        scale: proj.scale,
        transform: trans.translation.xy(),
    });

    tilemaps.par_iter().for_each(|(entity, tilemap)| {
        commands.command_scope(|mut cmd| {
            if tilemap.aabb.is_intersected(&camera_aabb) {
                cmd.entity(entity).insert(VisibleTilemap);
            } else {
                cmd.entity(entity).remove::<VisibleTilemap>();
            }
        });
    });
}

pub fn cull_chunks(
    tilemaps: Query<&ExtractedTilemap>,
    mut render_chunk_storage: ResMut<RenderChunkStorage>,
    cameras: Query<&ExtractedView>,
) {
    let Ok(proj) = cameras.get_single() else {
        return;
    };

    for tilemap in tilemaps.iter() {
        let Some(chunks) = render_chunk_storage.get_chunks_mut(tilemap.id) else {
            break;
        };

        let camera_aabb = AabbBox2d::from_camera(proj);

        for chunk in chunks.iter_mut() {
            if let Some(c) = chunk {
                if c.aabb.is_intersected(&camera_aabb) {
                    c.visible = true;
                } else {
                    c.visible = false;
                }
            }
        }
    }
}