Use GpuArrayBuffer for MeshUniform

assets/shaders/custom_vertex_attribute.wgsl

@@ -8,6 +8,7 @@ struct CustomMaterial {
 var<uniform> material: CustomMaterial;
 
 struct Vertex {
+    @builtin(instance_index) instance_index: u32,
     @location(0) position: vec3<f32>,
     @location(1) blend_color: vec4<f32>,
 };
@@ -21,8 +22,8 @@ struct VertexOutput {
 fn vertex(vertex: Vertex) -> VertexOutput {
     var out: VertexOutput;
     out.clip_position = mesh_position_local_to_clip(
-        mesh.model,
-        vec4<f32>(vertex.position, 1.0)
+        mesh[vertex.instance_index].model,
+        vec4<f32>(vertex.position, 1.0),
     );
     out.blend_color = vertex.blend_color;
     return out;

assets/shaders/instancing.wgsl

@@ -19,8 +19,12 @@ struct VertexOutput {
 fn vertex(vertex: Vertex) -> VertexOutput {
     let position = vertex.position * vertex.i_pos_scale.w + vertex.i_pos_scale.xyz;
     var out: VertexOutput;
+    // NOTE: The 0 index into the Mesh array is a hack for this example as the
+    // instance_index builtin would map to the wrong index in the Mesh array.
+    // This index could be passed in via another uniform instead but it's
+    // unnecessary for the example.
     out.clip_position = mesh_position_local_to_clip(
-        mesh.model, 
+        mesh[0].model,
         vec4<f32>(position, 1.0)
     );
     out.color = vertex.i_color;

crates/bevy_pbr/src/prepass/mod.rs

@@ -31,8 +31,8 @@ use bevy_render::{
         BindGroupLayoutEntry, BindingResource, BindingType, BlendState, BufferBindingType,
         ColorTargetState, ColorWrites, CompareFunction, DepthBiasState, DepthStencilState,
         DynamicUniformBuffer, FragmentState, FrontFace, MultisampleState, PipelineCache,
-        PolygonMode, PrimitiveState, RenderPipelineDescriptor, Shader, ShaderRef, ShaderStages,
-        ShaderType, SpecializedMeshPipeline, SpecializedMeshPipelineError,
+        PolygonMode, PrimitiveState, RenderPipelineDescriptor, Shader, ShaderDefVal, ShaderRef,
+        ShaderStages, ShaderType, SpecializedMeshPipeline, SpecializedMeshPipelineError,
         SpecializedMeshPipelines, StencilFaceState, StencilState, TextureSampleType,
         TextureViewDimension, VertexState,
     },
@@ -226,6 +226,7 @@ pub struct PrepassPipeline<M: Material> {
     pub view_layout_motion_vectors: BindGroupLayout,
     pub view_layout_no_motion_vectors: BindGroupLayout,
     pub mesh_layouts: MeshLayouts,
+    pub mesh_buffer_batch_size: Option<u32>,
     pub material_layout: BindGroupLayout,
     pub material_vertex_shader: Option<Handle<Shader>>,
     pub material_fragment_shader: Option<Handle<Shader>>,
@@ -313,6 +314,7 @@ impl<M: Material> FromWorld for PrepassPipeline<M> {
             view_layout_motion_vectors,
             view_layout_no_motion_vectors,
             mesh_layouts: mesh_pipeline.mesh_layouts.clone(),
+            mesh_buffer_batch_size: mesh_pipeline.mesh_buffer_batch_size,
             material_vertex_shader: match M::prepass_vertex_shader() {
                 ShaderRef::Default => None,
                 ShaderRef::Handle(handle) => Some(handle),
@@ -352,6 +354,10 @@ where
         let mut shader_defs = Vec::new();
         let mut vertex_attributes = Vec::new();
 
+        if let Some(batch_size) = self.mesh_buffer_batch_size {
+            shader_defs.push(ShaderDefVal::UInt("MESH_BATCH_SIZE".into(), batch_size));
+        }
+
         // NOTE: Eventually, it would be nice to only add this when the shaders are overloaded by the Material.
         // The main limitation right now is that bind group order is hardcoded in shaders.
         bind_group_layouts.insert(1, self.material_layout.clone());

crates/bevy_pbr/src/prepass/prepass.wgsl

@@ -7,6 +7,7 @@
 // Most of these attributes are not used in the default prepass fragment shader, but they are still needed so we can
 // pass them to custom prepass shaders like pbr_prepass.wgsl.
 struct Vertex {
+    @builtin(instance_index) instance_index: u32,
     @location(0) position: vec3<f32>,
 
 #ifdef VERTEX_UVS
@@ -88,7 +89,7 @@ fn vertex(vertex_no_morph: Vertex) -> VertexOutput {
 #ifdef SKINNED
     var model = bevy_pbr::skinning::skin_model(vertex.joint_indices, vertex.joint_weights);
 #else // SKINNED
-    var model = mesh.model;
+    var model = mesh[vertex.instance_index].model;
 #endif // SKINNED
 
     out.clip_position = bevy_pbr::mesh_functions::mesh_position_local_to_clip(model, vec4(vertex.position, 1.0));
@@ -105,17 +106,24 @@ fn vertex(vertex_no_morph: Vertex) -> VertexOutput {
 #ifdef SKINNED
     out.world_normal = bevy_pbr::skinning::skin_normals(model, vertex.normal);
 #else // SKINNED
-    out.world_normal = bevy_pbr::mesh_functions::mesh_normal_local_to_world(vertex.normal);
+    out.world_normal = bevy_pbr::mesh_functions::mesh_normal_local_to_world(
+        vertex.normal,
+        vertex.instance_index
+    );
 #endif // SKINNED
 
 #ifdef VERTEX_TANGENTS
-    out.world_tangent = bevy_pbr::mesh_functions::mesh_tangent_local_to_world(model, vertex.tangent);
+    out.world_tangent = bevy_pbr::mesh_functions::mesh_tangent_local_to_world(
+        model,
+        vertex.tangent,
+        vertex.instance_index
+    );
 #endif // VERTEX_TANGENTS
 #endif // NORMAL_PREPASS
 
 #ifdef MOTION_VECTOR_PREPASS
     out.world_position = bevy_pbr::mesh_functions::mesh_position_local_to_world(model, vec4<f32>(vertex.position, 1.0));
-    out.previous_world_position = bevy_pbr::mesh_functions::mesh_position_local_to_world(mesh.previous_model, vec4<f32>(vertex.position, 1.0));
+    out.previous_world_position = bevy_pbr::mesh_functions::mesh_position_local_to_world(mesh[vertex.instance_index].previous_model, vec4<f32>(vertex.position, 1.0));
 #endif // MOTION_VECTOR_PREPASS
 
     return out;

crates/bevy_pbr/src/prepass/prepass_bindings.wgsl

@@ -15,5 +15,4 @@ var<uniform> previous_view_proj: mat4x4<f32>;
 
 // Material bindings will be in @group(1)
 
-@group(2) @binding(0)
-var<uniform> mesh: bevy_pbr::mesh_types::Mesh;
+#import bevy_pbr::mesh_bindings   mesh

crates/bevy_pbr/src/render/mesh.rs

@@ -21,8 +21,8 @@ use bevy_ecs::{
 use bevy_math::{Mat3A, Mat4, Vec2};
 use bevy_reflect::TypeUuid;
 use bevy_render::{
-    extract_component::{ComponentUniforms, DynamicUniformIndex, UniformComponentPlugin},
     globals::{GlobalsBuffer, GlobalsUniform},
+    gpu_component_array_buffer::GpuComponentArrayBufferPlugin,
     mesh::{
         skinning::{SkinnedMesh, SkinnedMeshInverseBindposes},
         GpuBufferInfo, InnerMeshVertexBufferLayout, Mesh, MeshVertexBufferLayout,
@@ -121,7 +121,7 @@ impl Plugin for MeshRenderPlugin {
         load_internal_asset!(app, SKINNING_HANDLE, "skinning.wgsl", Shader::from_wgsl);
         load_internal_asset!(app, MORPH_HANDLE, "morph.wgsl", Shader::from_wgsl);
 
-        app.add_plugins(UniformComponentPlugin::<MeshUniform>::default());
+        app.add_plugins(GpuComponentArrayBufferPlugin::<MeshUniform>::default());
 
         if let Ok(render_app) = app.get_sub_app_mut(RenderApp) {
             render_app
@@ -309,8 +309,8 @@ pub struct MeshPipeline {
     // This dummy white texture is to be used in place of optional StandardMaterial textures
     pub dummy_white_gpu_image: GpuImage,
     pub clustered_forward_buffer_binding_type: BufferBindingType,
-
     pub mesh_layouts: MeshLayouts,
+    pub mesh_buffer_batch_size: Option<u32>,
 }
 
 impl FromWorld for MeshPipeline {
@@ -550,6 +550,9 @@ impl FromWorld for MeshPipeline {
             clustered_forward_buffer_binding_type,
             dummy_white_gpu_image,
             mesh_layouts: MeshLayouts::new(&render_device),
+            mesh_buffer_batch_size: GpuArrayBuffer::<MeshUniform>::batch_size(
+                render_device.as_ref(),
+            ),
         }
     }
 }
@@ -709,6 +712,11 @@ impl SpecializedMeshPipeline for MeshPipeline {
         let mut shader_defs = Vec::new();
         let mut vertex_attributes = Vec::new();
 
+        shader_defs.push("INSTANCE_INDEX".into());
+        if let Some(batch_size) = self.mesh_buffer_batch_size {
+            shader_defs.push(ShaderDefVal::UInt("MESH_BATCH_SIZE".into(), batch_size));
+        }
+
         if layout.contains(Mesh::ATTRIBUTE_POSITION) {
             shader_defs.push("VERTEX_POSITIONS".into());
             vertex_attributes.push(Mesh::ATTRIBUTE_POSITION.at_shader_location(0));
@@ -932,29 +940,29 @@ pub fn queue_mesh_bind_group(
     mut groups: ResMut<MeshBindGroups>,
     mesh_pipeline: Res<MeshPipeline>,
     render_device: Res<RenderDevice>,
-    mesh_uniforms: Res<ComponentUniforms<MeshUniform>>,
+    mesh_uniforms: Res<GpuArrayBuffer<MeshUniform>>,
     skinned_mesh_uniform: Res<SkinnedMeshUniform>,
     weights_uniform: Res<MorphUniform>,
 ) {
     groups.reset();
     let layouts = &mesh_pipeline.mesh_layouts;
-    let Some(model) = mesh_uniforms.buffer() else {
+    let Some(model) = mesh_uniforms.binding() else {
         return;
     };
-    groups.model_only = Some(layouts.model_only(&render_device, model));
+    groups.model_only = Some(layouts.model_only(&render_device, &model));
 
     let skin = skinned_mesh_uniform.buffer.buffer();
     if let Some(skin) = skin {
-        groups.skinned = Some(layouts.skinned(&render_device, model, skin));
+        groups.skinned = Some(layouts.skinned(&render_device, &model, skin));
     }
 
     if let Some(weights) = weights_uniform.buffer.buffer() {
         for (id, gpu_mesh) in meshes.iter() {
             if let Some(targets) = gpu_mesh.morph_targets.as_ref() {
                 let group = if let Some(skin) = skin.filter(|_| is_skinned(&gpu_mesh.layout)) {
-                    layouts.morphed_skinned(&render_device, model, skin, weights, targets)
+                    layouts.morphed_skinned(&render_device, &model, skin, weights, targets)
                 } else {
-                    layouts.morphed(&render_device, model, weights, targets)
+                    layouts.morphed(&render_device, &model, weights, targets)
                 };
                 groups.morph_targets.insert(id.id(), group);
             }
@@ -1198,7 +1206,7 @@ impl<P: PhaseItem, const I: usize> RenderCommand<P> for SetMeshBindGroup<I> {
     type ViewWorldQuery = ();
     type ItemWorldQuery = (
         Read<Handle<Mesh>>,
-        Read<DynamicUniformIndex<MeshUniform>>,
+        Read<GpuArrayBufferIndex<MeshUniform>>,
         Option<Read<SkinnedMeshJoints>>,
         Option<Read<MorphIndex>>,
     );
@@ -1207,7 +1215,7 @@ impl<P: PhaseItem, const I: usize> RenderCommand<P> for SetMeshBindGroup<I> {
     fn render<'w>(
         _item: &P,
         _view: (),
-        (mesh, mesh_index, skin_index, morph_index): ROQueryItem<Self::ItemWorldQuery>,
+        (mesh, batch_indices, skin_index, morph_index): ROQueryItem<Self::ItemWorldQuery>,
         bind_groups: SystemParamItem<'w, '_, Self::Param>,
         pass: &mut TrackedRenderPass<'w>,
     ) -> RenderCommandResult {
@@ -1223,13 +1231,19 @@ impl<P: PhaseItem, const I: usize> RenderCommand<P> for SetMeshBindGroup<I> {
             );
             return RenderCommandResult::Failure;
         };
+
         let mut set_bind_group = |indices: &[u32]| pass.set_bind_group(I, bind_group, indices);
-        let mesh_index = mesh_index.index();
-        match (skin_index, morph_index) {
-            (None, None) => set_bind_group(&[mesh_index]),
-            (Some(skin), None) => set_bind_group(&[mesh_index, skin.index]),
-            (None, Some(morph)) => set_bind_group(&[mesh_index, morph.index]),
-            (Some(skin), Some(morph)) => set_bind_group(&[mesh_index, skin.index, morph.index]),
+        match (batch_indices.dynamic_offset, skin_index, morph_index) {
+            (None, None, None) => set_bind_group(&[]),
+            (None, Some(skin), None) => set_bind_group(&[skin.index]),
+            (None, None, Some(morph)) => set_bind_group(&[morph.index]),
+            (None, Some(skin), Some(morph)) => set_bind_group(&[skin.index, morph.index]),
+            (Some(mesh_index), None, None) => set_bind_group(&[mesh_index]),
+            (Some(mesh_index), Some(skin), None) => set_bind_group(&[mesh_index, skin.index]),
+            (Some(mesh_index), None, Some(morph)) => set_bind_group(&[mesh_index, morph.index]),
+            (Some(mesh_index), Some(skin), Some(morph)) => {
+                set_bind_group(&[mesh_index, skin.index, morph.index])
+            }
         };
         RenderCommandResult::Success
     }
@@ -1239,12 +1253,12 @@ pub struct DrawMesh;
 impl<P: PhaseItem> RenderCommand<P> for DrawMesh {
     type Param = SRes<RenderAssets<Mesh>>;
     type ViewWorldQuery = ();
-    type ItemWorldQuery = Read<Handle<Mesh>>;
+    type ItemWorldQuery = (Read<GpuArrayBufferIndex<MeshUniform>>, Read<Handle<Mesh>>);
     #[inline]
     fn render<'w>(
         _item: &P,
         _view: (),
-        mesh_handle: ROQueryItem<'_, Self::ItemWorldQuery>,
+        (batch_indices, mesh_handle): ROQueryItem<'_, Self::ItemWorldQuery>,
         meshes: SystemParamItem<'w, '_, Self::Param>,
         pass: &mut TrackedRenderPass<'w>,
     ) -> RenderCommandResult {
@@ -1257,10 +1271,13 @@ impl<P: PhaseItem> RenderCommand<P> for DrawMesh {
                     count,
                 } => {
                     pass.set_index_buffer(buffer.slice(..), 0, *index_format);
-                    pass.draw_indexed(0..*count, 0, 0..1);
+                    pass.draw_indexed(0..*count, 0, batch_indices.index..batch_indices.index + 1);
                 }
                 GpuBufferInfo::NonIndexed => {
-                    pass.draw(0..gpu_mesh.vertex_count, 0..1);
+                    pass.draw(
+                        0..gpu_mesh.vertex_count,
+                        batch_indices.index..batch_indices.index + 1,
+                    );
                 }
             }
             RenderCommandResult::Success

crates/bevy_pbr/src/render/mesh.wgsl

@@ -5,6 +5,7 @@
 #import bevy_pbr::mesh_vertex_output  MeshVertexOutput
 
 struct Vertex {
+    @builtin(instance_index) instance_index: u32,
 #ifdef VERTEX_POSITIONS
     @location(0) position: vec3<f32>,
 #endif
@@ -63,14 +64,17 @@ fn vertex(vertex_no_morph: Vertex) -> MeshVertexOutput {
 #ifdef SKINNED
     var model = bevy_pbr::skinning::skin_model(vertex.joint_indices, vertex.joint_weights);
 #else
-    var model = mesh.model;
+    var model = mesh[vertex.instance_index].model;
 #endif
 
 #ifdef VERTEX_NORMALS
 #ifdef SKINNED
     out.world_normal = bevy_pbr::skinning::skin_normals(model, vertex.normal);
 #else
-    out.world_normal = mesh_functions::mesh_normal_local_to_world(vertex.normal);
+    out.world_normal = mesh_functions::mesh_normal_local_to_world(
+        vertex.normal,
+        vertex.instance_index
+    );
 #endif
 #endif
 
@@ -84,13 +88,21 @@ fn vertex(vertex_no_morph: Vertex) -> MeshVertexOutput {
 #endif
 
 #ifdef VERTEX_TANGENTS
-    out.world_tangent = mesh_functions::mesh_tangent_local_to_world(model, vertex.tangent);
+    out.world_tangent = mesh_functions::mesh_tangent_local_to_world(
+        model,
+        vertex.tangent,
+        vertex.instance_index
+    );
 #endif
 
 #ifdef VERTEX_COLORS
     out.color = vertex.color;
 #endif
 
+#ifdef INSTANCE_INDEX
+    out.instance_index = vertex.instance_index;
+#endif
+
     return out;
 }