merged RenderCommand and Draw

Author: kurtkuehnert

crates/bevy_core_pipeline/src/core_2d/mod.rs

@@ -27,7 +27,7 @@ use bevy_render::{
     render_graph::{EmptyNode, RenderGraph, SlotInfo, SlotType},
     render_phase::{
         batch_phase_system, sort_phase_system, BatchedPhaseItem, CachedRenderPipelinePhaseItem,
-        DrawFunctionId, DrawFunctions, PhaseItem, RenderPhase,
+        PhaseItem, RenderCommandId, RenderCommands, RenderPhase,
     },
     render_resource::CachedRenderPipelineId,
     Extract, RenderApp, RenderStage,
@@ -50,7 +50,7 @@ impl Plugin for Core2dPlugin {
         };
 
         render_app
-            .init_resource::<DrawFunctions<Transparent2d>>()
+            .init_resource::<RenderCommands<Transparent2d>>()
             .add_system_to_stage(RenderStage::Extract, extract_core_2d_camera_phases)
             .add_system_to_stage(RenderStage::PhaseSort, sort_phase_system::<Transparent2d>)
             .add_system_to_stage(
@@ -107,7 +107,7 @@ pub struct Transparent2d {
     pub sort_key: FloatOrd,
     pub entity: Entity,
     pub pipeline: CachedRenderPipelineId,
-    pub draw_function: DrawFunctionId,
+    pub render_command: RenderCommandId,
     /// Range in the vertex buffer of this item
     pub batch_range: Option<Range<u32>>,
 }
@@ -126,8 +126,8 @@ impl PhaseItem for Transparent2d {
     }
 
     #[inline]
-    fn draw_function(&self) -> DrawFunctionId {
-        self.draw_function
+    fn render_command_id(&self) -> RenderCommandId {
+        self.render_command
     }
 
     #[inline]

crates/bevy_core_pipeline/src/core_3d/mod.rs

@@ -30,8 +30,8 @@ use bevy_render::{
     prelude::Msaa,
     render_graph::{EmptyNode, RenderGraph, SlotInfo, SlotType},
     render_phase::{
-        sort_phase_system, CachedRenderPipelinePhaseItem, DrawFunctionId, DrawFunctions, PhaseItem,
-        RenderPhase,
+        sort_phase_system, CachedRenderPipelinePhaseItem, PhaseItem, RenderCommandId,
+        RenderCommands, RenderPhase,
     },
     render_resource::{
         CachedRenderPipelineId, Extent3d, TextureDescriptor, TextureDimension, TextureFormat,
@@ -64,9 +64,9 @@ impl Plugin for Core3dPlugin {
         };
 
         render_app
-            .init_resource::<DrawFunctions<Opaque3d>>()
-            .init_resource::<DrawFunctions<AlphaMask3d>>()
-            .init_resource::<DrawFunctions<Transparent3d>>()
+            .init_resource::<RenderCommands<Opaque3d>>()
+            .init_resource::<RenderCommands<AlphaMask3d>>()
+            .init_resource::<RenderCommands<Transparent3d>>()
             .add_system_to_stage(RenderStage::Extract, extract_core_3d_camera_phases)
             .add_system_to_stage(RenderStage::Prepare, prepare_core_3d_depth_textures)
             .add_system_to_stage(RenderStage::PhaseSort, sort_phase_system::<Opaque3d>)
@@ -132,7 +132,7 @@ pub struct Opaque3d {
     pub distance: f32,
     pub pipeline: CachedRenderPipelineId,
     pub entity: Entity,
-    pub draw_function: DrawFunctionId,
+    pub render_command_id: RenderCommandId,
 }
 
 impl PhaseItem for Opaque3d {
@@ -150,8 +150,8 @@ impl PhaseItem for Opaque3d {
     }
 
     #[inline]
-    fn draw_function(&self) -> DrawFunctionId {
-        self.draw_function
+    fn render_command_id(&self) -> RenderCommandId {
+        self.render_command_id
     }
 
     #[inline]
@@ -172,7 +172,7 @@ pub struct AlphaMask3d {
     pub distance: f32,
     pub pipeline: CachedRenderPipelineId,
     pub entity: Entity,
-    pub draw_function: DrawFunctionId,
+    pub render_command_id: RenderCommandId,
 }
 
 impl PhaseItem for AlphaMask3d {
@@ -190,8 +190,8 @@ impl PhaseItem for AlphaMask3d {
     }
 
     #[inline]
-    fn draw_function(&self) -> DrawFunctionId {
-        self.draw_function
+    fn render_command_id(&self) -> RenderCommandId {
+        self.render_command_id
     }
 
     #[inline]
@@ -212,7 +212,7 @@ pub struct Transparent3d {
     pub distance: f32,
     pub pipeline: CachedRenderPipelineId,
     pub entity: Entity,
-    pub draw_function: DrawFunctionId,
+    pub render_command_id: RenderCommandId,
 }
 
 impl PhaseItem for Transparent3d {
@@ -230,8 +230,8 @@ impl PhaseItem for Transparent3d {
     }
 
     #[inline]
-    fn draw_function(&self) -> DrawFunctionId {
-        self.draw_function
+    fn render_command_id(&self) -> RenderCommandId {
+        self.render_command_id
     }
 
     #[inline]

crates/bevy_core_pipeline/src/prepass/mod.rs

@@ -28,8 +28,9 @@ pub mod node;
 
 use bevy_ecs::prelude::*;
 use bevy_reflect::Reflect;
+use bevy_render::render_phase::RenderCommandId;
 use bevy_render::{
-    render_phase::{CachedRenderPipelinePhaseItem, DrawFunctionId, PhaseItem},
+    render_phase::{CachedRenderPipelinePhaseItem, PhaseItem},
     render_resource::{CachedRenderPipelineId, Extent3d, TextureFormat},
     texture::CachedTexture,
 };
@@ -71,7 +72,7 @@ pub struct Opaque3dPrepass {
     pub distance: f32,
     pub entity: Entity,
     pub pipeline_id: CachedRenderPipelineId,
-    pub draw_function: DrawFunctionId,
+    pub render_command_id: RenderCommandId,
 }
 
 impl PhaseItem for Opaque3dPrepass {
@@ -87,8 +88,8 @@ impl PhaseItem for Opaque3dPrepass {
     }
 
     #[inline]
-    fn draw_function(&self) -> DrawFunctionId {
-        self.draw_function
+    fn render_command_id(&self) -> RenderCommandId {
+        self.render_command_id
     }
 
     #[inline]
@@ -113,7 +114,7 @@ pub struct AlphaMask3dPrepass {
     pub distance: f32,
     pub entity: Entity,
     pub pipeline_id: CachedRenderPipelineId,
-    pub draw_function: DrawFunctionId,
+    pub render_command_id: RenderCommandId,
 }
 
 impl PhaseItem for AlphaMask3dPrepass {
@@ -129,8 +130,8 @@ impl PhaseItem for AlphaMask3dPrepass {
     }
 
     #[inline]
-    fn draw_function(&self) -> DrawFunctionId {
-        self.draw_function
+    fn render_command_id(&self) -> RenderCommandId {
+        self.render_command_id
     }
 
     #[inline]

crates/bevy_pbr/src/lib.rs

@@ -49,7 +49,7 @@ use bevy_render::{
     extract_resource::ExtractResourcePlugin,
     prelude::Color,
     render_graph::RenderGraph,
-    render_phase::{sort_phase_system, AddRenderCommand, DrawFunctions},
+    render_phase::{sort_phase_system, AddRenderCommand, RenderCommands},
     render_resource::{Shader, SpecializedMeshPipelines},
     view::VisibilitySystems,
     RenderApp, RenderStage,
@@ -268,7 +268,7 @@ impl Plugin for PbrPlugin {
             .add_system_to_stage(RenderStage::Queue, render::queue_shadow_view_bind_group)
             .add_system_to_stage(RenderStage::PhaseSort, sort_phase_system::<Shadow>)
             .init_resource::<ShadowPipeline>()
-            .init_resource::<DrawFunctions<Shadow>>()
+            .init_resource::<RenderCommands<Shadow>>()
             .init_resource::<LightMeta>()
             .init_resource::<GlobalLightMeta>()
             .init_resource::<SpecializedMeshPipelines<ShadowPipeline>>();

crates/bevy_pbr/src/material.rs

@@ -26,7 +26,7 @@ use bevy_render::{
     prelude::Image,
     render_asset::{PrepareAssetLabel, RenderAssets},
     render_phase::{
-        AddRenderCommand, DrawFunctions, PhaseItem, RenderCommand, RenderCommandResult,
+        AddRenderCommand, PhaseItem, RenderCommand, RenderCommandResult, RenderCommands,
         RenderPhase, SetItemPipeline, TrackedRenderPass,
     },
     render_resource::{
@@ -357,9 +357,9 @@ impl<P: PhaseItem, M: Material, const I: usize> RenderCommand<P> for SetMaterial
 
 #[allow(clippy::too_many_arguments)]
 pub fn queue_material_meshes<M: Material>(
-    opaque_draw_functions: Res<DrawFunctions<Opaque3d>>,
-    alpha_mask_draw_functions: Res<DrawFunctions<AlphaMask3d>>,
-    transparent_draw_functions: Res<DrawFunctions<Transparent3d>>,
+    opaque_render_commands: Res<RenderCommands<Opaque3d>>,
+    alpha_mask_render_commands: Res<RenderCommands<AlphaMask3d>>,
+    transparent_render_commands: Res<RenderCommands<Transparent3d>>,
     material_pipeline: Res<MaterialPipeline<M>>,
     mut pipelines: ResMut<SpecializedMeshPipelines<MaterialPipeline<M>>>,
     pipeline_cache: Res<PipelineCache>,
@@ -387,9 +387,9 @@ pub fn queue_material_meshes<M: Material>(
         mut transparent_phase,
     ) in &mut views
     {
-        let draw_opaque_pbr = opaque_draw_functions.read().id::<DrawMaterial<M>>();
-        let draw_alpha_mask_pbr = alpha_mask_draw_functions.read().id::<DrawMaterial<M>>();
-        let draw_transparent_pbr = transparent_draw_functions.read().id::<DrawMaterial<M>>();
+        let draw_opaque_pbr = opaque_render_commands.id::<DrawMaterial<M>>();
+        let draw_alpha_mask_pbr = alpha_mask_render_commands.id::<DrawMaterial<M>>();
+        let draw_transparent_pbr = transparent_render_commands.id::<DrawMaterial<M>>();
 
         let mut view_key =
             MeshPipelineKey::from_msaa_samples(msaa.samples) | MeshPipelineKey::from_hdr(view.hdr);
@@ -442,23 +442,23 @@ pub fn queue_material_meshes<M: Material>(
                             AlphaMode::Opaque => {
                                 opaque_phase.add(Opaque3d {
                                     entity: *visible_entity,
-                                    draw_function: draw_opaque_pbr,
+                                    render_command_id: draw_opaque_pbr,
                                     pipeline: pipeline_id,
                                     distance,
                                 });
                             }
                             AlphaMode::Mask(_) => {
                                 alpha_mask_phase.add(AlphaMask3d {
                                     entity: *visible_entity,
-                                    draw_function: draw_alpha_mask_pbr,
+                                    render_command_id: draw_alpha_mask_pbr,
                                     pipeline: pipeline_id,
                                     distance,
                                 });
                             }
                             AlphaMode::Blend => {
                                 transparent_phase.add(Transparent3d {
                                     entity: *visible_entity,
-                                    draw_function: draw_transparent_pbr,
+                                    render_command_id: draw_transparent_pbr,
                                     pipeline: pipeline_id,
                                     distance,
                                 });

crates/bevy_pbr/src/prepass/mod.rs

@@ -23,8 +23,8 @@ use bevy_render::{
     prelude::{Camera, Mesh},
     render_asset::RenderAssets,
     render_phase::{
-        sort_phase_system, AddRenderCommand, DrawFunctions, PhaseItem, RenderCommand,
-        RenderCommandResult, RenderPhase, SetItemPipeline, TrackedRenderPass,
+        sort_phase_system, AddRenderCommand, PhaseItem, RenderCommand, RenderCommandResult,
+        RenderCommands, RenderPhase, SetItemPipeline, TrackedRenderPass,
     },
     render_resource::{
         BindGroup, BindGroupDescriptor, BindGroupEntry, BindGroupLayout, BindGroupLayoutDescriptor,
@@ -99,8 +99,8 @@ where
                 sort_phase_system::<AlphaMask3dPrepass>,
             )
             .init_resource::<PrepassPipeline<M>>()
-            .init_resource::<DrawFunctions<Opaque3dPrepass>>()
-            .init_resource::<DrawFunctions<AlphaMask3dPrepass>>()
+            .init_resource::<RenderCommands<Opaque3dPrepass>>()
+            .init_resource::<RenderCommands<AlphaMask3dPrepass>>()
             .init_resource::<PrepassViewBindGroup>()
             .init_resource::<SpecializedMeshPipelines<PrepassPipeline<M>>>()
             .add_render_command::<Opaque3dPrepass, DrawPrepass<M>>()
@@ -462,8 +462,8 @@ pub fn queue_prepass_view_bind_group<M: Material>(
 
 #[allow(clippy::too_many_arguments)]
 pub fn queue_prepass_material_meshes<M: Material>(
-    opaque_draw_functions: Res<DrawFunctions<Opaque3dPrepass>>,
-    alpha_mask_draw_functions: Res<DrawFunctions<AlphaMask3dPrepass>>,
+    opaque_render_commands: Res<RenderCommands<Opaque3dPrepass>>,
+    alpha_mask_render_commands: Res<RenderCommands<AlphaMask3dPrepass>>,
     prepass_pipeline: Res<PrepassPipeline<M>>,
     mut pipelines: ResMut<SpecializedMeshPipelines<PrepassPipeline<M>>>,
     pipeline_cache: Res<PipelineCache>,
@@ -482,14 +482,9 @@ pub fn queue_prepass_material_meshes<M: Material>(
 ) where
     M::Data: PartialEq + Eq + Hash + Clone,
 {
-    let opaque_draw_prepass = opaque_draw_functions
-        .read()
-        .get_id::<DrawPrepass<M>>()
-        .unwrap();
-    let alpha_mask_draw_prepass = alpha_mask_draw_functions
-        .read()
-        .get_id::<DrawPrepass<M>>()
-        .unwrap();
+    let opaque_draw_prepass = opaque_render_commands.id::<DrawPrepass<M>>();
+    let alpha_mask_draw_prepass = alpha_mask_render_commands.id::<DrawPrepass<M>>();
+
     for (
         view,
         visible_entities,
@@ -553,15 +548,15 @@ pub fn queue_prepass_material_meshes<M: Material>(
                 AlphaMode::Opaque => {
                     opaque_phase.add(Opaque3dPrepass {
                         entity: *visible_entity,
-                        draw_function: opaque_draw_prepass,
+                        render_command_id: opaque_draw_prepass,
                         pipeline_id,
                         distance,
                     });
                 }
                 AlphaMode::Mask(_) => {
                     alpha_mask_phase.add(AlphaMask3dPrepass {
                         entity: *visible_entity,
-                        draw_function: alpha_mask_draw_prepass,
+                        render_command_id: alpha_mask_draw_prepass,
                         pipeline_id,
                         distance,
                     });

crates/bevy_pbr/src/render/light.rs

@@ -18,8 +18,8 @@ use bevy_render::{
     render_asset::RenderAssets,
     render_graph::{Node, NodeRunError, RenderGraphContext, SlotInfo, SlotType},
     render_phase::{
-        CachedRenderPipelinePhaseItem, DrawFunctionId, DrawFunctions, PhaseItem, RenderCommand,
-        RenderCommandResult, RenderPhase, SetItemPipeline, TrackedRenderPass,
+        CachedRenderPipelinePhaseItem, PhaseItem, RenderCommand, RenderCommandId,
+        RenderCommandResult, RenderCommands, RenderPhase, SetItemPipeline, TrackedRenderPass,
     },
     render_resource::*,
     renderer::{RenderContext, RenderDevice, RenderQueue},
@@ -1621,7 +1621,7 @@ pub fn queue_shadow_view_bind_group(
 
 #[allow(clippy::too_many_arguments)]
 pub fn queue_shadows(
-    shadow_draw_functions: Res<DrawFunctions<Shadow>>,
+    shadow_render_commands: Res<RenderCommands<Shadow>>,
     shadow_pipeline: Res<ShadowPipeline>,
     casting_meshes: Query<&Handle<Mesh>, Without<NotShadowCaster>>,
     render_meshes: Res<RenderAssets<Mesh>>,
@@ -1634,7 +1634,7 @@ pub fn queue_shadows(
     spot_light_entities: Query<&VisibleEntities, With<ExtractedPointLight>>,
 ) {
     for view_lights in &view_lights {
-        let draw_shadow_mesh = shadow_draw_functions.read().id::<DrawShadowMesh>();
+        let draw_shadow_mesh = shadow_render_commands.id::<DrawShadowMesh>();
         for view_light_entity in view_lights.lights.iter().copied() {
             let (light_entity, mut shadow_phase) =
                 view_light_shadow_phases.get_mut(view_light_entity).unwrap();
@@ -1676,7 +1676,7 @@ pub fn queue_shadows(
                         };
 
                         shadow_phase.add(Shadow {
-                            draw_function: draw_shadow_mesh,
+                            render_command: draw_shadow_mesh,
                             pipeline: pipeline_id,
                             entity,
                             distance: 0.0, // TODO: sort back-to-front
@@ -1692,7 +1692,7 @@ pub struct Shadow {
     pub distance: f32,
     pub entity: Entity,
     pub pipeline: CachedRenderPipelineId,
-    pub draw_function: DrawFunctionId,
+    pub render_command: RenderCommandId,
 }
 
 impl PhaseItem for Shadow {
@@ -1709,8 +1709,8 @@ impl PhaseItem for Shadow {
     }
 
     #[inline]
-    fn draw_function(&self) -> DrawFunctionId {
-        self.draw_function
+    fn render_command_id(&self) -> RenderCommandId {
+        self.render_command
     }
 
     #[inline]