For each mesh instance, only store the previous frame's transform, not the entire MeshInputUniform. (#23892)

Currently, we copy the entire `MeshInputUniform`, which is 24 words, to
the previous mesh instance buffer. This is wasteful, as we only ever use
the transform for motion blur.

This patch fixes the issue by introducing a new type,
`PreviousMeshInputUniform`, that contains only the transform. Not only
does this improve performance, but it will also simplify future work to
sparsely update only the `MeshInputUniform` fields that changed.

On `bevy_city --no-cpu-culling`, this commit reduces
`write_previous_input_buffers` from a median time of 240.1 μs to 65.33
μs, a 3.68× speedup.

<img width="2756" height="1800" alt="Screenshot 2026-04-20 003301"
src="https://github.com/user-attachments/assets/35fa099d-4935-4af5-9b9c-99a3db570148"
/>

Author: pcwalton

crates/bevy_pbr/src/render/gpu_preprocess.rs

@@ -72,7 +72,10 @@ use bitflags::bitflags;
 use smallvec::{smallvec, SmallVec};
 use tracing::warn;
 
-use crate::{LightEntity, MeshCullingData, MeshCullingDataBuffer, MeshInputUniform, MeshUniform};
+use crate::{
+    LightEntity, MeshCullingData, MeshCullingDataBuffer, MeshInputUniform, MeshUniform,
+    PreviousMeshInputUniform,
+};
 
 use super::{ShadowView, ViewLightEntities};
 
@@ -1418,7 +1421,10 @@ fn preprocess_direct_bind_group_layout_entries() -> DynamicBindGroupLayoutEntrie
             // `current_input`
             (3, storage_buffer_read_only::<MeshInputUniform>(false)),
             // `previous_input`
-            (4, storage_buffer_read_only::<MeshInputUniform>(false)),
+            (
+                4,
+                storage_buffer_read_only::<PreviousMeshInputUniform>(false),
+            ),
             // `indices`
             (5, storage_buffer_read_only::<PreprocessWorkItem>(false)),
             // `output`

crates/bevy_pbr/src/render/mesh.rs

@@ -40,7 +40,9 @@ use bevy_mesh::{
     MeshTag, MeshVertexBufferLayoutRef, VertexAttributeDescriptor,
 };
 use bevy_platform::collections::{hash_map::Entry, HashMap};
