Moved render settings onto entity.

Author: StarArawn

examples/bench.rs

@@ -39,6 +39,10 @@ fn startup(mut commands: Commands, asset_server: Res<AssetServer>) {
     });
 }
 
+fn display_t_entities(query: Query<Entity, With<Transform>>) {
+    dbg!(query.iter().count());
+}
+
 fn main() {
     App::new()
         .add_plugins(
@@ -60,6 +64,6 @@ fn main() {
         .add_plugins(FrameTimeDiagnosticsPlugin)
         .add_plugins(TilemapPlugin)
         .add_systems(Startup, startup)
-        .add_systems(Update, helpers::camera::movement)
+        .add_systems(Update, (helpers::camera::movement, display_t_entities))
         .run();
 }

src/lib.rs

@@ -26,7 +26,7 @@ use map::{
     TilemapGridSize, TilemapSize, TilemapSpacing, TilemapTexture, TilemapTextureSize,
     TilemapTileSize, TilemapType,
 };
-use prelude::TilemapId;
+use prelude::{TilemapId, TilemapRenderSettings};
 #[cfg(feature = "render")]
 use render::material::{MaterialTilemap, StandardTilemapMaterial};
 use tiles::{
@@ -114,6 +114,7 @@ pub struct MaterialTilemapBundle<M: MaterialTilemap> {
     pub tile_size: TilemapTileSize,
     pub transform: Transform,
     pub global_transform: GlobalTransform,
+    pub render_settings: TilemapRenderSettings,
     /// User indication of whether an entity is visible
     pub visibility: Visibility,
     /// Algorithmically-computed indication of whether an entity is visible and should be extracted
@@ -138,6 +139,7 @@ pub struct StandardTilemapBundle {
     pub tile_size: TilemapTileSize,
     pub transform: Transform,
     pub global_transform: GlobalTransform,
+    pub render_settings: TilemapRenderSettings,
     /// User indication of whether an entity is visible
     pub visibility: Visibility,
     /// Algorithmically-computed indication of whether an entity is visible and should be extracted

src/map/mod.rs

@@ -1,7 +1,7 @@
 use bevy::asset::Assets;
 use bevy::ecs::entity::{EntityMapper, MapEntities};
 use bevy::ecs::reflect::ReflectMapEntities;
-use bevy::prelude::{ReflectComponent, Res, ResMut, Resource};
+use bevy::prelude::{ReflectComponent, Res, ResMut};
 use bevy::render::render_resource::TextureUsages;
 use bevy::{
     math::{UVec2, Vec2},
@@ -10,20 +10,8 @@ use bevy::{
 
 /// Custom parameters for the render pipeline.
 ///
-/// It must be added as a resource before [`TilemapPlugin`](crate::TilemapPlugin). For example:
-/// ```ignore
-/// App::new()
-///     .insert_resource(WindowDescriptor {
-///         width: 1270.0,
-///         height: 720.0,
-///     })
-///     .insert_resource(TilemapRenderSettings {
-///         render_chunk_size: UVec2::new(32, 32),
-///     })
-///     .add_plugin(TilemapPlugin)
-///     .run();
-/// ```
-#[derive(Resource, Debug, Default, Copy, Clone)]
+/// It must be added as a component to the tilemap entity.
+#[derive(Component, Debug, Default, Copy, Clone)]
 pub struct TilemapRenderSettings {
     /// Dimensions of a "chunk" in tiles. Chunks are grouping of tiles combined and rendered as a
     /// single mesh by the render pipeline.

src/render/chunk.rs

@@ -22,6 +22,8 @@ use crate::{
     FrustumCulling, TilemapGridSize, TilemapTileSize,
 };
 
+use super::RenderChunkSize;
+
 #[derive(Resource, Default, Clone, Debug)]
 pub struct RenderChunk2dStorage {
     chunks: HashMap<u32, HashMap<UVec3, RenderChunk2d>>,
@@ -51,6 +53,8 @@ impl RenderChunk2dStorage {
         transform: GlobalTransform,
         visibility: &InheritedVisibility,
         frustum_culling: &FrustumCulling,
+        render_size: RenderChunkSize,
+        y_sort: bool,
     ) -> &mut RenderChunk2d {
         let pos = position.xyz();
 
@@ -86,6 +90,8 @@ impl RenderChunk2dStorage {
                 transform,
                 visibility.get(),
                 **frustum_culling,
+                render_size,
+                y_sort,
             );
             self.entity_to_chunk.insert(chunk_entity, pos);
             chunk_storage.insert(pos, chunk);
@@ -208,6 +214,8 @@ pub struct RenderChunk2d {
     pub dirty_mesh: bool,
     pub visible: bool,
     pub frustum_culling: bool,
+    pub render_size: RenderChunkSize,
+    pub y_sort: bool,
 }
 
 impl RenderChunk2d {
@@ -227,6 +235,8 @@ impl RenderChunk2d {
         global_transform: GlobalTransform,
         visible: bool,
         frustum_culling: bool,
+        render_size: RenderChunkSize,
+        y_sort: bool,
     ) -> Self {
         let position = chunk_index_to_world_space(index.xy(), size_in_tiles, &grid_size, &map_type);
         let local_transform = Transform::from_translation(position.extend(0.0));
@@ -258,6 +268,8 @@ impl RenderChunk2d {
             tiles: vec![None; (size_in_tiles.x * size_in_tiles.y) as usize],
             visible,
             frustum_culling,
+            render_size,
+            y_sort,
         }
     }
 

src/render/extract.rs

@@ -7,6 +7,7 @@ use bevy::render::render_resource::TextureFormat;
 use bevy::{math::Vec4, prelude::*, render::Extract, utils::HashMap};
 
 use crate::prelude::TilemapGridSize;
+use crate::prelude::TilemapRenderSettings;
 use crate::render::{DefaultSampler, SecondsSinceStartup};
 use crate::tiles::AnimatedTile;
 use crate::tiles::TilePosOld;
@@ -68,6 +69,7 @@ pub struct ExtractedTilemapBundle {
     map_size: TilemapSize,
     visibility: InheritedVisibility,
     frustum_culling: FrustumCulling,
+    render_settings: TilemapRenderSettings,
 }
 
 #[derive(Component)]
@@ -220,6 +222,7 @@ pub fn extract(
             &TilemapSize,
             &InheritedVisibility,
             &FrustumCulling,
+            &TilemapRenderSettings,
         )>,
     >,
     changed_tilemap_query: Extract<
@@ -236,6 +239,7 @@ pub fn extract(
                 Changed<TilemapSize>,
                 Changed<InheritedVisibility>,
                 Changed<FrustumCulling>,
+                Changed<TilemapRenderSettings>,
             )>,
         >,
     >,
@@ -300,6 +304,7 @@ pub fn extract(
                     map_size: *data.7,
                     visibility: *data.8,
                     frustum_culling: *data.9,
+                    render_settings: *data.10,
                 },
             ),
         );
@@ -335,6 +340,7 @@ pub fn extract(
                         map_size: *data.7,
                         visibility: *data.8,
                         frustum_culling: *data.9,
+                        render_settings: *data.10,
                     },
                 ),
             );
@@ -345,7 +351,7 @@ pub fn extract(
         extracted_tilemaps.drain().map(|kv| kv.1).collect();
 
     // Extracts tilemap textures.
-    for (entity, _, tile_size, tile_spacing, _, _, texture, _, _, _) in tilemap_query.iter() {
+    for (entity, _, tile_size, tile_spacing, _, _, texture, _, _, _, _) in tilemap_query.iter() {
         if texture.verify_ready(&images) {
             extracted_tilemap_textures.push((
                 entity,

src/render/material.rs

@@ -31,7 +31,6 @@ use super::{
     draw::DrawTilemapMaterial,
     pipeline::{TilemapPipeline, TilemapPipelineKey},
     queue::{ImageBindGroups, TilemapViewBindGroup},
-    RenderYSort,
 };
 
 #[cfg(not(feature = "atlas"))]
@@ -362,7 +361,6 @@ fn prepare_material_tilemap<M: MaterialTilemap>(
 
 #[allow(clippy::too_many_arguments)]
 pub fn queue_material_tilemap_meshes<M: MaterialTilemap>(
-    y_sort: Res<RenderYSort>,
     chunk_storage: Res<RenderChunk2dStorage>,
     transparent_2d_draw_functions: Res<DrawFunctions<Transparent2d>>,
     render_device: Res<RenderDevice>,
@@ -455,7 +453,7 @@ pub fn queue_material_tilemap_meshes<M: MaterialTilemap>(
                         bind_group_data: material.key.clone(),
                     },
                 );
-                let z = if **y_sort {
+                let z = if chunk.y_sort {
                     transform.translation.z
                         + (1.0
                             - (transform.translation.y

src/render/mod.rs

@@ -16,13 +16,13 @@ use bevy::{
 #[cfg(not(feature = "atlas"))]
 use bevy::render::renderer::RenderDevice;
 
-use crate::render::{
-    material::{MaterialTilemapPlugin, StandardTilemapMaterial},
-    prepare::{MeshUniformResource, TilemapUniformResource},
-};
+use crate::tiles::{TilePos, TileStorage};
 use crate::{
-    prelude::{TilemapRenderSettings, TilemapTexture},
-    tiles::{TilePos, TileStorage},
+    prelude::TilemapTexture,
+    render::{
+        material::{MaterialTilemapPlugin, StandardTilemapMaterial},
+        prepare::{MeshUniformResource, TilemapUniformResource},
+    },
 };
 
 use self::{
@@ -62,7 +62,7 @@ pub struct DefaultSampler(ImageSamplerDescriptor);
 ///
 /// Initialized from [`TilemapRenderSettings`](crate::map::TilemapRenderSettings) resource, if
 /// provided. Otherwise, defaults to `64 x 64`.
-#[derive(Resource, Debug, Copy, Clone, Deref)]
+#[derive(Debug, Copy, Clone, Deref)]
 pub(crate) struct RenderChunkSize(UVec2);
 
 impl RenderChunkSize {
@@ -85,13 +85,6 @@ impl RenderChunkSize {
     }
 }
 
-/// Sorts chunks using Y sort during render.
-///
-/// Initialized from [`TilemapRenderSettings`](crate::map::TilemapRenderSettings) resource, if
-/// provided. Otherwise, defaults to false.
-#[derive(Resource, Debug, Copy, Clone, Deref)]
-pub struct RenderYSort(bool);
-
 pub struct TilemapRenderingPlugin;
 
 #[derive(Resource, Default, Deref, DerefMut)]
@@ -129,15 +122,6 @@ impl Plugin for TilemapRenderingPlugin {
     }
 
     fn finish(&self, app: &mut App) {
-        // Extract the chunk size from the TilemapRenderSettings used to initialize the
-        // ChunkCoordinate resource to insert into the render pipeline
-        let (chunk_size, y_sort) = {
-            match app.world.get_resource::<TilemapRenderSettings>() {
-                Some(settings) => (settings.render_chunk_size, settings.y_sort),
-                None => (CHUNK_SIZE_2D, false),
-            }
-        };
-
         let sampler = app.get_added_plugins::<ImagePlugin>().first().map_or_else(
             || ImagePlugin::default_nearest().default_sampler,
             |plugin| plugin.default_sampler.clone(),
@@ -242,8 +226,6 @@ impl Plugin for TilemapRenderingPlugin {
 
         render_app
             .insert_resource(DefaultSampler(sampler))
-            .insert_resource(RenderChunkSize(chunk_size))
-            .insert_resource(RenderYSort(y_sort))
             .insert_resource(RenderChunk2dStorage::default())
             .insert_resource(SecondsSinceStartup(0.0))
             .add_systems(

src/render/prepare.rs

@@ -4,6 +4,7 @@ use crate::map::{
     TilemapId, TilemapSize, TilemapSpacing, TilemapTexture, TilemapTextureSize, TilemapTileSize,
     TilemapType,
 };
+use crate::prelude::TilemapRenderSettings;
 use crate::render::extract::ExtractedFrustum;
 use crate::{
     prelude::TilemapGridSize, render::RenderChunkSize, render::SecondsSinceStartup, FrustumCulling,
@@ -42,7 +43,6 @@ pub(crate) fn prepare(
     mut chunk_storage: ResMut<RenderChunk2dStorage>,
     mut mesh_uniforms: ResMut<MeshUniformResource>,
     mut tilemap_uniforms: ResMut<TilemapUniformResource>,
-    chunk_size: Res<RenderChunkSize>,
     extracted_tiles: Query<&ExtractedTile>,
     extracted_tilemaps: Query<(
         Entity,
@@ -56,6 +56,7 @@ pub(crate) fn prepare(
         &TilemapSize,
         &InheritedVisibility,
         &FrustumCulling,
+        &TilemapRenderSettings,
     )>,
     extracted_tilemap_textures: Query<&ExtractedTilemapTexture>,
     extracted_frustum_query: Query<&ExtractedFrustum>,
@@ -69,7 +70,6 @@ pub(crate) fn prepare(
             chunk_storage.remove_tile_with_entity(tile.entity);
         }
 
-        let chunk_index = chunk_size.map_tile_to_chunk(&tile.position);
         let (
             _entity,
             transform,
@@ -82,7 +82,10 @@ pub(crate) fn prepare(
             map_size,
             visibility,
             frustum_culling,
+            tilemap_render_settings,
         ) = extracted_tilemaps.get(tile.tilemap_id.0).unwrap();
+        let chunk_size = RenderChunkSize(tilemap_render_settings.render_chunk_size);
+        let chunk_index = chunk_size.map_tile_to_chunk(&tile.position);
 
         let chunk_data = UVec4::new(
             chunk_index.x,
@@ -97,7 +100,7 @@ pub(crate) fn prepare(
             in_chunk_tile_index,
             tile.tilemap_id.0,
             &chunk_data,
-            **chunk_size,
+            *chunk_size,
             *mesh_type,
             *tile_size,
             (*texture_size).into(),
@@ -108,6 +111,8 @@ pub(crate) fn prepare(
             *transform,
             visibility,
             frustum_culling,
+            chunk_size,
+            tilemap_render_settings.y_sort,
         );
         chunk.set(
             &in_chunk_tile_index.into(),
@@ -135,6 +140,7 @@ pub(crate) fn prepare(
         map_size,
         visibility,
         frustum_culling,
+        _,
     ) in extracted_tilemaps.iter()
     {
         let chunks = chunk_storage.get_chunk_storage(&UVec4::new(0, 0, 0, entity.index()));