[Merged by Bors] - EntityRenderCommand and PhaseItemRenderCommand

assets/shaders/custom.wgsl

@@ -11,7 +11,7 @@ var<uniform> view: View;
 struct Mesh {
     transform: mat4x4<f32>;
 };
-[[group(2), binding(0)]]
+[[group(1), binding(0)]]
 var<uniform> mesh: Mesh;
 
 struct Vertex {
@@ -37,7 +37,7 @@ fn vertex(vertex: Vertex) -> VertexOutput {
 struct CustomMaterial {
     color: vec4<f32>;
 };
-[[group(1), binding(0)]]
+[[group(2), binding(0)]]
 var<uniform> material: CustomMaterial;
 
 [[stage(fragment)]]

examples/shader/custom_shader_pipelined.rs

@@ -1,5 +1,5 @@
 use bevy::{
-    core_pipeline::{SetItemPipeline, Transparent3d},
+    core_pipeline::Transparent3d,
     diagnostic::{FrameTimeDiagnosticsPlugin, LogDiagnosticsPlugin},
     ecs::{
         prelude::*,
@@ -19,11 +19,12 @@ use bevy::{
         render_asset::{PrepareAssetError, RenderAsset, RenderAssetPlugin, RenderAssets},
         render_component::ExtractComponentPlugin,
         render_phase::{
-            AddRenderCommand, DrawFunctions, RenderCommand, RenderPhase, TrackedRenderPass,
+            AddRenderCommand, DrawFunctions, EntityRenderCommand, RenderPhase, SetItemPipeline,
+            TrackedRenderPass,
         },
         render_resource::*,
         renderer::RenderDevice,
-        view::ExtractedView,
+        view::{ComputedVisibility, ExtractedView, Msaa, Visibility},
         RenderApp, RenderStage,
     },
     PipelinedDefaultPlugins,
@@ -51,6 +52,8 @@ fn setup(
         meshes.add(Mesh::from(shape::Cube { size: 1.0 })),
         Transform::from_xyz(0.0, 0.5, 0.0),
         GlobalTransform::default(),
+        Visibility::default(),
+        ComputedVisibility::default(),
         materials.add(CustomMaterial {
             color: Color::GREEN,
         }),
@@ -118,21 +121,36 @@ impl Plugin for CustomMaterialPlugin {
         app.sub_app(RenderApp)
             .add_render_command::<Transparent3d, DrawCustom>()
             .init_resource::<CustomPipeline>()
+            .init_resource::<SpecializedPipelines<CustomPipeline>>()
             .add_system_to_stage(RenderStage::Queue, queue_custom);
     }
 }
 
 pub struct CustomPipeline {
     material_layout: BindGroupLayout,
-    pipeline: CachedPipelineId,
+    shader: Handle<Shader>,
+    pbr_pipeline: PbrPipeline,
+}
+
+impl SpecializedPipeline for CustomPipeline {
+    type Key = PbrPipelineKey;
+
+    fn specialize(&self, key: Self::Key) -> RenderPipelineDescriptor {
+        let mut descriptor = self.pbr_pipeline.specialize(key);
+        descriptor.vertex.shader = self.shader.clone();
+        descriptor.fragment.as_mut().unwrap().shader = self.shader.clone();
+        descriptor.layout = Some(vec![
+            self.pbr_pipeline.view_layout.clone(),
+            self.pbr_pipeline.mesh_layout.clone(),
+            self.material_layout.clone(),
+        ]);
+        descriptor
+    }
 }
 
 impl FromWorld for CustomPipeline {
     fn from_world(world: &mut World) -> Self {
-        let world = world.cell();
         let asset_server = world.get_resource::<AssetServer>().unwrap();
-        let shader = asset_server.load("shaders/custom.wgsl");
-
         let render_device = world.get_resource::<RenderDevice>().unwrap();
         let material_layout = render_device.create_bind_group_layout(&BindGroupLayoutDescriptor {
             entries: &[BindGroupLayoutEntry {
@@ -148,43 +166,42 @@ impl FromWorld for CustomPipeline {
             label: None,
         });
 
-        let pbr_pipeline = world.get_resource::<PbrPipeline>().unwrap();
-        let mut descriptor = pbr_pipeline.specialize(PbrPipelineKey::empty());
-        descriptor.vertex.shader = shader.clone();
-        descriptor.fragment.as_mut().unwrap().shader = shader;
-        descriptor.layout = Some(vec![
-            pbr_pipeline.view_layout.clone(),
-            material_layout.clone(),
-            pbr_pipeline.mesh_layout.clone(),
-        ]);
-
-        let mut pipeline_cache = world.get_resource_mut::<RenderPipelineCache>().unwrap();
         CustomPipeline {
-            pipeline: pipeline_cache.queue(descriptor),
+            pbr_pipeline: world.get_resource::<PbrPipeline>().unwrap().clone(),
+            shader: asset_server.load("shaders/custom.wgsl"),
             material_layout,
         }
     }
 }
 
+#[allow(clippy::too_many_arguments)]
 pub fn queue_custom(
     transparent_3d_draw_functions: Res<DrawFunctions<Transparent3d>>,
     materials: Res<RenderAssets<CustomMaterial>>,
     custom_pipeline: Res<CustomPipeline>,
+    mut pipeline_cache: ResMut<RenderPipelineCache>,
+    mut specialized_pipelines: ResMut<SpecializedPipelines<CustomPipeline>>,
+    msaa: Res<Msaa>,
     material_meshes: Query<(Entity, &Handle<CustomMaterial>, &MeshUniform), With<Handle<Mesh>>>,
     mut views: Query<(&ExtractedView, &mut RenderPhase<Transparent3d>)>,
 ) {
     let draw_custom = transparent_3d_draw_functions
         .read()
         .get_id::<DrawCustom>()
         .unwrap();
+    let key = PbrPipelineKey::from_msaa_samples(msaa.samples);
     for (view, mut transparent_phase) in views.iter_mut() {
         let view_matrix = view.transform.compute_matrix();
         let view_row_2 = view_matrix.row(2);
         for (entity, material_handle, mesh_uniform) in material_meshes.iter() {
             if materials.contains_key(material_handle) {
                 transparent_phase.add(Transparent3d {
                     entity,
-                    pipeline: custom_pipeline.pipeline,
+                    pipeline: specialized_pipelines.specialize(
+                        &mut pipeline_cache,
+                        &custom_pipeline,
+                        key,
+                    ),
                     draw_function: draw_custom,
                     distance: view_row_2.dot(mesh_uniform.transform.col(3)),
                 });
@@ -196,25 +213,25 @@ pub fn queue_custom(
 type DrawCustom = (
     SetItemPipeline,
     SetMeshViewBindGroup<0>,
+    SetTransformBindGroup<1>,
     SetCustomMaterialBindGroup,
-    SetTransformBindGroup<2>,
     DrawMesh,
 );
 
 struct SetCustomMaterialBindGroup;
-impl RenderCommand<Transparent3d> for SetCustomMaterialBindGroup {
+impl EntityRenderCommand for SetCustomMaterialBindGroup {
     type Param = (
         SRes<RenderAssets<CustomMaterial>>,
         SQuery<Read<Handle<CustomMaterial>>>,
     );
     fn render<'w>(
         _view: Entity,
-        item: &Transparent3d,
+        item: Entity,
         (materials, query): SystemParamItem<'w, '_, Self::Param>,
         pass: &mut TrackedRenderPass<'w>,
     ) {
-        let material_handle = query.get(item.entity).unwrap();
+        let material_handle = query.get(item).unwrap();
         let material = materials.into_inner().get(material_handle).unwrap();
-        pass.set_bind_group(1, &material.bind_group, &[]);
+        pass.set_bind_group(2, &material.bind_group, &[]);
     }
 }

examples/shader/shader_defs_pipelined.rs

@@ -1,5 +1,5 @@
 use bevy::{
-    core_pipeline::{SetItemPipeline, Transparent3d},
+    core_pipeline::Transparent3d,
     diagnostic::{FrameTimeDiagnosticsPlugin, LogDiagnosticsPlugin},
     ecs::prelude::*,
     math::Vec3,
@@ -12,9 +12,9 @@ use bevy::{
         camera::PerspectiveCameraBundle,
         mesh::{shape, Mesh},
         render_component::{ExtractComponent, ExtractComponentPlugin},
-        render_phase::{AddRenderCommand, DrawFunctions, RenderPhase},
+        render_phase::{AddRenderCommand, DrawFunctions, RenderPhase, SetItemPipeline},
         render_resource::*,
-        view::ExtractedView,
+        view::{ComputedVisibility, ExtractedView, Msaa, Visibility},
         RenderApp, RenderStage,
     },
     PipelinedDefaultPlugins,
@@ -64,6 +64,8 @@ fn setup(mut commands: Commands, mut meshes: ResMut<Assets<Mesh>>) {
         IsRed(true),
         Transform::from_xyz(-1.0, 0.5, 0.0),
         GlobalTransform::default(),
+        Visibility::default(),
+        ComputedVisibility::default(),
     ));
 
     // blue cube
@@ -72,6 +74,8 @@ fn setup(mut commands: Commands, mut meshes: ResMut<Assets<Mesh>>) {
         IsRed(false),
         Transform::from_xyz(1.0, 0.5, 0.0),
         GlobalTransform::default(),
+        Visibility::default(),
+        ComputedVisibility::default(),
     ));
 
     // camera
@@ -99,14 +103,14 @@ impl FromWorld for IsRedPipeline {
 }
 
 impl SpecializedPipeline for IsRedPipeline {
-    type Key = IsRed;
+    type Key = (IsRed, PbrPipelineKey);
 
-    fn specialize(&self, key: Self::Key) -> RenderPipelineDescriptor {
+    fn specialize(&self, (is_red, pbr_pipeline_key): Self::Key) -> RenderPipelineDescriptor {
         let mut shader_defs = Vec::new();
-        if key.0 {
+        if is_red.0 {
             shader_defs.push("IS_RED".to_string());
         }
-        let mut descriptor = self.pbr_pipeline.specialize(PbrPipelineKey::empty());
+        let mut descriptor = self.pbr_pipeline.specialize(pbr_pipeline_key);
         descriptor.vertex.shader = self.shader.clone();
         descriptor.vertex.shader_defs = shader_defs.clone();
         let fragment = descriptor.fragment.as_mut().unwrap();
@@ -130,6 +134,7 @@ type DrawIsRed = (
 fn queue_custom(
     transparent_3d_draw_functions: Res<DrawFunctions<Transparent3d>>,
     custom_pipeline: Res<IsRedPipeline>,
+    msaa: Res<Msaa>,
     mut pipelines: ResMut<SpecializedPipelines<IsRedPipeline>>,
     mut pipeline_cache: ResMut<RenderPipelineCache>,
     material_meshes: Query<(Entity, &MeshUniform, &IsRed), With<Handle<Mesh>>>,
@@ -139,11 +144,13 @@ fn queue_custom(
         .read()
         .get_id::<DrawIsRed>()
         .unwrap();
+    let key = PbrPipelineKey::from_msaa_samples(msaa.samples);
     for (view, mut transparent_phase) in views.iter_mut() {
         let view_matrix = view.transform.compute_matrix();
         let view_row_2 = view_matrix.row(2);
         for (entity, mesh_uniform, is_red) in material_meshes.iter() {
-            let pipeline = pipelines.specialize(&mut pipeline_cache, &custom_pipeline, *is_red);
+            let pipeline =
+                pipelines.specialize(&mut pipeline_cache, &custom_pipeline, (*is_red, key));
             transparent_phase.add(Transparent3d {
                 entity,
                 pipeline,

pipelined/bevy_core_pipeline/src/lib.rs

@@ -8,17 +8,14 @@ pub use main_pass_driver::*;
 
 use bevy_app::{App, Plugin};
 use bevy_core::FloatOrd;
-use bevy_ecs::{
-    prelude::*,
-    system::{lifetimeless::SRes, SystemParamItem},
-};
+use bevy_ecs::prelude::*;
 use bevy_render2::{
     camera::{ActiveCameras, CameraPlugin},
     color::Color,
     render_graph::{EmptyNode, RenderGraph, SlotInfo, SlotType},
     render_phase::{
-        sort_phase_system, DrawFunctionId, DrawFunctions, PhaseItem, RenderCommand, RenderPhase,
-        TrackedRenderPass,
+        sort_phase_system, CachedPipelinePhaseItem, DrawFunctionId, DrawFunctions, EntityPhaseItem,
+        PhaseItem, RenderPhase,
     },
     render_resource::*,
     renderer::RenderDevice,
@@ -171,38 +168,17 @@ impl PhaseItem for Transparent3d {
     }
 }
 
-pub struct SetItemPipeline;
-impl RenderCommand<Transparent3d> for SetItemPipeline {
-    type Param = SRes<RenderPipelineCache>;
+impl EntityPhaseItem for Transparent3d {
     #[inline]
-    fn render<'w>(
-        _view: Entity,
-        item: &Transparent3d,
-        pipeline_cache: SystemParamItem<'w, '_, Self::Param>,
-        pass: &mut TrackedRenderPass<'w>,
-    ) {
-        let pipeline = pipeline_cache
-            .into_inner()
-            .get_state(item.pipeline)
-            .unwrap();
-        pass.set_render_pipeline(pipeline);
+    fn entity(&self) -> Entity {
+        self.entity
     }
 }
 
-impl RenderCommand<Transparent2d> for SetItemPipeline {
-    type Param = SRes<RenderPipelineCache>;
+impl CachedPipelinePhaseItem for Transparent3d {
     #[inline]
-    fn render<'w>(
-        _view: Entity,
-        item: &Transparent2d,
-        pipeline_cache: SystemParamItem<'w, '_, Self::Param>,
-        pass: &mut TrackedRenderPass<'w>,
-    ) {
-        let pipeline = pipeline_cache
-            .into_inner()
-            .get_state(item.pipeline)
-            .unwrap();
-        pass.set_render_pipeline(pipeline);
+    fn cached_pipeline(&self) -> CachedPipelineId {
+        self.pipeline
     }
 }
 

pipelined/bevy_pbr2/src/lib.rs

@@ -108,15 +108,10 @@ impl Plugin for PbrPlugin {
             .init_resource::<SpecializedPipelines<PbrPipeline>>()
             .init_resource::<SpecializedPipelines<ShadowPipeline>>();
 
-        let draw_shadow_mesh = DrawShadowMesh::new(&mut render_app.world);
         let shadow_pass_node = ShadowPassNode::new(&mut render_app.world);
         render_app.add_render_command::<Transparent3d, DrawPbr>();
-        let render_world = render_app.world.cell();
-        let draw_functions = render_world
-            .get_resource::<DrawFunctions<Shadow>>()
-            .unwrap();
-        draw_functions.write().add(draw_shadow_mesh);
-        let mut graph = render_world.get_resource_mut::<RenderGraph>().unwrap();
+        render_app.add_render_command::<Shadow, DrawShadowMesh>();
+        let mut graph = render_app.world.get_resource_mut::<RenderGraph>().unwrap();
         let draw_3d_graph = graph
             .get_sub_graph_mut(bevy_core_pipeline::draw_3d_graph::NAME)
             .unwrap();