Directly copy data into uniform buffers

crates/bevy_pbr/src/prepass/mod.rs

@@ -709,7 +709,9 @@ pub fn prepare_previous_view_projection_uniforms(
         With<MotionVectorPrepass>,
     >,
 ) {
-    view_uniforms.uniforms.clear();
+    let view_iter = views.iter();
+    let capacity = view_iter.len();
+    let Some(mut writer) = view_uniforms.uniforms.get_writer(capacity, &render_device, &render_queue) else  { return };
 
     for (entity, camera, maybe_previous_view_proj) in &views {
         let view_projection = match maybe_previous_view_proj {
@@ -721,13 +723,9 @@ pub fn prepare_previous_view_projection_uniforms(
         commands
             .entity(entity)
             .insert(PreviousViewProjectionUniformOffset {
-                offset: view_uniforms.uniforms.push(view_projection),
+                offset: writer.write(&view_projection),
             });
     }
-
-    view_uniforms
-        .uniforms
-        .write_buffer(&render_device, &render_queue);
 }
 
 // Prepares the textures used by the prepass

crates/bevy_pbr/src/render/fog.rs

@@ -53,9 +53,11 @@ pub fn prepare_fog(
     mut fog_meta: ResMut<FogMeta>,
     views: Query<(Entity, Option<&FogSettings>), With<ExtractedView>>,
 ) {
-    fog_meta.gpu_fogs.clear();
+    let view_iter = views.iter();
+    let capacity = view_iter.len();
+    let Some(mut writer) = fog_meta.gpu_fogs.get_writer(capacity, &render_device, &render_queue) else  { return };
 
-    for (entity, fog) in &views {
+    for (entity, fog) in view_iter {
         let gpu_fog = if let Some(fog) = fog {
             match &fog.falloff {
                 FogFalloff::Linear { start, end } => GpuFog {
@@ -104,13 +106,9 @@ pub fn prepare_fog(
 
         // This is later read by `SetMeshViewBindGroup<I>`
         commands.entity(entity).insert(ViewFogUniformOffset {
-            offset: fog_meta.gpu_fogs.push(gpu_fog),
+            offset: writer.write(&gpu_fog),
         });
     }
-
-    fog_meta
-        .gpu_fogs
-        .write_buffer(&render_device, &render_queue);
 }
 
 /// Labels for fog-related systems

crates/bevy_pbr/src/render/light.rs

@@ -668,7 +668,9 @@ pub fn prepare_lights(
     point_lights: Query<(Entity, &ExtractedPointLight)>,
     directional_lights: Query<(Entity, &ExtractedDirectionalLight)>,
 ) {
-    light_meta.view_gpu_lights.clear();
+    let view_iter = views.iter();
+    let capacity = view_iter.len();
+    let Some(mut writer) = light_meta.view_gpu_lights.get_writer(capacity, &render_device, &render_queue) else  { return };
 
     // Pre-calculate for PointLights
     let cube_face_projection =
@@ -1199,14 +1201,10 @@ pub fn prepare_lights(
                 lights: view_lights,
             },
             ViewLightsUniformOffset {
-                offset: light_meta.view_gpu_lights.push(gpu_lights),
+                offset: writer.write(&gpu_lights),
             },
         ));
     }
-
-    light_meta
-        .view_gpu_lights
-        .write_buffer(&render_device, &render_queue);
 }
 
 // this must match CLUSTER_COUNT_SIZE in pbr.wgsl

crates/bevy_render/src/extract_component.rs

@@ -130,26 +130,23 @@ fn prepare_uniform_components<C: Component>(
     mut component_uniforms: ResMut<ComponentUniforms<C>>,
     components: Query<(Entity, &C)>,
 ) where
-    C: ShaderType + WriteInto + Clone,
+    C: ShaderType + WriteInto,
 {
-    component_uniforms.uniforms.clear();
-    let entities = components
-        .iter()
+    let component_iter = components.iter();
+    let capacity = component_iter.len();
+    let Some(mut writer) = component_uniforms.uniforms.get_writer(capacity, &render_device, &render_queue) else { return };
+    let entities = component_iter
         .map(|(entity, component)| {
             (
                 entity,
                 DynamicUniformIndex::<C> {
-                    index: component_uniforms.uniforms.push(component.clone()),
+                    index: writer.write(component),
                     marker: PhantomData,
                 },
             )
         })
         .collect::<Vec<_>>();
     commands.insert_or_spawn_batch(entities);
-
-    component_uniforms
-        .uniforms
-        .write_buffer(&render_device, &render_queue);
 }
 
 /// This plugin extracts the components into the "render world".

crates/bevy_render/src/render_resource/uniform_buffer.rs

@@ -1,14 +1,16 @@
-use std::marker::PhantomData;
+use std::{marker::PhantomData, num::NonZeroU64};
 
 use crate::{
     render_resource::Buffer,
     renderer::{RenderDevice, RenderQueue},
 };
 use encase::{
-    internal::WriteInto, DynamicUniformBuffer as DynamicUniformBufferWrapper, ShaderType,
-    UniformBuffer as UniformBufferWrapper,
+    internal::{BufferMut, WriteInto, AlignmentValue},
+    ShaderType, UniformBuffer as UniformBufferWrapper,
+};
+use wgpu::{
+    util::BufferInitDescriptor, BindingResource, BufferBinding, BufferDescriptor, BufferUsages,
 };
-use wgpu::{util::BufferInitDescriptor, BindingResource, BufferBinding, BufferUsages};
 
 /// Stores data to be transferred to the GPU and made accessible to shaders as a uniform buffer.
 ///
@@ -155,18 +157,46 @@ impl<T: ShaderType + WriteInto> UniformBuffer<T> {
 ///
 /// [std140 alignment/padding requirements]: https://www.w3.org/TR/WGSL/#address-spaces-uniform
 pub struct DynamicUniformBuffer<T: ShaderType> {
-    scratch: DynamicUniformBufferWrapper<Vec<u8>>,
     buffer: Option<Buffer>,
     label: Option<String>,
     changed: bool,
     buffer_usage: BufferUsages,
     _marker: PhantomData<fn() -> T>,
 }
 
+pub struct DynamicUniformBufferWriter<'a, T> {
+    buffer: encase::DynamicUniformBuffer<QueueWriteBufferViewWrapper<'a>>,
+    _marker: PhantomData<fn() -> T>,
+}
+
+impl<'a, T: ShaderType + WriteInto> DynamicUniformBufferWriter<'a, T> {
+    pub fn write(&mut self, value: &T) -> u32 {
+        self.buffer.write(value).unwrap() as u32
+    }
+}
+
+/// A wrapper to work around the orphan rule so that [`wgpu::QueueWriteBufferView`] can  implement
+/// [`encase::internal::BufferMut`].
+struct QueueWriteBufferViewWrapper<'a> {
+    buffer_view: wgpu::QueueWriteBufferView<'a>,
+    capacity: usize,
+}
+
+impl<'a> BufferMut for QueueWriteBufferViewWrapper<'a> {
+    #[inline]
+    fn capacity(&self) -> usize {
+        self.capacity
+    }
+
+    #[inline]
+    fn write<const N: usize>(&mut self, offset: usize, val: &[u8; N]) {
+        self.buffer_view.write(offset, val);
+    }
+}
+
 impl<T: ShaderType> Default for DynamicUniformBuffer<T> {
     fn default() -> Self {
         Self {
-            scratch: DynamicUniformBufferWrapper::new(Vec::new()),
             buffer: None,
             label: None,
             changed: false,
@@ -191,17 +221,6 @@ impl<T: ShaderType + WriteInto> DynamicUniformBuffer<T> {
         }))
     }
 
-    #[inline]
-    pub fn is_empty(&self) -> bool {
-        self.scratch.as_ref().is_empty()
-    }
-
-    /// Push data into the `DynamicUniformBuffer`'s internal vector (residing on system RAM).
-    #[inline]
-    pub fn push(&mut self, value: T) -> u32 {
-        self.scratch.write(&value).unwrap() as u32
-    }
-
     pub fn set_label(&mut self, label: Option<&str>) {
         let label = label.map(str::to_string);
 
@@ -232,25 +251,45 @@ impl<T: ShaderType + WriteInto> DynamicUniformBuffer<T> {
     /// If there is no GPU-side buffer allocated to hold the data currently stored, or if a GPU-side buffer previously
     /// allocated does not have enough capacity, a new GPU-side buffer is created.
     #[inline]
-    pub fn write_buffer(&mut self, device: &RenderDevice, queue: &RenderQueue) {
-        let capacity = self.buffer.as_deref().map(wgpu::Buffer::size).unwrap_or(0);
-        let size = self.scratch.as_ref().len() as u64;
+    pub fn get_writer<'a>(
+        &'a mut self,
+        max_count: usize,
+        device: &RenderDevice,
+        queue: &'a RenderQueue,
+    ) -> Option<DynamicUniformBufferWriter<'a, T>> {
+        let alignment = AlignmentValue::new(device.limits().min_uniform_buffer_offset_alignment as u64);
+        let mut capacity = self.buffer.as_deref().map(wgpu::Buffer::size).unwrap_or(0);
+        let size = alignment.round_up(T::min_size().get())
+            .checked_mul(max_count as u64)
+            .unwrap();
 
         if capacity < size || self.changed {
-            self.buffer = Some(device.create_buffer_with_data(&BufferInitDescriptor {
+            let buffer = device.create_buffer(&BufferDescriptor {
                 label: self.label.as_deref(),
                 usage: self.buffer_usage,
-                contents: self.scratch.as_ref(),
-            }));
+                size,
+                mapped_at_creation: false,
+            });
+            capacity = buffer.size();
+            self.buffer = Some(buffer);
             self.changed = false;
-        } else if let Some(buffer) = &self.buffer {
-            queue.write_buffer(buffer, 0, self.scratch.as_ref());
         }
-    }
 
-    #[inline]
-    pub fn clear(&mut self) {
-        self.scratch.as_mut().clear();
-        self.scratch.set_offset(0);
+        if let Some(buffer) = self.buffer.as_deref() {
+            let buffer_view =
+                queue.write_buffer_with(buffer, 0, NonZeroU64::new(buffer.size())?)?;
+            Some(DynamicUniformBufferWriter {
+                buffer: encase::DynamicUniformBuffer::new_with_alignment(
+                    QueueWriteBufferViewWrapper {
+                        capacity: capacity as usize,
+                        buffer_view,
+                    },
+                    alignment.get(),
+                ),
+                _marker: PhantomData,
+            })
+        } else {
+            None
+        }
     }
 }

crates/bevy_render/src/view/mod.rs

@@ -315,9 +315,10 @@ pub fn prepare_view_uniforms(
     mut view_uniforms: ResMut<ViewUniforms>,
     views: Query<(Entity, &ExtractedView, Option<&TemporalJitter>)>,
 ) {
-    view_uniforms.uniforms.clear();
-
-    for (entity, camera, temporal_jitter) in &views {
+    let view_iter = views.iter();
+    let capacity = view_iter.len();
+    let Some(mut writer) = view_uniforms.uniforms.get_writer(capacity, &render_device, &render_queue) else  { return };
+    for (entity, camera, temporal_jitter) in view_iter {
         let viewport = camera.viewport.as_vec4();
         let unjittered_projection = camera.projection;
         let mut projection = unjittered_projection;
@@ -331,7 +332,7 @@ pub fn prepare_view_uniforms(
         let inverse_view = view.inverse();
 
         let view_uniforms = ViewUniformOffset {
-            offset: view_uniforms.uniforms.push(ViewUniform {
+            offset: writer.write(&ViewUniform {
                 view_proj: camera
                     .view_projection
                     .unwrap_or_else(|| projection * inverse_view),
@@ -349,10 +350,6 @@ pub fn prepare_view_uniforms(
 
         commands.entity(entity).insert(view_uniforms);
     }
-
-    view_uniforms
-        .uniforms
-        .write_buffer(&render_device, &render_queue);
 }
 
 #[derive(Clone)]