bevy_entitiles 0.1.1

A tilemap library for bevy. With many algorithms 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
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94

use bevy::{
    asset::load_internal_asset,
    core_pipeline::core_2d::Transparent2d,
    prelude::{Entity, Handle, HandleUntyped, Image, IntoSystemConfigs, Plugin, Resource, Shader},
    reflect::TypeUuid,
    render::{
        render_phase::AddRenderCommand,
        render_resource::{BindGroup, SpecializedRenderPipelines},
        ExtractSchedule, Render, RenderApp, RenderSet,
    },
    utils::HashMap,
};

use crate::render::{
    chunk::RenderChunkStorage,
    draw::{DrawTilemap, DrawTilemapPureColor},
    pipeline::EntiTilesPipeline,
    texture::TilemapTextureArrayStorage,
    uniform::TilemapUniformsStorage,
};

pub mod chunk;
pub mod culling;
pub mod draw;
pub mod extract;
pub mod pipeline;
pub mod prepare;
pub mod queue;
pub mod texture;
pub mod uniform;

const SQUARE: HandleUntyped = HandleUntyped::weak_from_u64(Shader::TYPE_UUID, 4189641863548);
const ISO_DIAMOND: HandleUntyped = HandleUntyped::weak_from_u64(Shader::TYPE_UUID, 65416516351);
const COMMON: HandleUntyped = HandleUntyped::weak_from_u64(Shader::TYPE_UUID, 548635415641535);
const TILEMAP_SHADER: HandleUntyped =
    HandleUntyped::weak_from_u64(Shader::TYPE_UUID, 151631653416315);

pub struct EntiTilesRendererPlugin;

impl Plugin for EntiTilesRendererPlugin {
    fn build(&self, _app: &mut bevy::prelude::App) {}

    fn finish(&self, _app: &mut bevy::prelude::App) {
        load_internal_asset!(_app, SQUARE, "shaders/square.wgsl", Shader::from_wgsl);
        load_internal_asset!(
            _app,
            ISO_DIAMOND,
            "shaders/iso_diamond.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
        );

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

        render_app
            .add_systems(
                ExtractSchedule,
                (
                    extract::extract_tilemaps,
                    extract::extract_tiles,
                    extract::extract_view,
                ),
            )
            .add_systems(
                Render,
                (prepare::prepare, culling::cull).in_set(RenderSet::Prepare),
            )
            .add_systems(Render, queue::queue.in_set(RenderSet::Queue));

        render_app
            .init_resource::<RenderChunkStorage>()
            .init_resource::<TilemapTextureArrayStorage>()
            .init_resource::<TilemapUniformsStorage>()
            .init_resource::<EntiTilesPipeline>()
            .init_resource::<BindGroups>()
            .init_resource::<SpecializedRenderPipelines<EntiTilesPipeline>>();

        render_app.add_render_command::<Transparent2d, DrawTilemap>();
        render_app.add_render_command::<Transparent2d, DrawTilemapPureColor>();
    }
}

#[derive(Resource, Default)]
pub struct BindGroups {
    pub tilemap_uniform_bind_group: HashMap<Entity, BindGroup>,
    pub tilemap_texture_arrays: HashMap<Handle<Image>, BindGroup>,
}