updated remaining post-processing nodes to make use of the new builder API

updated builder API to support arbitrary attachments
TrackedRenderPass methods can be chained
associated TrackedRenderPass with the view Entity
added render_phase method to TrackedRenderPass
added TrackedRenderPassBuilder
changed set_camera_viewport method to take &Camera instead of &Viewport

Author: kurtkuehnert

crates/bevy_core_pipeline/src/clear_color.rs

@@ -1,6 +1,7 @@
 use bevy_derive::{Deref, DerefMut};
 use bevy_ecs::prelude::*;
 use bevy_reflect::{Reflect, ReflectDeserialize, ReflectSerialize};
+use bevy_render::render_resource::{LoadOp, RawColor};
 use bevy_render::{color::Color, extract_resource::ExtractResource};
 use serde::{Deserialize, Serialize};
 
@@ -13,6 +14,17 @@ pub enum ClearColorConfig {
     None,
 }
 
+impl ClearColorConfig {
+    #[inline]
+    pub fn load_op(&self, world: &World) -> LoadOp<RawColor> {
+        match self {
+            ClearColorConfig::Default => LoadOp::Clear(world.resource::<ClearColor>().0.into()),
+            ClearColorConfig::Custom(color) => LoadOp::Clear((*color).into()),
+            ClearColorConfig::None => LoadOp::Load,
+        }
+    }
+}
+
 /// A [`Resource`] that stores the color that is used to clear the screen between frames.
 ///
 /// This color appears as the "background" color for simple apps,

crates/bevy_core_pipeline/src/core_2d/main_pass_2d_node.rs

@@ -1,13 +1,9 @@
-use crate::{
-    clear_color::{ClearColor, ClearColorConfig},
-    core_2d::{camera_2d::Camera2d, Transparent2d},
-};
+use crate::core_2d::{camera_2d::Camera2d, Transparent2d};
 use bevy_ecs::prelude::*;
 use bevy_render::{
     camera::ExtractedCamera,
     render_graph::{Node, NodeRunError, RenderGraphContext, SlotInfo, SlotType},
     render_phase::RenderPhase,
-    render_resource::{LoadOp, Operations, RenderPassDescriptor},
     renderer::RenderContext,
     view::{ExtractedView, ViewTarget},
 };
@@ -63,46 +59,31 @@ impl Node for MainPass2dNode {
             #[cfg(feature = "trace")]
             let _main_pass_2d = info_span!("main_pass_2d").entered();
 
-            let mut render_pass = render_context.begin_tracked_render_pass(RenderPassDescriptor {
-                label: Some("main_pass_2d"),
-                color_attachments: &[Some(target.get_color_attachment(Operations {
-                    load: match camera_2d.clear_color {
-                        ClearColorConfig::Default => {
-                            LoadOp::Clear(world.resource::<ClearColor>().0.into())
-                        }
-                        ClearColorConfig::Custom(color) => LoadOp::Clear(color.into()),
-                        ClearColorConfig::None => LoadOp::Load,
-                    },
-                    store: true,
-                }))],
-                depth_stencil_attachment: None,
-            });
-
-            if let Some(viewport) = camera.viewport.as_ref() {
-                render_pass.set_camera_viewport(viewport);
-            }
-
-            transparent_phase.render(&mut render_pass, world, view_entity);
+            render_context
+                .render_pass(view_entity)
+                .set_label("main_pass_2d")
+                .add_view_target(target)
+                .set_color_ops(camera_2d.clear_color.load_op(world), true)
+                .begin()
+                .set_camera_viewport(camera)
+                .render_phase(transparent_phase, world);
         }
 
         // WebGL2 quirk: if ending with a render pass with a custom viewport, the viewport isn't
         // reset for the next render pass so add an empty render pass without a custom viewport
         #[cfg(feature = "webgl")]
         if camera.viewport.is_some() {
+            use bevy_render::render_resource::LoadOp;
+
             #[cfg(feature = "trace")]
             let _reset_viewport_pass_2d = info_span!("reset_viewport_pass_2d").entered();
-            let pass_descriptor = RenderPassDescriptor {
-                label: Some("reset_viewport_pass_2d"),
-                color_attachments: &[Some(target.get_color_attachment(Operations {
-                    load: LoadOp::Load,
-                    store: true,
-                }))],
-                depth_stencil_attachment: None,
-            };
 
             render_context
-                .command_encoder()
-                .begin_render_pass(&pass_descriptor);
+                .render_pass(view_entity)
+                .set_label("reset_view_port_pass_2d")
+                .add_view_target(target)
+                .set_color_ops(LoadOp::Load, true)
+                .begin();
         }
 
         Ok(())

