Added compute to the new pipelined renderer.

crates/bevy_app/src/app.rs

@@ -568,7 +568,11 @@ impl App {
         self
     }
 
-    pub fn add_sub_app(&mut self, app: App, f: impl Fn(&mut World, &mut App) + 'static) -> &mut Self {
+    pub fn add_sub_app(
+        &mut self,
+        app: App,
+        f: impl Fn(&mut World, &mut App) + 'static,
+    ) -> &mut Self {
         self.sub_apps.push(SubApp {
             app,
             runner: Box::new(f),

crates/bevy_app/src/lib.rs

@@ -15,10 +15,7 @@ pub use schedule_runner::*;
 
 pub mod prelude {
     #[doc(hidden)]
-    pub use crate::{
-        app::App, CoreStage, DynamicPlugin, Plugin, PluginGroup,
-        StartupStage,
-    };
+    pub use crate::{app::App, CoreStage, DynamicPlugin, Plugin, PluginGroup, StartupStage};
 }
 
 use bevy_ecs::schedule::StageLabel;

crates/bevy_ecs/src/lib.rs

@@ -1229,7 +1229,9 @@ mod tests {
 
     fn clear_entities() {
         let mut world = World::default();
-        world.register_component(ComponentDescriptor::new::<f32>(StorageType::SparseSet)).unwrap();
+        world
+            .register_component(ComponentDescriptor::new::<f32>(StorageType::SparseSet))
+            .unwrap();
         world.insert_resource::<i32>(0);
         world.spawn().insert(1u32);
         world.spawn().insert(1.0f32);
@@ -1243,9 +1245,25 @@ mod tests {
 
         world.clear_entities();
 
-        assert_eq!(q1.iter(&world).len(), 0, "world should not contain table components");
-        assert_eq!(q2.iter(&world).len(), 0, "world should not contain sparse set components");
-        assert_eq!(world.entities().len(), 0, "world should not have any entities");
-        assert_eq!(*world.get_resource::<i32>().unwrap(), 0, "world should still contain resources");
+        assert_eq!(
+            q1.iter(&world).len(),
+            0,
+            "world should not contain table components"
+        );
+        assert_eq!(
+            q2.iter(&world).len(),
+            0,
+            "world should not contain sparse set components"
+        );
+        assert_eq!(
+            world.entities().len(),
+            0,
+            "world should not have any entities"
+        );
+        assert_eq!(
+            *world.get_resource::<i32>().unwrap(),
+            0,
+            "world should still contain resources"
+        );
     }
 }

crates/crevice/src/lib.rs

@@ -139,4 +139,4 @@ pub mod internal;
 #[cfg(feature = "mint")]
 mod mint;
 
-mod glam;
+mod glam;

pipelined/bevy_render2/src/camera/bundle.rs

@@ -1,4 +1,7 @@
-use crate::camera::{CAMERA_2D, CAMERA_3D, Camera, DepthCalculation, OrthographicProjection, PerspectiveProjection, ScalingMode};
+use crate::camera::{
+    Camera, DepthCalculation, OrthographicProjection, PerspectiveProjection, ScalingMode,
+    CAMERA_2D, CAMERA_3D,
+};
 use bevy_ecs::bundle::Bundle;
 use bevy_transform::components::{GlobalTransform, Transform};
 

pipelined/bevy_render2/src/color/mod.rs

@@ -2,4 +2,4 @@ mod color;
 mod colorspace;
 
 pub use color::*;
-pub use colorspace::*;
+pub use colorspace::*;

pipelined/bevy_render2/src/main_pass/mod.rs

@@ -1,20 +1,17 @@
-mod draw_state;
 mod draw;
+mod draw_state;
 
-pub use draw_state::*;
 pub use draw::*;
+pub use draw_state::*;
 
-use crate::{RenderStage, pass::RenderPassColorAttachment, renderer::RenderContext};
 use crate::{
     camera::CameraPlugin,
     color::Color,
-    pass::{
-        LoadOp, Operations, PassDescriptor, RenderPass,
-        TextureAttachment,
-    },
+    pass::{LoadOp, Operations, PassDescriptor, RenderPass, TextureAttachment},
     render_graph::{Node, RenderGraph, ResourceSlotInfo, ResourceSlots, WindowSwapChainNode},
     render_resource::RenderResourceType,
 };
+use crate::{pass::RenderPassColorAttachment, renderer::RenderContext, RenderStage};
 use bevy_app::{App, Plugin};
 use bevy_ecs::prelude::*;
 use bevy_window::WindowId;
@@ -120,17 +117,20 @@ impl Node for MainPassNode {
         let transparent_phase = world.get_resource::<RenderPhase>().unwrap();
         let draw_functions = world.get_resource::<DrawFunctions>().unwrap();
 
-        render_context.begin_pass(&pass_descriptor, &mut |render_pass: &mut dyn RenderPass| {
-            let mut draw_functions = draw_functions.draw_function.lock();
-            let mut tracked_pass = TrackedRenderPass::new(render_pass);
-            for drawable in transparent_phase.drawn_things.iter() {
-                draw_functions[drawable.draw_function].draw(
-                    world,
-                    &mut tracked_pass,
-                    drawable.draw_key,
-                    drawable.sort_key,
-                );
-            }
-        })
+        render_context.begin_render_pass(
+            &pass_descriptor,
+            &mut |render_pass: &mut dyn RenderPass| {
+                let mut draw_functions = draw_functions.draw_function.lock();
+                let mut tracked_pass = TrackedRenderPass::new(render_pass);
+                for drawable in transparent_phase.drawn_things.iter() {
+                    draw_functions[drawable.draw_function].draw(
+                        world,
+                        &mut tracked_pass,
+                        drawable.draw_key,
+                        drawable.sort_key,
+                    );
+                }
+            },
+        )
     }
 }

pipelined/bevy_render2/src/mesh/mesh.rs

@@ -1,6 +1,9 @@
 mod conversions;
 
-use crate::pipeline::{IndexFormat, InputStepMode, PrimitiveTopology, VertexAttribute, VertexBufferLayout, VertexFormat};
+use crate::pipeline::{
+    IndexFormat, InputStepMode, PrimitiveTopology, VertexAttribute, VertexBufferLayout,
+    VertexFormat,
+};
 use bevy_core::cast_slice;
 use bevy_math::*;
 use bevy_reflect::TypeUuid;

pipelined/bevy_render2/src/pass/compute_pass.rs

@@ -0,0 +1,18 @@
+use crate::{
+    pipeline::{BindGroupDescriptorId, PipelineId},
+    render_resource::BindGroupId,
+    renderer::RenderContext,
+};
+
+pub trait ComputePass {
+    fn get_render_context(&self) -> &dyn RenderContext;
+    fn set_pipeline(&mut self, pipeline: PipelineId);
+    fn dispatch(&mut self, x: u32, y: u32, z: u32);
+    fn set_bind_group(
+        &mut self,
+        index: u32,
+        bind_group_descriptor_id: BindGroupDescriptorId,
+        bind_group: BindGroupId,
+        dynamic_uniform_indices: Option<&[u32]>,
+    );
+}

pipelined/bevy_render2/src/pass/mod.rs

@@ -1,8 +1,10 @@
+mod compute_pass;
 mod ops;
 #[allow(clippy::module_inception)]
 mod pass;
 mod render_pass;
 
+pub use compute_pass::*;
 pub use ops::*;
 pub use pass::*;
 pub use render_pass::*;

pipelined/bevy_render2/src/pass/pass.rs

@@ -1,6 +1,5 @@
 use crate::{color::Color, pass::Operations, render_resource::TextureId};
 
-
 #[derive(Debug, Clone)]
 pub enum TextureAttachment {
     Id(TextureId),

pipelined/bevy_render2/src/pipeline/compute_pipeline.rs

@@ -0,0 +1,29 @@
+use super::PipelineLayout;
+use crate::shader::ComputeShaderStages;
+use bevy_reflect::TypeUuid;
+
+#[derive(Clone, Debug, TypeUuid)]
+#[uuid = "359c1fff-0c86-4fbb-8b66-4e2af422a2f1"]
+pub struct ComputePipelineDescriptor {
+    pub name: Option<String>,
+    pub layout: PipelineLayout,
+    pub shader_stages: ComputeShaderStages,
+}
+
+impl ComputePipelineDescriptor {
+    pub fn new(shader_stages: ComputeShaderStages, layout: PipelineLayout) -> Self {
+        ComputePipelineDescriptor {
+            name: None,
+            layout,
+            shader_stages,
+        }
+    }
+
+    pub fn default_config(shader_stages: ComputeShaderStages, layout: PipelineLayout) -> Self {
+        ComputePipelineDescriptor {
+            name: None,
+            layout,
+            shader_stages,
+        }
+    }
+}

pipelined/bevy_render2/src/pipeline/mod.rs

@@ -1,5 +1,6 @@
 mod bind_group;
 mod binding;
+mod compute_pipeline;
 #[allow(clippy::module_inception)]
 mod pipeline;
 mod pipeline_layout;
@@ -9,6 +10,7 @@ mod vertex_format;
 
 pub use bind_group::*;
 pub use binding::*;
+pub use compute_pipeline::*;
 pub use pipeline::*;
 pub use pipeline_layout::*;
 pub use state_descriptors::*;

pipelined/bevy_render2/src/pipeline/pipeline.rs

@@ -10,7 +10,7 @@ use crate::{
         BlendComponent, BlendState, ColorTargetState, DepthBiasState, DepthStencilState,
         MultisampleState, PolygonMode, PrimitiveState, StencilFaceState, StencilState,
     },
-    shader::{ShaderStages},
+    shader::ShaderStages,
     texture::TextureFormat,
 };
 use bevy_reflect::{TypeUuid, Uuid};

pipelined/bevy_render2/src/render_graph/mod.rs

@@ -2,15 +2,15 @@ mod edge;
 mod graph;
 mod node;
 mod node_slot;
-mod schedule;
 mod nodes;
+mod schedule;
 
 pub use edge::*;
 pub use graph::*;
 pub use node::*;
 pub use node_slot::*;
-pub use schedule::*;
 pub use nodes::*;
+pub use schedule::*;
 
 use thiserror::Error;
 

pipelined/bevy_render2/src/render_graph/nodes/mod.rs

@@ -1,3 +1,3 @@
 mod window_swap_chain_node;
 
-pub use window_swap_chain_node::*;
+pub use window_swap_chain_node::*;

pipelined/bevy_render2/src/render_resource/bind_group.rs

@@ -124,4 +124,4 @@ impl BindGroupBuilder {
             }
         }
     }
-}
+}

