Fixed issues with z-index by hiding the y-sort behind a flag.

examples/3d_iso.rs

@@ -20,6 +20,7 @@ fn main() {
             // Map size is 12x12 so we'll have render chunks that are:
             // 12 tiles wide and 1 tile tall.
             render_chunk_size: UVec2::new(3, 1),
+            y_sort: true,
         })
         .add_plugins(
             DefaultPlugins

examples/bench.rs

@@ -54,6 +54,7 @@ fn main() {
         )
         .insert_resource(TilemapRenderSettings {
             render_chunk_size: UVec2::new(256, 256),
+            ..Default::default()
         })
         .add_plugin(LogDiagnosticsPlugin::default())
         .add_plugin(FrameTimeDiagnosticsPlugin::default())

examples/chunking.rs

@@ -120,6 +120,7 @@ fn main() {
         // `TilemapRenderSettings` be added before the `TilemapPlugin`.
         .insert_resource(TilemapRenderSettings {
             render_chunk_size: RENDER_CHUNK_SIZE,
+            ..Default::default()
         })
         .add_plugin(TilemapPlugin)
         .insert_resource(ChunkManager::default())

src/map/mod.rs

@@ -30,6 +30,13 @@ pub struct TilemapRenderSettings {
     ///
     /// Smaller chunk sizes will benefit tilemaps which change frequently.
     pub render_chunk_size: UVec2,
+    /// If true, uses the chunk's `z` and `y` values when sorting during rendering.
+    ///
+    /// When using this option with layered tilemaps, `z` values for layers should be separated by
+    /// at least `1.0` units.
+    ///
+    /// `render_chunk_size`'s `z` value should be `1` when using this for 3d isometric tilemaps.
+    pub y_sort: bool,
 }
 
 /// A component which stores a reference to the tilemap entity.

src/render/mod.rs

@@ -83,6 +83,13 @@ 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)]
@@ -123,10 +130,10 @@ impl Plugin for TilemapRenderingPlugin {
 
         // Extract the chunk size from the TilemapRenderSettings used to initialize the
         // ChunkCoordinate resource to insert into the render pipeline
-        let chunk_size = {
+        let (chunk_size, y_sort) = {
             match app.world.get_resource::<TilemapRenderSettings>() {
-                Some(settings) => settings.render_chunk_size,
-                None => CHUNK_SIZE_2D,
+                Some(settings) => (settings.render_chunk_size, settings.y_sort),
+                None => (CHUNK_SIZE_2D, false),
             }
         };
 
@@ -225,6 +232,7 @@ 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((extract::extract, extract::extract_removal).in_schedule(ExtractSchedule))

src/render/queue.rs

@@ -30,6 +30,7 @@ use super::{
     draw::DrawTilemap,
     pipeline::{TilemapPipeline, TilemapPipelineKey},
     prepare::{MeshUniformResource, TilemapUniformResource},
+    RenderYSort,
 };
 
 #[derive(Resource)]
@@ -95,6 +96,7 @@ pub struct ImageBindGroups {
 #[allow(clippy::too_many_arguments)]
 pub fn queue_meshes(
     mut commands: Commands,
+    y_sort: Res<RenderYSort>,
     chunk_storage: Res<RenderChunk2dStorage>,
     transparent_2d_draw_functions: Res<DrawFunctions<Transparent2d>>,
     render_device: Res<RenderDevice>,
@@ -196,10 +198,14 @@ pub fn queue_meshes(
                     };
 
                     let pipeline_id = pipelines.specialize(&pipeline_cache, &tilemap_pipeline, key);
-                    let z = transform.translation.z
-                        + (1.0
-                            - (transform.translation.y
-                                / (chunk.map_size.y as f32 * chunk.tile_size.y)));
+                    let z = if **y_sort {
+                        transform.translation.z
+                            + (1.0
+                                - (transform.translation.y
+                                    / (chunk.map_size.y as f32 * chunk.tile_size.y)))
+                    } else {
+                        transform.translation.z
+                    };
                     transparent_phase.add(Transparent2d {
                         entity,
                         draw_function: draw_tilemap,