-use bevy_render::batching::gpu_preprocessing::PreviousInstanceInputUniformBuffer;
+use bevy_render::batching::gpu_preprocessing::{
+    BufferDataInput, PreviousInstanceInputUniformBuffer,
+};
 use bevy_render::impl_atomic_pod;
 use bevy_render::mesh::allocator::{MeshSlabId, MeshSlabs};
 use bevy_render::mesh::morph::{
@@ -632,8 +634,22 @@ pub struct MeshInputUniform {
     pub pad3: u32,
 }
 
+/// Per-mesh-instance data that we retain from the previous frame.
+#[derive(ShaderType, Pod, Zeroable, Clone, Copy, Default, Debug)]
+#[repr(C)]
+pub struct PreviousMeshInputUniform {
+    /// The model transform, an affine 4×3 matrix transposed to 3×4.
+    pub world_from_local: [Vec4; 3],
+}
+
+impl BufferDataInput for MeshInputUniform {
+    type Previous = PreviousMeshInputUniform;
+}
+
 impl_atomic_pod!(MeshInputUniform, MeshInputUniformBlob);
 
+impl_atomic_pod!(PreviousMeshInputUniform, PreviousMeshInputUniformBlob);
+
 /// Information about each mesh instance needed to cull it on GPU.
 ///
 /// This consists of its axis-aligned bounding box (AABB).
@@ -1550,7 +1566,7 @@ impl RenderMeshInstanceGpuPrepared {
         entity: MainEntity,
         render_mesh_instances: &mut MainEntityHashMap<RenderMeshInstanceGpu>,
         current_input_buffer: &mut InstanceInputUniformBuffer<MeshInputUniform>,
-        previous_input_buffer: &PreviousInstanceInputUniformBuffer<MeshInputUniform>,
+        previous_input_buffer: &PreviousInstanceInputUniformBuffer<PreviousMeshInputUniform>,
     ) -> u32 {
         // Did the last frame contain this entity as well?
         let current_uniform_index;
@@ -1564,11 +1580,14 @@ impl RenderMeshInstanceGpuPrepared {
                     .gpu_specific
                     .current_uniform_index();
 
-                // Save the old mesh input uniform. The mesh preprocessing
-                // shader will need it to compute motion vectors.
-                let previous_mesh_input_uniform =
-                    current_input_buffer.get_unchecked(current_uniform_index);
-                let previous_input_index = previous_input_buffer.push(previous_mesh_input_uniform);
+                // Save the old mesh transform. The mesh preprocessing shader
+                // will need it to compute motion vectors.
+                let previous_world_from_local = current_input_buffer
+                    .get_unchecked(current_uniform_index)
+                    .world_from_local;
+                let previous_input_index = previous_input_buffer.push(PreviousMeshInputUniform {
+                    world_from_local: previous_world_from_local,
+                });
                 self.mesh_input_uniform.previous_input_index = previous_input_index;
 
                 // Write in the new mesh input uniform.
@@ -2606,10 +2625,13 @@ pub fn collect_meshes_for_gpu_building(
                                 let current_uniform_index =
                                     render_mesh_instance.gpu_specific.current_uniform_index();
 
-                                let previous_mesh_input_uniform =
-                                    current_input_buffer.get_unchecked(current_uniform_index);
+                                let previous_world_from_local = current_input_buffer
+                                    .get_unchecked(current_uniform_index)
+                                    .world_from_local;
                                 let previous_input_index =
-                                    previous_input_buffer.push(previous_mesh_input_uniform);
+                                    previous_input_buffer.push(PreviousMeshInputUniform {
+                                        world_from_local: previous_world_from_local,
+                                    });
                                 prepared.mesh_input_uniform.previous_input_index =
                                     previous_input_index;
 

crates/bevy_pbr/src/render/mesh_preprocess.wgsl

@@ -15,7 +15,8 @@
 // respectively.
 
 #import bevy_pbr::mesh_preprocess_types::{
-    IndirectParametersCpuMetadata, IndirectParametersGpuMetadata, MeshInput, PreprocessWorkItem
+    IndirectParametersCpuMetadata, IndirectParametersGpuMetadata, MeshInput, PreprocessWorkItem,
+    PreviousMeshInput
 }
 #import bevy_pbr::mesh_types::{
     Mesh, MESH_FLAGS_AABB_BASED_VISIBILITY_RANGE_BIT, MESH_FLAGS_NO_FRUSTUM_CULLING_BIT,
@@ -87,7 +88,7 @@ struct Immediates {
 // The current frame's `MeshInput`.
 @group(0) @binding(3) var<storage> current_input: array<MeshInput>;
 // The `MeshInput` values from the previous frame.
-@group(0) @binding(4) var<storage> previous_input: array<MeshInput>;
+@group(0) @binding(4) var<storage> previous_input: array<PreviousMeshInput>;
 // Indices into the `MeshInput` buffer.
 //
 // There may be many indices that map to the same `MeshInput`.

crates/bevy_render/src/batching/gpu_preprocessing.rs

@@ -167,7 +167,7 @@ pub enum GpuPreprocessingMode {
 pub struct BatchedInstanceBuffers<BD, BDI>
 where
     BD: GpuArrayBufferable + Sync + Send + 'static,
-    BDI: AtomicPod,
+    BDI: BufferDataInput,
 {
     /// The uniform data inputs for the current frame.
     ///
@@ -181,7 +181,7 @@ where
     /// can spawn or despawn between frames. Instead, each current buffer
     /// data input uniform is expected to contain the index of the
     /// corresponding buffer data input uniform in this list.
-    pub previous_input_buffer: PreviousInstanceInputUniformBuffer<BDI>,
+    pub previous_input_buffer: PreviousInstanceInputUniformBuffer<BDI::Previous>,
 
     /// The data needed to render buffers for each phase.
     ///
@@ -193,7 +193,7 @@ where
 impl<BD, BDI> Default for BatchedInstanceBuffers<BD, BDI>
 where
     BD: GpuArrayBufferable + Sync + Send + 'static,
-    BDI: AtomicPod,
+    BDI: BufferDataInput,
 {
     fn default() -> Self {
         BatchedInstanceBuffers {
@@ -204,6 +204,22 @@ where
     }
 }
 
+/// A trait that defines the data that we supply to the GPU for a single mesh
+/// instance (2D or 3D).
+///
+/// A compute shader is expected to expand this data to the full *buffer data*
+/// type. See [`BatchedInstanceBuffers`] for more detail.
+pub trait BufferDataInput: AtomicPod {
+    /// The type of the data that we supply for the GPU for the previous
+    type Previous: AtomicPod;
+}
+
+// We don't use GPU mesh preprocessing for the 2D pipeline, so we implement
+// `BufferDataInput` for the unit type here.
+impl BufferDataInput for () {
+    type Previous = ();
+}
+
 /// The GPU buffers holding the data needed to render batches for a single
 /// phase.
 ///
@@ -420,23 +436,23 @@ where
 /// large size, enough to hold all push operations that could possibly occur on
 /// the worker threads, and only synchronize the changed portion of the buffer
 /// to the GPU on each frame.
-pub struct PreviousInstanceInputUniformBuffer<BDI>
+pub struct PreviousInstanceInputUniformBuffer<BPDI>
 where
-    BDI: AtomicPod,
+    BPDI: AtomicPod,
 {
     /// The buffer containing the data that will be uploaded to the GPU.
-    buffer: AtomicRawBufferVec<BDI>,
+    buffer: AtomicRawBufferVec<BPDI>,
 
     /// The number of elements pushed since the last [`Self::reserve`].
     atomic_len: AtomicU32,
 }
 
-impl<BDI> PreviousInstanceInputUniformBuffer<BDI>
+impl<BPDI> PreviousInstanceInputUniformBuffer<BPDI>
 where
-    BDI: AtomicPod,
+    BPDI: AtomicPod,
 {
     /// Creates a new, empty buffer.
-    pub fn new() -> PreviousInstanceInputUniformBuffer<BDI> {
+    pub fn new() -> PreviousInstanceInputUniformBuffer<BPDI> {
         PreviousInstanceInputUniformBuffer {
             buffer: AtomicRawBufferVec::with_label(
                 BufferUsages::STORAGE,
@@ -475,7 +491,7 @@ where
     /// Appends a value and returns its index. Thread-safe.
     ///
     /// [`Self::reserve`] must have been called first with sufficient capacity.
-    pub fn push(&self, value: BDI) -> u32 {
+    pub fn push(&self, value: BPDI) -> u32 {
         let index = self.atomic_len.fetch_add(1, Ordering::Relaxed);
         debug_assert!(
             (index as usize) < self.buffer.len() as usize,
@@ -499,9 +515,9 @@ where
     }
 }
 
-impl<BDI> Default for PreviousInstanceInputUniformBuffer<BDI>
+impl<BPDI> Default for PreviousInstanceInputUniformBuffer<BPDI>
 where
-    BDI: AtomicPod,
+    BPDI: AtomicPod,
 {
     fn default() -> Self {
         Self::new()
@@ -1383,7 +1399,7 @@ impl FromWorld for GpuPreprocessingSupport {
 impl<BD, BDI> BatchedInstanceBuffers<BD, BDI>
 where
     BD: GpuArrayBufferable + Sync + Send + 'static,
-    BDI: AtomicPod,
+    BDI: BufferDataInput,
 {
     /// Creates new buffers.
     pub fn new() -> Self {

crates/bevy_render/src/batching/mod.rs

@@ -9,11 +9,12 @@ use nonmax::NonMaxU32;
 use bevy_material::{descriptor::CachedRenderPipelineId, labels::DrawFunctionId};
 
 use crate::{
+    batching::gpu_preprocessing::BufferDataInput,
     render_phase::{
         BinnedPhaseItem, CachedRenderPipelinePhaseItem, PhaseItemExtraIndex, SortedPhaseItem,
         SortedRenderPhase, ViewBinnedRenderPhases,
     },
-    render_resource::{AtomicPod, GpuArrayBufferable},
+    render_resource::GpuArrayBufferable,
     sync_world::MainEntity,
 };
 
@@ -119,7 +120,7 @@ pub trait GetBatchData {
 pub trait GetFullBatchData: GetBatchData {
     /// The per-instance data that was inserted into the
     /// [`crate::render_resource::BufferVec`] during extraction.
-    type BufferInputData: AtomicPod;
+    type BufferInputData: BufferDataInput;
 
     /// Get the per-instance data to be inserted into the
     /// [`crate::render_resource::GpuArrayBuffer`].

crates/bevy_render/src/occlusion_culling/mesh_preprocess_types.wgsl

@@ -10,6 +10,8 @@ struct MeshInput {
     lightmap_uv_rect: vec2<u32>,
     // Various flags.
     flags: u32,
+    // The index of the `PreviousMeshInput` uniform in the buffer, or `u32::MAX`
+    // if there's no such uniform.
     previous_input_index: u32,
     first_vertex_index: u32,
     first_index_index: u32,
@@ -29,6 +31,12 @@ struct MeshInput {
     metadata_index: u32
 }
 
+// Per-mesh-instance data that we retain from the previous frame.
+struct PreviousMeshInput {
+    // The model transform.
+    world_from_local: mat3x4<f32>,
+};
+
 // The `wgpu` indirect parameters structure. This is a union of two structures.
 // For more information, see the corresponding comment in
 // `gpu_preprocessing.rs`.