updated builder API to support arbitrary attachments

improved docs

Author: kurtkuehnert

crates/bevy_core_pipeline/src/bloom/mod.rs

@@ -239,19 +239,12 @@ impl Node for BloomNode {
 
         {
             let view = &BloomTextures::texture_view(&textures.texture_a, 0);
-            let mut prefilter_pass = render_context.begin_tracked_render_pass(
-                RenderPassDescriptor {
-                    label: Some("bloom_prefilter_pass"),
-                    color_attachments: &[Some(RenderPassColorAttachment {
-                        view,
-                        resolve_target: None,
-                        ops: Operations::default(),
-                    })],
-                    depth_stencil_attachment: None,
-                },
-                view_entity,
-            );
-            prefilter_pass
+
+            render_context
+                .render_pass(view_entity)
+                .set_label("bloom_prefilter_pass")
+                .add_color_attachment(view)
+                .begin()
                 .set_camera_viewport(camera)
                 .set_render_pipeline(downsampling_prefilter_pipeline)
                 .set_bind_group(
@@ -264,19 +257,12 @@ impl Node for BloomNode {
 
         for mip in 1..textures.mip_count {
             let view = &BloomTextures::texture_view(&textures.texture_a, mip);
-            let mut downsampling_pass = render_context.begin_tracked_render_pass(
-                RenderPassDescriptor {
-                    label: Some("bloom_downsampling_pass"),
-                    color_attachments: &[Some(RenderPassColorAttachment {
-                        view,
-                        resolve_target: None,
-                        ops: Operations::default(),
-                    })],
-                    depth_stencil_attachment: None,
-                },
-                view_entity,
-            );
-            downsampling_pass
+
+            render_context
+                .render_pass(view_entity)
+                .set_label("bloom_downsampling_pass")
+                .add_color_attachment(view)
+                .begin()
                 .set_camera_viewport(camera)
                 .set_render_pipeline(downsampling_pipeline)
                 .set_bind_group(
@@ -289,19 +275,12 @@ impl Node for BloomNode {
 
         for mip in (1..textures.mip_count).rev() {
             let view = &BloomTextures::texture_view(&textures.texture_b, mip - 1);
-            let mut upsampling_pass = render_context.begin_tracked_render_pass(
-                RenderPassDescriptor {
-                    label: Some("bloom_upsampling_pass"),
-                    color_attachments: &[Some(RenderPassColorAttachment {
-                        view,
-                        resolve_target: None,
-                        ops: Operations::default(),
-                    })],
-                    depth_stencil_attachment: None,
-                },
-                view_entity,
-            );
-            upsampling_pass
+
+            render_context
+                .render_pass(view_entity)
+                .set_label("bloom_upsampling_pass")
+                .add_color_attachment(view)
+                .begin()
                 .set_camera_viewport(camera)
                 .set_render_pipeline(upsampling_pipeline)
                 .set_bind_group(
@@ -313,20 +292,12 @@ impl Node for BloomNode {
         }
 
         {
-            let mut upsampling_final_pass = render_context.begin_tracked_render_pass(
-                RenderPassDescriptor {
-                    label: Some("bloom_upsampling_final_pass"),
-                    color_attachments: &[Some(view_target.get_unsampled_color_attachment(
-                        Operations {
-                            load: LoadOp::Load,
-                            store: true,
-                        },
-                    ))],
-                    depth_stencil_attachment: None,
-                },
-                view_entity,
-            );
-            upsampling_final_pass
+            render_context
+                .render_pass(view_entity)
+                .set_label("bloom_upsampling_final_pass")
+                .add_view_target_unsampled(view_target)
+                .set_color_ops(LoadOp::Load, true)
+                .begin()
                 .set_camera_viewport(camera)
                 .set_render_pipeline(upsampling_final_pipeline)
                 .set_bind_group(

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,
     renderer::RenderContext,
     view::{ExtractedView, ViewTarget},
 };
@@ -63,22 +59,12 @@ impl Node for MainPass2dNode {
             #[cfg(feature = "trace")]
             let _main_pass_2d = info_span!("main_pass_2d").entered();
 
-            let mut render_pass = target
-                .render_pass(view_entity, None)
-                .label("main_pass_2d")
-                .color_ops(
-                    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,
-                    },
-                    true,
-                )
-                .begin(render_context);
-
-            render_pass
+            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);
         }
@@ -87,14 +73,17 @@ impl Node for MainPass2dNode {
         // 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();
 
-            target
-                .render_pass(view_entity, None)
-                .label("reset_view_port_pass_2d")
-                .color_ops(LoadOp::Load, true)
-                .begin(render_context);
+            render_context
+                .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},
 };
@@ -15,8 +14,6 @@ use bevy_render::{
 #[cfg(feature = "trace")]
 use bevy_utils::tracing::info_span;
 
-use super::Camera3dDepthLoadOp;
-
 pub struct MainPass3dNode {
     query: QueryState<
         (
@@ -82,33 +79,22 @@ impl Node for MainPass3dNode {
             #[cfg(feature = "trace")]
             let _main_opaque_pass_3d_span = info_span!("main_opaque_pass_3d").entered();
 
-            let mut render_pass = target
-                .render_pass(view_entity, Some(depth))
-                .label("main_opaque_pass_3d")
-                .color_ops(
-                    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,
-                    },
-                    true,
-                )
-                .depth_ops(
-                    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(),
-                    true,
-                )
-                .begin(render_context);
-            render_pass
+            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);
         }
@@ -119,13 +105,14 @@ 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 = target
-                .render_pass(view_entity, Some(depth))
-                .label("main_alpha_mask_pass_3d")
-                .color_ops(LoadOp::Load, true)
-                .depth_ops(LoadOp::Load, true)
-                .begin(render_context);
-            render_pass
+            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);
         }
@@ -142,13 +129,14 @@ impl Node for MainPass3dNode {
             // so that wgpu does not clear the depth buffer.
             // As the opaque and alpha mask passes run first, opaque meshes can occlude
             // transparent ones.
-            let mut render_pass = target
-                .render_pass(view_entity, Some(depth))
-                .label("main_transparent_pass_3d")
-                .color_ops(LoadOp::Load, true)
-                .depth_ops(LoadOp::Load, true)
-                .begin(render_context);
-            render_pass
+            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);
         }
@@ -160,11 +148,12 @@ impl Node for MainPass3dNode {
             #[cfg(feature = "trace")]
             let _reset_viewport_pass_3d = info_span!("reset_viewport_pass_3d").entered();
 
-            target
-                .render_pass(view_entity, None)
-                .label("reset_viewport_pass_3d")
-                .color_ops(LoadOp::Load, true)
-                .begin(render_context);
+            render_context
+                .render_pass(view_entity)
+                .set_label("reset_viewport_pass_3d")
+                .add_view_target(target)
+                .set_color_ops(LoadOp::Load, true)
+                .begin();
         }
 
         Ok(())