bevy_entitiles 0.6.1

A 2d tilemap library for bevy. With many useful algorithms/tools built in.
Documentation 
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
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104

use bevy::{
    app::{App, Update},
    asset::load_internal_asset,
    prelude::{Handle, Plugin, Shader},
    render::{
        mesh::MeshVertexAttribute, render_resource::VertexFormat, ExtractSchedule, RenderApp,
    },
};

use crate::render::{
    binding::TilemapBindGroupLayouts,
    buffer::TilemapStorageBuffers,
    chunk::{ChunkUnload, RenderChunkStorage, UnloadRenderChunk},
    culling::FrustumCulling,
    material::StandardTilemapMaterialSingleton,
    texture::TilemapTexturesStorage,
};

pub mod binding;
pub mod buffer;
pub mod chunk;
pub mod culling;
pub mod draw;
pub mod extract;
pub mod material;
pub mod pipeline;
pub mod prepare;
pub mod queue;
pub mod resources;
pub mod texture;

pub const SQUARE: Handle<Shader> = Handle::weak_from_u128(54311635145631);
pub const ISOMETRIC: Handle<Shader> = Handle::weak_from_u128(45522415151365135);
pub const HEXAGONAL: Handle<Shader> = Handle::weak_from_u128(341658413214563135);
pub const COMMON: Handle<Shader> = Handle::weak_from_u128(1321023135616351);
pub const TILEMAP_SHADER: Handle<Shader> = Handle::weak_from_u128(89646584153215);

pub const TILEMAP_MESH_ATTR_INDEX: MeshVertexAttribute =
    MeshVertexAttribute::new("GridIndex", 14513156146, VertexFormat::Sint32x4);
pub const TILEMAP_MESH_ATTR_COLOR: MeshVertexAttribute =
    MeshVertexAttribute::new("Color", 85415341854, VertexFormat::Float32x4);
pub const TILEMAP_MESH_ATTR_TEX_INDICES: MeshVertexAttribute =
    MeshVertexAttribute::new("TextureIndex", 186541653135, VertexFormat::Sint32x4);
pub const TILEMAP_MESH_ATTR_FLIP: MeshVertexAttribute =
    MeshVertexAttribute::new("Flip", 7365156123161, VertexFormat::Uint32x4);

#[derive(Default)]
pub struct EntiTilesRendererPlugin;

impl Plugin for EntiTilesRendererPlugin {
    fn build(&self, app: &mut App) {
        load_internal_asset!(app, SQUARE, "shaders/square.wgsl", Shader::from_wgsl);
        load_internal_asset!(app, ISOMETRIC, "shaders/isometric.wgsl", Shader::from_wgsl);
        load_internal_asset!(app, HEXAGONAL, "shaders/hexagonal.wgsl", Shader::from_wgsl);
        load_internal_asset!(app, COMMON, "shaders/common.wgsl", Shader::from_wgsl);

        load_internal_asset!(
            app,
            TILEMAP_SHADER,
            "shaders/tilemap.wgsl",
            Shader::from_wgsl
        );

        app.add_systems(
            Update,
            (
                culling::cull_tilemaps,
                texture::set_texture_usage,
                material::standard_material_register,
            ),
        );

        app.init_resource::<FrustumCulling>()
            .init_resource::<StandardTilemapMaterialSingleton>();

        app.register_type::<UnloadRenderChunk>();
        app.add_event::<ChunkUnload>();

        let render_app = app.get_sub_app_mut(RenderApp).unwrap();

        render_app.add_systems(
            ExtractSchedule,
            (
                extract::extract_tilemaps,
                extract::extract_tiles,
                extract::extract_view,
                extract::extract_unloaded_chunks,
                extract::extract_resources,
                extract::extract_despawned_tilemaps,
                extract::extract_despawned_tiles,
            ),
        );

        render_app
            .init_resource::<TilemapTexturesStorage>()
            .init_resource::<TilemapStorageBuffers>();
    }

    fn finish(&self, app: &mut App) {
        let render_app = app.get_sub_app_mut(RenderApp).unwrap();

        render_app.init_resource::<TilemapBindGroupLayouts>();
    }
}