crates/bevy_core_pipeline/src/core_3d/main_pass_3d_node.rs

@@ -1,5 +1,4 @@
 use crate::{
-    clear_color::{ClearColor, ClearColorConfig},
     core_3d::{AlphaMask3d, Camera3d, Opaque3d, Transparent3d},
     prepass::{DepthPrepass, NormalPrepass},
 };
@@ -8,15 +7,13 @@ use bevy_render::{
     camera::ExtractedCamera,
     render_graph::{Node, NodeRunError, RenderGraphContext, SlotInfo, SlotType},
     render_phase::RenderPhase,
-    render_resource::{LoadOp, Operations, RenderPassDepthStencilAttachment, RenderPassDescriptor},
+    render_resource::LoadOp,
     renderer::RenderContext,
     view::{ExtractedView, ViewDepthTexture, ViewTarget},
 };
 #[cfg(feature = "trace")]
 use bevy_utils::tracing::info_span;
 
-use super::Camera3dDepthLoadOp;
-
 pub struct MainPass3dNode {
     query: QueryState<
         (
@@ -82,44 +79,24 @@ impl Node for MainPass3dNode {
             #[cfg(feature = "trace")]
             let _main_opaque_pass_3d_span = info_span!("main_opaque_pass_3d").entered();
 
-            let mut render_pass = render_context.begin_tracked_render_pass(RenderPassDescriptor {
-                label: Some("main_opaque_pass_3d"),
-                // NOTE: The opaque pass loads the color
-                // buffer as well as writing to it.
-                color_attachments: &[Some(target.get_color_attachment(Operations {
-                    load: match camera_3d.clear_color {
-                        ClearColorConfig::Default => {
-                            LoadOp::Clear(world.resource::<ClearColor>().0.into())
-                        }
-                        ClearColorConfig::Custom(color) => LoadOp::Clear(color.into()),
-                        ClearColorConfig::None => LoadOp::Load,
-                    },
-                    store: true,
-                }))],
-                depth_stencil_attachment: Some(RenderPassDepthStencilAttachment {
-                    view: &depth.view,
-                    // NOTE: The opaque main pass loads the depth buffer and possibly overwrites it
-                    depth_ops: Some(Operations {
-                        load: if depth_prepass.is_some() || normal_prepass.is_some() {
-                            // if any prepass runs, it will generate a depth buffer so we should use it,
-                            // even if only the normal_prepass is used.
-                            Camera3dDepthLoadOp::Load
-                        } else {
-                            // NOTE: 0.0 is the far plane due to bevy's use of reverse-z projections.
-                            camera_3d.depth_load_op.clone()
-                        }
-                        .into(),
-                        store: true,
-                    }),
-                    stencil_ops: None,
-                }),
-            });
-
-            if let Some(viewport) = camera.viewport.as_ref() {
-                render_pass.set_camera_viewport(viewport);
-            }
-
-            opaque_phase.render(&mut render_pass, world, view_entity);
+            let depth_load_op = if depth_prepass.is_some() || normal_prepass.is_some() {
+                // if any prepass runs, it will generate a depth buffer so we should use it,
+                // even if only the normal_prepass is used.
+                LoadOp::Load
+            } else {
+                camera_3d.depth_load_op.clone().into()
+            };
+
+            render_context
+                .render_pass(view_entity)
+                .set_label("main_opaque_pass_3d")
+                .add_view_target(target)
+                .set_color_ops(camera_3d.clear_color.load_op(world), true)
+                .set_depth_stencil_attachment(&depth.view)
+                .set_depth_ops(depth_load_op, true)
+                .begin()
+                .set_camera_viewport(camera)
+                .render_phase(opaque_phase, world);
         }
 
         if !alpha_mask_phase.items.is_empty() {
@@ -128,29 +105,16 @@ impl Node for MainPass3dNode {
             #[cfg(feature = "trace")]
             let _main_alpha_mask_pass_3d_span = info_span!("main_alpha_mask_pass_3d").entered();
 
-            let mut render_pass = render_context.begin_tracked_render_pass(RenderPassDescriptor {
-                label: Some("main_alpha_mask_pass_3d"),
-                // NOTE: The alpha_mask pass loads the color buffer as well as overwriting it where appropriate.
-                color_attachments: &[Some(target.get_color_attachment(Operations {
-                    load: LoadOp::Load,
-                    store: true,
-                }))],
-                depth_stencil_attachment: Some(RenderPassDepthStencilAttachment {
-                    view: &depth.view,
-                    // NOTE: The alpha mask pass loads the depth buffer and possibly overwrites it
-                    depth_ops: Some(Operations {
-                        load: LoadOp::Load,
-                        store: true,
-                    }),
-                    stencil_ops: None,
-                }),
-            });
-
-            if let Some(viewport) = camera.viewport.as_ref() {
-                render_pass.set_camera_viewport(viewport);
-            }
-
-            alpha_mask_phase.render(&mut render_pass, world, view_entity);
+            render_context
+                .render_pass(view_entity)
+                .set_label("main_alpha_mask_pass_3d")
+                .add_view_target(target)
+                .set_color_ops(LoadOp::Load, true)
+                .set_depth_stencil_attachment(&depth.view)
+                .set_depth_ops(LoadOp::Load, true)
+                .begin()
+                .set_camera_viewport(camera)
+                .render_phase(alpha_mask_phase, world);
         }
 
         if !transparent_phase.items.is_empty() {
@@ -159,34 +123,22 @@ impl Node for MainPass3dNode {
             #[cfg(feature = "trace")]
             let _main_transparent_pass_3d_span = info_span!("main_transparent_pass_3d").entered();
 
-            let mut render_pass = render_context.begin_tracked_render_pass(RenderPassDescriptor {
-                label: Some("main_transparent_pass_3d"),
-                // NOTE: The transparent pass loads the color buffer as well as overwriting it where appropriate.
-                color_attachments: &[Some(target.get_color_attachment(Operations {
-                    load: LoadOp::Load,
-                    store: true,
-                }))],
-                depth_stencil_attachment: Some(RenderPassDepthStencilAttachment {
-                    view: &depth.view,
-                    // NOTE: For the transparent pass we load the depth buffer. There should be no
-                    // need to write to it, but store is set to `true` as a workaround for issue #3776,
-                    // https://github.com/bevyengine/bevy/issues/3776
-                    // so that wgpu does not clear the depth buffer.
-                    // As the opaque and alpha mask passes run first, opaque meshes can occlude
-                    // transparent ones.
-                    depth_ops: Some(Operations {
-                        load: LoadOp::Load,
-                        store: true,
-                    }),
-                    stencil_ops: None,
-                }),
-            });
-
-            if let Some(viewport) = camera.viewport.as_ref() {
-                render_pass.set_camera_viewport(viewport);
-            }
-
-            transparent_phase.render(&mut render_pass, world, view_entity);
+            // NOTE: For the transparent pass we load the depth buffer. There should be no
+            // need to write to it, but store is set to `true` as a workaround for issue #3776,
+            // https://github.com/bevyengine/bevy/issues/3776
+            // so that wgpu does not clear the depth buffer.
+            // As the opaque and alpha mask passes run first, opaque meshes can occlude
+            // transparent ones.
+            render_context
+                .render_pass(view_entity)
+                .set_label("main_transparent_pass_3d")
+                .add_view_target(target)
+                .set_color_ops(LoadOp::Load, true)
+                .set_depth_stencil_attachment(&depth.view)
+                .set_depth_ops(LoadOp::Load, true)
+                .begin()
+                .set_camera_viewport(camera)
+                .render_phase(transparent_phase, world);
         }
 
         // WebGL2 quirk: if ending with a render pass with a custom viewport, the viewport isn't
@@ -195,18 +147,13 @@ impl Node for MainPass3dNode {
         if camera.viewport.is_some() {
             #[cfg(feature = "trace")]
             let _reset_viewport_pass_3d = info_span!("reset_viewport_pass_3d").entered();
-            let pass_descriptor = RenderPassDescriptor {
-                label: Some("reset_viewport_pass_3d"),
-                color_attachments: &[Some(target.get_color_attachment(Operations {
-                    load: LoadOp::Load,
-                    store: true,
-                }))],
-                depth_stencil_attachment: None,
-            };
 
             render_context
-                .command_encoder()
-                .begin_render_pass(&pass_descriptor);
+                .render_pass(view_entity)
+                .set_label("reset_viewport_pass_3d")
+                .add_view_target(target)
+                .set_color_ops(LoadOp::Load, true)
+                .begin();
         }
 
         Ok(())

crates/bevy_core_pipeline/src/fxaa/node.rs

@@ -1,19 +1,16 @@
-use std::sync::Mutex;
-
 use crate::fxaa::{CameraFxaaPipeline, Fxaa, FxaaPipeline};
-use bevy_ecs::prelude::*;
-use bevy_ecs::query::QueryState;
+use bevy_ecs::{prelude::*, query::QueryState};
 use bevy_render::{
     render_graph::{Node, NodeRunError, RenderGraphContext, SlotInfo, SlotType},
     render_resource::{
-        BindGroup, BindGroupDescriptor, BindGroupEntry, BindingResource, FilterMode, Operations,
-        PipelineCache, RenderPassColorAttachment, RenderPassDescriptor, SamplerDescriptor,
-        TextureViewId,
+        BindGroup, BindGroupDescriptor, BindGroupEntry, BindingResource, FilterMode, PipelineCache,
+        SamplerDescriptor, TextureViewId,
     },
     renderer::RenderContext,
     view::{ExtractedView, ViewTarget},
 };
 use bevy_utils::default;
+use std::sync::Mutex;
 
 pub struct FxaaNode {
     query: QueryState<
@@ -109,23 +106,14 @@ impl Node for FxaaNode {
             }
         };
 
-        let pass_descriptor = RenderPassDescriptor {
-            label: Some("fxaa_pass"),
-            color_attachments: &[Some(RenderPassColorAttachment {
-                view: destination,
-                resolve_target: None,
-                ops: Operations::default(),
-            })],
-            depth_stencil_attachment: None,
-        };
-
-        let mut render_pass = render_context
-            .command_encoder()
-            .begin_render_pass(&pass_descriptor);
-
-        render_pass.set_pipeline(pipeline);
-        render_pass.set_bind_group(0, bind_group, &[]);
-        render_pass.draw(0..3, 0..1);
+        render_context
+            .render_pass(view_entity)
+            .set_label("fxaa_pass")
+            .add_color_attachment(destination)
+            .begin()
+            .set_pipeline(pipeline)
+            .set_bind_group(0, bind_group, &[])
+            .draw(0..3, 0..1);
 
         Ok(())
     }

crates/bevy_pbr/src/render/light.rs

@@ -1729,21 +1729,13 @@ impl Node for ShadowPassNode {
                     continue;
                 }
 
-                let mut render_pass =
-                    render_context.begin_tracked_render_pass(RenderPassDescriptor {
-                        label: Some(&view_light.pass_name),
-                        color_attachments: &[],
-                        depth_stencil_attachment: Some(RenderPassDepthStencilAttachment {
-                            view: &view_light.depth_texture_view,
-                            depth_ops: Some(Operations {
-                                load: LoadOp::Clear(0.0),
-                                store: true,
-                            }),
-                            stencil_ops: None,
-                        }),
-                    });
-
-                shadow_phase.render(&mut render_pass, world, view_light_entity);
+                render_context
+                    .render_pass(view_entity)
+                    .set_label(&view_light.pass_name)
+                    .set_depth_stencil_attachment(&view_light.depth_texture_view)
+                    .set_depth_ops(LoadOp::Clear(0.0), true)
+                    .begin()
+                    .render_phase(shadow_phase, world);
             }
         }