Avoid unnecessary copying with BufferVec::swap

crates/bevy_pbr/src/render/mesh.rs

@@ -741,7 +741,7 @@ impl Default for SkinnedMeshUniform {
 pub fn prepare_skinned_meshes(
     render_device: Res<RenderDevice>,
     render_queue: Res<RenderQueue>,
-    extracted_joints: Res<ExtractedJoints>,
+    mut extracted_joints: ResMut<ExtractedJoints>,
     mut skinned_mesh_uniform: ResMut<SkinnedMeshUniform>,
 ) {
     if extracted_joints.buffer.is_empty() {
@@ -752,9 +752,7 @@ pub fn prepare_skinned_meshes(
     skinned_mesh_uniform
         .buffer
         .reserve(extracted_joints.buffer.len(), &render_device);
-    for joint in &extracted_joints.buffer {
-        skinned_mesh_uniform.buffer.push(*joint);
-    }
+    skinned_mesh_uniform.buffer.swap(&mut extracted_joints.buffer);
     skinned_mesh_uniform
         .buffer
         .write_buffer(&render_device, &render_queue);

crates/bevy_render/src/render_resource/buffer_vec.rs

@@ -5,6 +5,8 @@ use crate::{
 use bevy_core::{cast_slice, Pod};
 use copyless::VecHelper;
 use wgpu::BufferUsages;
+#[cfg(feature="trace")]
+use bevy_utils::tracing::info_span;
 
 pub struct BufferVec<T: Pod> {
     values: Vec<T>,
@@ -51,6 +53,11 @@ impl<T: Pod> BufferVec<T> {
         index
     }
 
+    /// Swaps the internal [`Vec`] with another of the same type.
+    pub fn swap(&mut self, other: &mut Vec<T>) {
+        std::mem::swap(&mut self.values, other)
+    }
+
     pub fn reserve(&mut self, capacity: usize, device: &RenderDevice) {
         if capacity > self.capacity {
             self.capacity = capacity;
@@ -72,11 +79,13 @@ impl<T: Pod> BufferVec<T> {
         if let Some(buffer) = &self.buffer {
             let range = 0..self.item_size * self.values.len();
             let bytes: &[u8] = cast_slice(&self.values);
+            #[cfg(feature="trace")]
+            let _span = info_span!("BufferVec: write buffer").entered();
             queue.write_buffer(buffer, 0, &bytes[range]);
         }
     }
 
     pub fn clear(&mut self) {
         self.values.clear();
     }
-}
+}

crates/bevy_render/src/render_resource/storage_buffer.rs

@@ -5,6 +5,8 @@ use encase::{
     StorageBuffer as StorageBufferWrapper,
 };
 use wgpu::{util::BufferInitDescriptor, BindingResource, BufferBinding, BufferUsages};
+#[cfg(feature="trace")]
+use bevy_utils::tracing::info_span;
 
 pub struct StorageBuffer<T: ShaderType> {
     value: T,
@@ -73,6 +75,8 @@ impl<T: ShaderType + WriteInto> StorageBuffer<T> {
             }));
             self.capacity = size;
         } else if let Some(buffer) = &self.buffer {
+            #[cfg(feature="trace")]
+            let _span = info_span!("StorageBuffer: write buffer").entered();
             queue.write_buffer(buffer, 0, self.scratch.as_ref());
         }
     }
@@ -140,6 +144,8 @@ impl<T: ShaderType + WriteInto> DynamicStorageBuffer<T> {
             }));
             self.capacity = size;
         } else if let Some(buffer) = &self.buffer {
+            #[cfg(feature="trace")]
+            let _span = info_span!("DynamicStorageBuffer: write buffer").entered();
             queue.write_buffer(buffer, 0, self.scratch.as_ref());
         }
     }

crates/bevy_render/src/render_resource/uniform_buffer.rs

@@ -7,6 +7,8 @@ use encase::{
     UniformBuffer as UniformBufferWrapper,
 };
 use wgpu::{util::BufferInitDescriptor, BindingResource, BufferBinding, BufferUsages};
+#[cfg(feature="trace")]
+use bevy_utils::tracing::info_span;
 
 pub struct UniformBuffer<T: ShaderType> {
     value: T,
@@ -63,7 +65,11 @@ impl<T: ShaderType + WriteInto> UniformBuffer<T> {
         self.scratch.write(&self.value).unwrap();
 
         match &self.buffer {
-            Some(buffer) => queue.write_buffer(buffer, 0, self.scratch.as_ref()),
+            Some(buffer) => {
+                #[cfg(feature="trace")]
+                let _span = info_span!("UniformBuffer: write buffer").entered();
+                queue.write_buffer(buffer, 0, self.scratch.as_ref())
+            },
             None => {
                 self.buffer = Some(device.create_buffer_with_data(&BufferInitDescriptor {
                     label: None,
@@ -137,6 +143,8 @@ impl<T: ShaderType + WriteInto> DynamicUniformBuffer<T> {
             }));
             self.capacity = size;
         } else if let Some(buffer) = &self.buffer {
+            #[cfg(feature="trace")]
+            let _span = info_span!("DynamicUniformBuffer: write buffer").entered();
             queue.write_buffer(buffer, 0, self.scratch.as_ref());
         }
     }