Update to 0.14.0

Cargo.toml

@@ -1,7 +1,7 @@
 [package]
 name = "bevy_ecs_tilemap"
 description = "A tilemap rendering plugin for bevy which is more ECS friendly by having an entity per tile."
-version = "0.12.0"
+version = "0.14.0"
 authors = ["John Mitchell"]
 homepage = "https://github.com/StarArawn/bevy_ecs_tilemap"
 repository = "https://github.com/StarArawn/bevy_ecs_tilemap"
@@ -16,7 +16,7 @@ render = []
 serde = ["dep:serde"]
 
 [dependencies]
-bevy = { version = "0.13", default-features = false, features = [
+bevy = { version = "0.14.0-rc.2", default-features = false, features = [
     "bevy_core_pipeline",
     "bevy_render",
     "bevy_asset",
@@ -35,7 +35,7 @@ tiled = { version = "0.11.0", default-features = false }
 thiserror = { version = "1.0" }
 
 [dev-dependencies.bevy]
-version = "0.13"
+version = "0.14.0-rc.2"
 default-features = false
 features = [
     "bevy_core_pipeline",
@@ -47,11 +47,13 @@ features = [
     "bevy_text",
     "bevy_sprite",
     #"file_watcher",
-    "multi-threaded",
+    "multi_threaded",
+    "zstd",
+    "bevy_pbr",
 ]
 
 [target.'cfg(unix)'.dev-dependencies.bevy]
-version = "0.13"
+version = "0.14.0-rc.2"
 default-features = false
 features = [
     "bevy_core_pipeline",
@@ -63,7 +65,7 @@ features = [
     "x11",
     "bevy_text",
     "bevy_sprite",
-    "multi-threaded",
+    "multi_threaded",
 ]
 
 

src/render/chunk.rs

@@ -1,9 +1,8 @@
 use std::hash::{Hash, Hasher};
 
-use bevy::math::Mat4;
-use bevy::prelude::{InheritedVisibility, Resource, Transform};
-use bevy::render::primitives::Aabb;
 use bevy::render::render_asset::RenderAssetUsages;
+use bevy::render::{mesh::BaseMeshPipelineKey, primitives::Aabb};
+use bevy::{math::Mat4, render::mesh::PrimitiveTopology};
 use bevy::{
     math::{UVec2, UVec3, UVec4, Vec2, Vec3Swizzles, Vec4, Vec4Swizzles},
     prelude::{Component, Entity, GlobalTransform, Mesh, Vec3},
@@ -14,6 +13,10 @@ use bevy::{
     },
     utils::HashMap,
 };
+use bevy::{
+    prelude::{InheritedVisibility, Resource, Transform},
+    render::mesh::MeshVertexBufferLayouts,
+};
 
 use crate::prelude::helpers::transform::{chunk_aabb, chunk_index_to_world_space};
 use crate::render::extract::ExtractedFrustum;
@@ -355,7 +358,11 @@ impl RenderChunk2d {
         }
     }
 
-    pub fn prepare(&mut self, device: &RenderDevice) {
+    pub fn prepare(
+        &mut self,
+        device: &RenderDevice,
+        mut mesh_vertex_buffer_layouts: &mut MeshVertexBufferLayouts,
+    ) {
         if self.dirty_mesh {
             let size = ((self.size_in_tiles.x * self.size_in_tiles.y) * 4) as usize;
             let mut positions: Vec<[f32; 4]> = Vec::with_capacity(size);
@@ -444,14 +451,18 @@ impl RenderChunk2d {
                         }
                     });
 
-            let mesh_vertex_buffer_layout = self.mesh.get_mesh_vertex_buffer_layout();
+            let mesh_vertex_buffer_layout = self
+                .mesh
+                .get_mesh_vertex_buffer_layout(&mut mesh_vertex_buffer_layouts);
             self.gpu_mesh = Some(GpuMesh {
                 vertex_buffer,
                 vertex_count: self.mesh.count_vertices() as u32,
                 buffer_info,
                 morph_targets: None,
                 layout: mesh_vertex_buffer_layout,
-                primitive_topology: bevy::render::render_resource::PrimitiveTopology::TriangleList,
+                key_bits: BaseMeshPipelineKey::from_primitive_topology(
+                    PrimitiveTopology::TriangleList,
+                ),
             });
             self.dirty_mesh = false;
         }

src/render/extract.rs

@@ -282,7 +282,7 @@ pub fn extract(
             visible: visible.0,
             position,
             texture,
-            color: color.0.as_linear_rgba_f32(),
+            color: color.0.linear().to_f32_array(),
         };
 
         let data = tilemap_query.get(tilemap_id.0).unwrap();

src/render/material.rs

@@ -1,30 +1,33 @@
 use bevy::{
     core_pipeline::core_2d::Transparent2d,
+    math::FloatOrd,
     prelude::*,
     reflect::TypePath,
     render::{
         extract_component::ExtractComponentPlugin,
         globals::GlobalsBuffer,
         render_asset::RenderAssets,
-        render_phase::{AddRenderCommand, DrawFunctions, RenderPhase},
+        render_phase::{
+            AddRenderCommand, DrawFunctions, PhaseItemExtraIndex, ViewSortedRenderPhases,
+        },
         render_resource::{
             AsBindGroup, AsBindGroupError, BindGroup, BindGroupEntry, BindGroupLayout,
             BindingResource, OwnedBindingResource, PipelineCache, RenderPipelineDescriptor,
             ShaderRef, SpecializedRenderPipeline, SpecializedRenderPipelines,
         },
         renderer::RenderDevice,
-        texture::FallbackImage,
+        texture::{FallbackImage, GpuImage},
         view::{ExtractedView, ViewUniforms, VisibleEntities},
         Extract, Render, RenderApp, RenderSet,
     },
-    utils::{FloatOrd, HashMap, HashSet},
+    utils::{HashMap, HashSet},
 };
 use std::{hash::Hash, marker::PhantomData};
 
 #[cfg(not(feature = "atlas"))]
 use bevy::render::renderer::RenderQueue;
 
-use crate::prelude::TilemapId;
+use crate::prelude::{TilemapId, TilemapRenderSettings};
 
 use super::{
     chunk::{ChunkId, RenderChunk2dStorage},
@@ -113,7 +116,7 @@ where
     }
 
     fn finish(&self, app: &mut App) {
-        if let Ok(render_app) = app.get_sub_app_mut(RenderApp) {
+        if let Some(render_app) = app.get_sub_app_mut(RenderApp) {
             render_app
                 .add_render_command::<Transparent2d, DrawTilemapMaterial<M>>()
                 .init_resource::<MaterialTilemapPipeline<M>>()
@@ -303,7 +306,7 @@ fn prepare_materials_tilemap<M: MaterialTilemap>(
     mut extracted_assets: ResMut<ExtractedMaterialsTilemap<M>>,
     mut render_materials: ResMut<RenderMaterialsTilemap<M>>,
     render_device: Res<RenderDevice>,
-    images: Res<RenderAssets<Image>>,
+    images: Res<RenderAssets<GpuImage>>,
     fallback_image: Res<FallbackImage>,
     pipeline: Res<MaterialTilemapPipeline<M>>,
 ) {
@@ -350,7 +353,7 @@ fn prepare_materials_tilemap<M: MaterialTilemap>(
 fn prepare_material_tilemap<M: MaterialTilemap>(
     material: &M,
     render_device: &RenderDevice,
-    images: &RenderAssets<Image>,
+    images: &RenderAssets<GpuImage>,
     fallback_image: &FallbackImage,
     pipeline: &MaterialTilemapPipeline<M>,
 ) -> Result<PreparedMaterialTilemap<M>, AsBindGroupError> {
@@ -378,23 +381,20 @@ pub fn queue_material_tilemap_meshes<M: MaterialTilemap>(
     ),
     pipeline_cache: Res<PipelineCache>,
     view_uniforms: Res<ViewUniforms>,
-    gpu_images: Res<RenderAssets<Image>>,
+    gpu_images: Res<RenderAssets<GpuImage>>,
     msaa: Res<Msaa>,
     globals_buffer: Res<GlobalsBuffer>,
     (standard_tilemap_meshes, materials): (
         Query<(Entity, &ChunkId, &Transform, &TilemapId)>,
         Query<&Handle<M>>,
     ),
-    mut views: Query<(
-        &ExtractedView,
-        &VisibleEntities,
-        &mut RenderPhase<Transparent2d>,
-    )>,
+    mut views: Query<(Entity, &ExtractedView, &VisibleEntities)>,
     render_materials: Res<RenderMaterialsTilemap<M>>,
     #[cfg(not(feature = "atlas"))] (mut texture_array_cache, render_queue): (
         ResMut<TextureArrayCache>,
         Res<RenderQueue>,
     ),
+    mut transparent_render_phases: ResMut<ViewSortedRenderPhases<Transparent2d>>,
 ) where
     M::Data: PartialEq + Eq + Hash + Clone,
 {
@@ -409,16 +409,19 @@ pub fn queue_material_tilemap_meshes<M: MaterialTilemap>(
         return;
     }
 
-    for (view, visible_entities, mut transparent_phase) in views.iter_mut() {
+    for (view_entity, view, visible_entities) in views.iter_mut() {
+        let Some(transparent_phase) = transparent_render_phases.get_mut(&view_entity) else {
+            continue;
+        };
+
         let draw_tilemap = transparent_2d_draw_functions
             .read()
             .get_id::<DrawTilemapMaterial<M>>()
             .unwrap();
 
         for (entity, chunk_id, transform, tilemap_id) in standard_tilemap_meshes.iter() {
             if !visible_entities
-                .entities
-                .iter()
+                .iter::<With<TilemapRenderSettings>>()
                 .any(|&entity| entity.index() == tilemap_id.0.index())
             {
                 continue;
@@ -475,7 +478,7 @@ pub fn queue_material_tilemap_meshes<M: MaterialTilemap>(
                     pipeline: pipeline_id,
                     sort_key: FloatOrd(z),
                     batch_range: 0..1,
-                    dynamic_offset: None,
+                    extra_index: PhaseItemExtraIndex::NONE,
                 });
             }
         }
@@ -489,7 +492,7 @@ pub fn bind_material_tilemap_meshes<M: MaterialTilemap>(
     render_device: Res<RenderDevice>,
     tilemap_pipeline: Res<TilemapPipeline>,
     view_uniforms: Res<ViewUniforms>,
-    gpu_images: Res<RenderAssets<Image>>,
+    gpu_images: Res<RenderAssets<GpuImage>>,
     globals_buffer: Res<GlobalsBuffer>,
     mut image_bind_groups: ResMut<ImageBindGroups>,
     (standard_tilemap_meshes, materials): (Query<(&ChunkId, &TilemapId)>, Query<&Handle<M>>),
@@ -535,8 +538,7 @@ pub fn bind_material_tilemap_meshes<M: MaterialTilemap>(
 
             for (chunk_id, tilemap_id) in standard_tilemap_meshes.iter() {
                 if !visible_entities
-                    .entities
-                    .iter()
+                    .iter::<With<TilemapRenderSettings>>()
                     .any(|&entity| entity.index() == tilemap_id.0.index())
                 {
                     continue;

src/render/mod.rs

@@ -9,14 +9,20 @@ use bevy::{
         render_phase::AddRenderCommand,
         render_resource::{FilterMode, SpecializedRenderPipelines, VertexFormat},
         texture::ImageSamplerDescriptor,
+        view::{check_visibility, VisibilitySystems},
         Render, RenderApp, RenderSet,
     },
 };
 
 #[cfg(not(feature = "atlas"))]
 use bevy::render::renderer::RenderDevice;
+#[cfg(not(feature = "atlas"))]
+use bevy::render::texture::GpuImage;
 
-use crate::tiles::{TilePos, TileStorage};
+use crate::{
+    prelude::TilemapRenderSettings,
+    tiles::{TilePos, TileStorage},
+};
 use crate::{
     prelude::TilemapTexture,
     render::{
@@ -110,10 +116,10 @@ impl Plugin for TilemapRenderingPlugin {
 
         app.add_plugins(MaterialTilemapPlugin::<StandardTilemapMaterial>::default());
 
-        app.world
+        app.world_mut()
             .resource_mut::<Assets<StandardTilemapMaterial>>()
             .insert(
-                Handle::<StandardTilemapMaterial>::default(),
+                Handle::<StandardTilemapMaterial>::default().id(),
                 StandardTilemapMaterial::default(),
             );
     }
@@ -209,9 +215,16 @@ impl Plugin for TilemapRenderingPlugin {
             Shader::from_wgsl
         );
 
+        app.add_systems(
+            PostUpdate,
+            (check_visibility::<With<TilemapRenderSettings>>)
+                .in_set(VisibilitySystems::CheckVisibility)
+                .after(VisibilitySystems::CalculateBounds),
+        );
+
         let render_app = match app.get_sub_app_mut(RenderApp) {
-            Ok(render_app) => render_app,
-            Err(_) => return,
+            Some(render_app) => render_app,
+            None => return,
         };
 
         render_app.init_resource::<TilemapPipeline>();
@@ -319,7 +332,7 @@ fn prepare_textures(
     render_device: Res<RenderDevice>,
     mut texture_array_cache: ResMut<TextureArrayCache>,
     extracted_tilemap_textures: Query<&ExtractedTilemapTexture>,
-    render_images: Res<bevy::render::render_asset::RenderAssets<Image>>,
+    render_images: Res<bevy::render::render_asset::RenderAssets<GpuImage>>,
 ) {
     for extracted_texture in extracted_tilemap_textures.iter() {
         texture_array_cache.add_extracted_texture(extracted_texture);

src/render/pipeline.rs

@@ -32,7 +32,6 @@ pub struct TilemapPipeline {
 
 impl FromWorld for TilemapPipeline {
     fn from_world(world: &mut World) -> Self {
-        let world = world.cell();
         let render_device = world.get_resource::<RenderDevice>().unwrap();
 
         let view_layout = render_device.create_bind_group_layout(

src/render/prepare.rs

@@ -9,8 +9,8 @@ use crate::render::extract::ExtractedFrustum;
 use crate::{
     prelude::TilemapGridSize, render::RenderChunkSize, render::SecondsSinceStartup, FrustumCulling,
 };
-use bevy::log::trace;
 use bevy::prelude::{InheritedVisibility, Resource};
+use bevy::{log::trace, render::mesh::MeshVertexBufferLayouts};
 use bevy::{
     math::{Mat4, UVec4},
     prelude::{Commands, Component, Entity, GlobalTransform, Query, Res, ResMut, Vec2},
@@ -63,6 +63,7 @@ pub(crate) fn prepare(
     render_device: Res<RenderDevice>,
     render_queue: Res<RenderQueue>,
     seconds_since_startup: Res<SecondsSinceStartup>,
+    mut mesh_vertex_buffer_layouts: ResMut<MeshVertexBufferLayouts>,
 ) {
     for tile in extracted_tiles.iter() {
         // First if the tile position has changed remove the tile from the old location.
@@ -188,7 +189,7 @@ pub(crate) fn prepare(
         }
         trace!("Preparing chunk: {:?}", chunk.get_index());
 
-        chunk.prepare(&render_device);
+        chunk.prepare(&render_device, &mut mesh_vertex_buffer_layouts);
 
         let mut chunk_uniform: TilemapUniformData = chunk.into();
         chunk_uniform.time = **seconds_since_startup;

src/render/shaders/tilemap_vertex.wgsl

@@ -130,7 +130,7 @@ fn vertex(vertex_input: VertexInput) -> MeshVertexOutput {
     out.uv = atlas_uvs[vertex_input.v_index % 4u];
     out.tile_id = i32(texture_index);
     // out.uv = out.uv + 1e-5;
-    out.position = view.view_proj * mesh_data.world_position;
+    out.position = view.clip_from_world * mesh_data.world_position;
     out.color = vertex_input.color;
     out.storage_position = vec2<u32>(vertex_input.position.xy);
     return out;