pipelined/bevy_render2/src/render_resource/buffer_vec.rs

@@ -2,7 +2,7 @@ use crate::{
     render_resource::{BufferId, BufferInfo, BufferMapMode, BufferUsage},
     renderer::{RenderContext, RenderResources},
 };
-use bevy_core::{Pod, cast_slice};
+use bevy_core::{cast_slice, Pod};
 
 pub struct BufferVec<T: Pod> {
     values: Vec<T>,

pipelined/bevy_render2/src/render_resource/render_resource_id.rs

@@ -38,4 +38,4 @@ impl RenderResourceId {
             None
         }
     }
-}
+}

pipelined/bevy_render2/src/renderer/headless_render_resource_context.rs

@@ -1,6 +1,6 @@
 use super::RenderResourceContext;
 use crate::{
-    pipeline::{BindGroupDescriptorId, PipelineDescriptor, PipelineId},
+    pipeline::{BindGroupDescriptorId, ComputePipelineDescriptor, PipelineDescriptor, PipelineId},
     render_resource::{
         BindGroup, BufferId, BufferInfo, BufferMapMode, SamplerId, SwapChainDescriptor, TextureId,
     },
@@ -101,6 +101,13 @@ impl RenderResourceContext for HeadlessRenderResourceContext {
         PipelineId::new()
     }
 
+    fn create_compute_pipeline(
+        &self,
+        _pipeline_descriptor: &ComputePipelineDescriptor,
+    ) -> PipelineId {
+        PipelineId::new()
+    }
+
     fn create_bind_group(
         &self,
         _bind_group_descriptor_id: BindGroupDescriptorId,

pipelined/bevy_render2/src/renderer/render_context.rs

@@ -1,6 +1,6 @@
 use super::RenderResourceContext;
 use crate::{
-    pass::{PassDescriptor, RenderPass},
+    pass::{ComputePass, PassDescriptor, RenderPass},
     render_resource::{BufferId, TextureId},
     texture::Extent3d,
 };
@@ -49,9 +49,11 @@ pub trait RenderContext {
         destination_mip_level: u32,
         size: Extent3d,
     );
-    fn begin_pass(
+    fn begin_render_pass(
         &mut self,
         pass_descriptor: &PassDescriptor,
         run_pass: &mut dyn FnMut(&mut dyn RenderPass),
     );
+
+    fn begin_compute_pass(&mut self, run_pass: &mut dyn FnMut(&mut dyn ComputePass));
 }

pipelined/bevy_render2/src/renderer/render_resource_context.rs

@@ -1,5 +1,5 @@
 use crate::{
-    pipeline::{BindGroupDescriptorId, PipelineDescriptor, PipelineId},
+    pipeline::{BindGroupDescriptorId, ComputePipelineDescriptor, PipelineDescriptor, PipelineId},
     render_resource::{
         BindGroup, BufferId, BufferInfo, BufferMapMode, SamplerId, SwapChainDescriptor, TextureId,
     },
@@ -65,6 +65,10 @@ pub trait RenderResourceContext: Downcast + Send + Sync + 'static {
     fn get_aligned_uniform_size(&self, size: usize, dynamic: bool) -> usize;
     fn get_aligned_texture_size(&self, data_size: usize) -> usize;
     fn create_render_pipeline(&self, pipeline_descriptor: &PipelineDescriptor) -> PipelineId;
+    fn create_compute_pipeline(
+        &self,
+        _pipeline_descriptor: &ComputePipelineDescriptor,
+    ) -> PipelineId;
     fn bind_group_descriptor_exists(&self, bind_group_descriptor_id: BindGroupDescriptorId)
         -> bool;
     fn create_bind_group(

pipelined/bevy_render2/src/shader/shader.rs

@@ -253,6 +253,12 @@ pub struct ShaderStages {
     pub fragment: Option<ShaderId>,
 }
 
+/// All stages in a compute shader program
+#[derive(Clone, Debug, Eq, PartialEq, Hash)]
+pub struct ComputeShaderStages {
+    pub compute: ShaderId,
+}
+
 #[derive(Default)]
 pub struct ShaderLoader;
 

pipelined/bevy_sprite2/src/lib.rs

@@ -1,12 +1,12 @@
 mod bundle;
-mod render;
 mod rect;
+mod render;
 mod sprite;
 
+pub use bundle::*;
 pub use rect::*;
 pub use render::*;
 pub use sprite::*;
-pub use bundle::*;
 
 use bevy_app::prelude::*;
 use bevy_ecs::prelude::IntoSystem;

pipelined/bevy_sprite2/src/sprite.rs

@@ -36,4 +36,4 @@ impl Sprite {
             flip_y: false,
         }
     }
-}
+}