SharedBuffersNode

crates/bevy_asset/src/handle.rs

@@ -37,6 +37,10 @@ impl<T> Handle<T> {
         }
     }
 
+    pub fn as_handle<U>(&self) -> Handle<U> {
+        Handle::from_id(self.id)
+    }
+
     pub const fn from_id(id: HandleId) -> Self {
         Handle {
             id,

crates/bevy_render/src/base_render_graph/mod.rs

@@ -5,7 +5,8 @@ use crate::{
     },
     render_graph::{
         nodes::{
-            CameraNode, MainPassNode, TextureCopyNode, WindowSwapChainNode, WindowTextureNode,
+            CameraNode, MainPassNode, SharedBuffersNode, TextureCopyNode, WindowSwapChainNode,
+            WindowTextureNode,
         },
         RenderGraph,
     },
@@ -30,6 +31,7 @@ pub mod node {
     pub const TEXTURE_COPY: &str = "texture_copy";
     pub const MAIN_DEPTH_TEXTURE: &str = "main_pass_depth_texture";
     pub const MAIN_PASS: &str = "main_pass";
+    pub const SHARED_BUFFERS: &str = "shared_buffers";
 }
 
 pub mod uniform {
@@ -67,6 +69,7 @@ impl BaseRenderGraphBuilder for RenderGraph {
             self.add_system_node(node::CAMERA2D, CameraNode::new(uniform::CAMERA2D));
         }
 
+        self.add_node(node::SHARED_BUFFERS, SharedBuffersNode::default());
         if config.add_main_depth_texture {
             self.add_node(
                 node::MAIN_DEPTH_TEXTURE,
@@ -116,6 +119,9 @@ impl BaseRenderGraphBuilder for RenderGraph {
 
             self.add_node_edge(node::TEXTURE_COPY, node::MAIN_PASS)
                 .unwrap();
+            self.add_node_edge(node::SHARED_BUFFERS, node::MAIN_PASS)
+                .unwrap();
+
             if config.add_3d_camera {
                 self.add_node_edge(node::CAMERA, node::MAIN_PASS).unwrap();
             }

crates/bevy_render/src/render_graph/nodes/shared_buffers_node.rs

@@ -0,0 +1,24 @@
+use crate::{
+    render_graph::{Node, ResourceSlots},
+    render_resource::SharedBuffers,
+    renderer::RenderContext,
+};
+use legion::prelude::*;
+
+#[derive(Default)]
+pub struct SharedBuffersNode;
+
+impl Node for SharedBuffersNode {
+    fn update(
+        &mut self,
+        _world: &World,
+        resources: &Resources,
+        render_context: &mut dyn RenderContext,
+        _input: &ResourceSlots,
+        _output: &mut ResourceSlots,
+    ) {
+        let shared_buffers = resources.get::<SharedBuffers>().unwrap();
+        let mut command_queue = shared_buffers.reset_command_queue();
+        // command_queue.execute(render_context);
+    }
+}

crates/bevy_render/src/render_resource/mod.rs

@@ -2,7 +2,7 @@ mod bind_group;
 mod buffer;
 mod render_resource;
 mod render_resource_bindings;
-mod shared_buffer;
+mod shared_buffers;
 mod systems;
 mod texture;
 
@@ -10,6 +10,6 @@ pub use bind_group::*;
 pub use buffer::*;
 pub use render_resource::*;
 pub use render_resource_bindings::*;
-pub use shared_buffer::*;
+pub use shared_buffers::*;
 pub use systems::*;
 pub use texture::*;

crates/bevy_render/src/render_resource/shared_buffers.rs

@@ -1,5 +1,7 @@
 use super::{BufferId, BufferInfo, RenderResource, RenderResourceBinding};
-use crate::{render_resource::BufferUsage, renderer::RenderResourceContext};
+use crate::{
+    render_graph::CommandQueue, render_resource::BufferUsage, renderer::RenderResourceContext,
+};
 use legion::systems::Res;
 use std::sync::{Arc, RwLock};
 
@@ -9,6 +11,7 @@ use std::sync::{Arc, RwLock};
 pub struct SharedBuffers {
     render_resource_context: Box<dyn RenderResourceContext>,
     buffers: Arc<RwLock<Vec<BufferId>>>,
+    command_queue: Arc<RwLock<CommandQueue>>,
 }
 
 impl SharedBuffers {
@@ -16,6 +19,7 @@ impl SharedBuffers {
         Self {
             render_resource_context,
             buffers: Default::default(),
+            command_queue: Default::default(),
         }
     }
 
@@ -26,18 +30,35 @@ impl SharedBuffers {
     ) -> Option<RenderResourceBinding> {
         if let Some(size) = render_resource.buffer_byte_len() {
             // PERF: this buffer will be slow
-            let buffer = self.render_resource_context.create_buffer_mapped(
+            let staging_buffer = self.render_resource_context.create_buffer_mapped(
                 BufferInfo {
                     size,
-                    buffer_usage: buffer_usage | BufferUsage::COPY_SRC | BufferUsage::COPY_DST,
+                    buffer_usage: BufferUsage::COPY_SRC,
                 },
                 &mut |data, _renderer| {
                     render_resource.write_buffer_bytes(data);
                 },
             );
-            self.buffers.write().unwrap().push(buffer);
+
+            let destination_buffer = self.render_resource_context.create_buffer(BufferInfo {
+                size,
+                buffer_usage: BufferUsage::COPY_DST | buffer_usage,
+            });
+
+            let mut command_queue = self.command_queue.write().unwrap();
+            command_queue.copy_buffer_to_buffer(
+                staging_buffer,
+                0,
+                destination_buffer,
+                0,
+                size as u64,
+            );
+
+            let mut buffers = self.buffers.write().unwrap();
+            buffers.push(staging_buffer);
+            buffers.push(destination_buffer);
             Some(RenderResourceBinding::Buffer {
-                buffer,
+                buffer: destination_buffer,
                 range: 0..size as u64,
                 dynamic_index: None,
             })
@@ -53,6 +74,11 @@ impl SharedBuffers {
             self.render_resource_context.remove_buffer(buffer)
         }
     }
+
+    pub fn reset_command_queue(&self) -> CommandQueue {
+        let mut command_queue = self.command_queue.write().unwrap();
+        std::mem::replace(&mut *command_queue, CommandQueue::default())
+    }
 }
 
 // TODO: remove this when this actually uses shared buffers