RenderTask

crates/bevy_core_pipeline/src/core_3d/mod.rs

@@ -5,7 +5,7 @@ mod main_transparent_pass_3d_node;
 pub mod graph {
     use bevy_render::render_graph::{RenderLabel, RenderSubGraph};
 
-    #[derive(Debug, Hash, PartialEq, Eq, Clone, RenderSubGraph)]
+    #[derive(Debug, Hash, PartialEq, Eq, Clone, Default, RenderSubGraph)]
     pub struct Core3d;
 
     pub mod input {

crates/bevy_render/src/lib.rs

@@ -55,6 +55,7 @@ pub mod render_asset;
 pub mod render_graph;
 pub mod render_phase;
 pub mod render_resource;
+pub mod render_task;
 pub mod renderer;
 pub mod settings;
 pub mod storage;

crates/bevy_render/src/render_graph/app.rs

@@ -17,10 +17,10 @@ pub trait RenderGraphExt {
         node_label: impl RenderLabel,
     ) -> &mut Self;
     /// Automatically add the required node edges based on the given ordering
-    fn add_render_graph_edges<const N: usize>(
+    fn add_render_graph_edges(
         &mut self,
         sub_graph: impl RenderSubGraph,
-        edges: impl IntoRenderNodeArray<N>,
+        edges: impl IntoRenderNodeArray,
     ) -> &mut Self;
 
     /// Add node edge to the specified graph
@@ -54,10 +54,10 @@ impl RenderGraphExt for World {
     }
 
     #[track_caller]
-    fn add_render_graph_edges<const N: usize>(
+    fn add_render_graph_edges(
         &mut self,
         sub_graph: impl RenderSubGraph,
-        edges: impl IntoRenderNodeArray<N>,
+        edges: impl IntoRenderNodeArray,
     ) -> &mut Self {
         let sub_graph = sub_graph.intern();
         let mut render_graph = self.get_resource_mut::<RenderGraph>().expect(
@@ -123,10 +123,10 @@ impl RenderGraphExt for SubApp {
     }
 
     #[track_caller]
-    fn add_render_graph_edges<const N: usize>(
+    fn add_render_graph_edges(
         &mut self,
         sub_graph: impl RenderSubGraph,
-        edges: impl IntoRenderNodeArray<N>,
+        edges: impl IntoRenderNodeArray,
     ) -> &mut Self {
         World::add_render_graph_edges(self.world_mut(), sub_graph, edges);
         self
@@ -158,10 +158,11 @@ impl RenderGraphExt for App {
         self
     }
 
-    fn add_render_graph_edges<const N: usize>(
+    #[track_caller]
+    fn add_render_graph_edges(
         &mut self,
         sub_graph: impl RenderSubGraph,
-        edges: impl IntoRenderNodeArray<N>,
+        edges: impl IntoRenderNodeArray,
     ) -> &mut Self {
         World::add_render_graph_edges(self.world_mut(), sub_graph, edges);
         self

crates/bevy_render/src/render_graph/graph.rs

@@ -146,7 +146,7 @@ impl RenderGraph {
     /// Defining an edge that already exists is not considered an error with this api.
     /// It simply won't create a new edge.
     #[track_caller]
-    pub fn add_node_edges<const N: usize>(&mut self, edges: impl IntoRenderNodeArray<N>) {
+    pub fn add_node_edges(&mut self, edges: impl IntoRenderNodeArray) {
         for window in edges.into_array().windows(2) {
             let [a, b] = window else {
                 break;

crates/bevy_render/src/render_graph/node.rs

@@ -34,18 +34,18 @@ define_label!(
 /// A shorthand for `Interned<dyn RenderLabel>`.
 pub type InternedRenderLabel = Interned<dyn RenderLabel>;
 
-pub trait IntoRenderNodeArray<const N: usize> {
-    fn into_array(self) -> [InternedRenderLabel; N];
+pub trait IntoRenderNodeArray {
+    fn into_array(self) -> Vec<InternedRenderLabel>;
 }
 
 macro_rules! impl_render_label_tuples {
     ($N: expr, $(#[$meta:meta])* $(($T: ident, $I: ident)),*) => {
         $(#[$meta])*
-        impl<$($T: RenderLabel),*> IntoRenderNodeArray<$N> for ($($T,)*) {
+        impl<$($T: RenderLabel),*> IntoRenderNodeArray for ($($T,)*) {
             #[inline]
-            fn into_array(self) -> [InternedRenderLabel; $N] {
+            fn into_array(self) -> Vec<InternedRenderLabel> {
                 let ($($I,)*) = self;
-                [$($I.intern(), )*]
+                vec![$($I.intern(), )*]
             }
         }
     }

crates/bevy_render/src/render_resource/bind_group_entries.rs

@@ -182,6 +182,13 @@ impl<'a> IntoBinding<'a> for BindingResource<'a> {
     }
 }
 
+impl<'a> IntoBinding<'a> for &'a super::Buffer {
+    #[inline]
+    fn into_binding(self) -> BindingResource<'a> {
+        self.as_entire_binding()
+    }
+}
+
 impl<'a> IntoBinding<'a> for wgpu::BufferBinding<'a> {
     #[inline]
     fn into_binding(self) -> BindingResource<'a> {

crates/bevy_render/src/render_resource/pipeline.rs

@@ -104,7 +104,7 @@ impl BindGroupLayoutDescriptor {
 }
 
 /// Describes a render (graphics) pipeline.
-#[derive(Clone, Debug, PartialEq, Default)]
+#[derive(Clone, Debug, PartialEq, Eq, Default, Hash)]
 pub struct RenderPipelineDescriptor {
     /// Debug label of the pipeline. This will show up in graphics debuggers for easy identification.
     pub label: Option<Cow<'static, str>>,
@@ -142,7 +142,7 @@ impl RenderPipelineDescriptor {
     }
 }
 
-#[derive(Clone, Debug, Eq, PartialEq, Default)]
+#[derive(Clone, Debug, Eq, PartialEq, Default, Hash)]
 pub struct VertexState {
     /// The compiled shader module for this stage.
     pub shader: Handle<Shader>,
@@ -155,7 +155,7 @@ pub struct VertexState {
 }
 
 /// Describes the fragment process in a render pipeline.
-#[derive(Clone, Debug, PartialEq, Eq, Default)]
+#[derive(Clone, Debug, PartialEq, Eq, Default, Hash)]
 pub struct FragmentState {
     /// The compiled shader module for this stage.
     pub shader: Handle<Shader>,
@@ -174,7 +174,7 @@ impl FragmentState {
 }
 
 /// Describes a compute pipeline.
-#[derive(Clone, Debug, PartialEq, Eq, Default)]
+#[derive(Clone, Debug, PartialEq, Eq, Default, Hash)]
 pub struct ComputePipelineDescriptor {
     pub label: Option<Cow<'static, str>>,
     pub layout: Vec<BindGroupLayoutDescriptor>,

crates/bevy_render/src/render_task/bind.rs

@@ -0,0 +1,144 @@
+use crate::render_resource::{
+    BindGroupLayoutEntryBuilder, Buffer, IntoBindGroupLayoutEntryBuilder, IntoBinding, TextureView,
+};
+use wgpu::{BindingResource, BindingType, BufferBindingType, StorageTextureAccess};
+
+#[derive(Clone)]
+pub struct StorageBuffer<'a>(pub &'a Buffer);
+
+#[derive(Clone)]
+pub struct StorageBufferWriteable<'a>(pub &'a Buffer);
+
+#[derive(Clone)]
+pub struct Texture<'a>(pub &'a TextureView);
+
+#[derive(Clone)]
+pub struct StorageTexture<'a>(pub &'a TextureView);
+
+#[derive(Clone)]
+pub struct StorageTextureWriteOnly<'a>(pub &'a TextureView);
+
+#[derive(Clone)]
+pub struct StorageTextureReadOnly<'a>(pub &'a TextureView);
+
+#[derive(Clone)]
+pub struct StorageTextureAtomic<'a>(pub &'a TextureView);
+
+impl<'a> IntoBinding<'a> for StorageBuffer<'a> {
+    fn into_binding(self) -> BindingResource<'a> {
+        self.0.as_entire_binding()
+    }
+}
+
+impl<'a> IntoBindGroupLayoutEntryBuilder for StorageBuffer<'a> {
+    fn into_bind_group_layout_entry_builder(self) -> BindGroupLayoutEntryBuilder {
+        BindingType::Buffer {
+            ty: BufferBindingType::Storage { read_only: true },
+            has_dynamic_offset: false,
+            min_binding_size: None,
+        }
+        .into_bind_group_layout_entry_builder()
+    }
+}
+
+impl<'a> IntoBinding<'a> for StorageBufferWriteable<'a> {
+    fn into_binding(self) -> BindingResource<'a> {
+        self.0.as_entire_binding()
+    }
+}
+
+impl<'a> IntoBindGroupLayoutEntryBuilder for StorageBufferWriteable<'a> {
+    fn into_bind_group_layout_entry_builder(self) -> BindGroupLayoutEntryBuilder {
+        BindingType::Buffer {
+            ty: BufferBindingType::Storage { read_only: false },
+            has_dynamic_offset: false,
+            min_binding_size: None,
+        }
+        .into_bind_group_layout_entry_builder()
+    }
+}
+
+impl<'a> IntoBinding<'a> for Texture<'a> {
+    fn into_binding(self) -> BindingResource<'a> {
+        BindingResource::TextureView(self.0)
+    }
+}
+
+impl<'a> IntoBindGroupLayoutEntryBuilder for Texture<'a> {
+    fn into_bind_group_layout_entry_builder(self) -> BindGroupLayoutEntryBuilder {
+        BindingType::Texture {
+            sample_type: todo!(),
+            view_dimension: todo!(),
+            multisampled: self.0.texture().sample_count() > 1,
+        }
+        .into_bind_group_layout_entry_builder()
+    }
+}
+
+impl<'a> IntoBinding<'a> for StorageTexture<'a> {
+    fn into_binding(self) -> BindingResource<'a> {
+        BindingResource::TextureView(self.0)
+    }
+}
+
+impl<'a> IntoBindGroupLayoutEntryBuilder for StorageTexture<'a> {
+    fn into_bind_group_layout_entry_builder(self) -> BindGroupLayoutEntryBuilder {
+        BindingType::StorageTexture {
+            access: StorageTextureAccess::ReadWrite,
+            format: self.0.texture().format(),
+            view_dimension: todo!(),
+        }
+        .into_bind_group_layout_entry_builder()
+    }
+}
+
+impl<'a> IntoBinding<'a> for StorageTextureWriteOnly<'a> {
+    fn into_binding(self) -> BindingResource<'a> {
+        BindingResource::TextureView(self.0)
+    }
+}
+
+impl<'a> IntoBindGroupLayoutEntryBuilder for StorageTextureWriteOnly<'a> {
+    fn into_bind_group_layout_entry_builder(self) -> BindGroupLayoutEntryBuilder {
+        BindingType::StorageTexture {
+            access: StorageTextureAccess::WriteOnly,
+            format: self.0.texture().format(),
+            view_dimension: todo!(),
+        }
+        .into_bind_group_layout_entry_builder()
+    }
+}
+
+impl<'a> IntoBinding<'a> for StorageTextureReadOnly<'a> {
+    fn into_binding(self) -> BindingResource<'a> {
+        BindingResource::TextureView(self.0)
+    }
+}
+
+impl<'a> IntoBindGroupLayoutEntryBuilder for StorageTextureReadOnly<'a> {
+    fn into_bind_group_layout_entry_builder(self) -> BindGroupLayoutEntryBuilder {
+        BindingType::StorageTexture {
+            access: StorageTextureAccess::ReadOnly,
+            format: self.0.texture().format(),
+            view_dimension: todo!(),
+        }
+        .into_bind_group_layout_entry_builder()
+    }
+}
+
+impl<'a> IntoBinding<'a> for StorageTextureAtomic<'a> {
+    fn into_binding(self) -> BindingResource<'a> {
+        BindingResource::TextureView(self.0)
+    }
+}
+
+impl<'a> IntoBindGroupLayoutEntryBuilder for StorageTextureAtomic<'a> {
+    fn into_bind_group_layout_entry_builder(self) -> BindGroupLayoutEntryBuilder {
+        BindingType::StorageTexture {
+            access: StorageTextureAccess::Atomic,
+            format: self.0.texture().format(),
+            view_dimension: todo!(),
+        }
+        .into_bind_group_layout_entry_builder()
+    }
+}