Keep track of when a texture is first cleared

crates/bevy_core_pipeline/src/bloom/mod.rs

@@ -265,12 +265,7 @@ impl ViewNode 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: StoreOp::Store,
-                        },
-                    ))],
+                    color_attachments: &[Some(view_target.get_unsampled_color_attachment())],
                     depth_stencil_attachment: None,
                     timestamp_writes: None,
                     occlusion_query_set: None,

crates/bevy_core_pipeline/src/core_2d/camera_2d.rs

@@ -1,7 +1,4 @@
-use crate::{
-    clear_color::ClearColorConfig,
-    tonemapping::{DebandDither, Tonemapping},
-};
+use crate::tonemapping::{DebandDither, Tonemapping};
 use bevy_ecs::prelude::*;
 use bevy_reflect::Reflect;
 use bevy_render::{
@@ -15,9 +12,7 @@ use bevy_transform::prelude::{GlobalTransform, Transform};
 #[derive(Component, Default, Reflect, Clone, ExtractComponent)]
 #[extract_component_filter(With<Camera>)]
 #[reflect(Component)]
-pub struct Camera2d {
-    pub clear_color: ClearColorConfig,
-}
+pub struct Camera2d {}
 
 #[derive(Bundle)]
 pub struct Camera2dBundle {

crates/bevy_core_pipeline/src/core_2d/main_pass_2d_node.rs

@@ -1,13 +1,10 @@
-use crate::{
-    clear_color::{ClearColor, ClearColorConfig},
-    core_2d::{camera_2d::Camera2d, Transparent2d},
-};
+use crate::core_2d::Transparent2d;
 use bevy_ecs::prelude::*;
 use bevy_render::{
     camera::ExtractedCamera,
     render_graph::{Node, NodeRunError, RenderGraphContext},
     render_phase::RenderPhase,
-    render_resource::{LoadOp, Operations, RenderPassDescriptor, StoreOp},
+    render_resource::RenderPassDescriptor,
     renderer::RenderContext,
     view::{ExtractedView, ViewTarget},
 };
@@ -20,7 +17,6 @@ pub struct MainPass2dNode {
             &'static ExtractedCamera,
             &'static RenderPhase<Transparent2d>,
             &'static ViewTarget,
-            &'static Camera2d,
         ),
         With<ExtractedView>,
     >,
@@ -46,28 +42,19 @@ impl Node for MainPass2dNode {
         world: &World,
     ) -> Result<(), NodeRunError> {
         let view_entity = graph.view_entity();
-        let Ok((camera, transparent_phase, target, camera_2d)) =
-            self.query.get_manual(world, view_entity)
+        let Ok((camera, transparent_phase, target)) = self.query.get_manual(world, view_entity)
         else {
             // no target
             return Ok(());
         };
+
         {
             #[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: StoreOp::Store,
-                }))],
+                color_attachments: &[Some(target.get_color_attachment())],
                 depth_stencil_attachment: None,
                 timestamp_writes: None,
                 occlusion_query_set: None,
@@ -88,13 +75,8 @@ impl Node for MainPass2dNode {
             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: StoreOp::Store,
-                }))],
+                color_attachments: &[Some(target.get_color_attachment())],
                 depth_stencil_attachment: None,
-                timestamp_writes: None,
-                occlusion_query_set: None,
             };
 
             render_context

crates/bevy_core_pipeline/src/core_3d/camera_3d.rs

@@ -1,7 +1,4 @@
-use crate::{
-    clear_color::ClearColorConfig,
-    tonemapping::{DebandDither, Tonemapping},
-};
+use crate::tonemapping::{DebandDither, Tonemapping};
 use bevy_ecs::prelude::*;
 use bevy_reflect::{Reflect, ReflectDeserialize, ReflectSerialize};
 use bevy_render::{
@@ -19,8 +16,6 @@ use serde::{Deserialize, Serialize};
 #[extract_component_filter(With<Camera>)]
 #[reflect(Component)]
 pub struct Camera3d {
-    /// The clear color operation to perform for the main 3d pass.
-    pub clear_color: ClearColorConfig,
     /// The depth clear operation to perform for the main 3d pass.
     pub depth_load_op: Camera3dDepthLoadOp,
     /// The texture usages for the depth texture created for the main 3d pass.
@@ -55,7 +50,6 @@ pub struct Camera3d {
 impl Default for Camera3d {
     fn default() -> Self {
         Self {
-            clear_color: ClearColorConfig::Default,
             depth_load_op: Default::default(),
             depth_texture_usages: TextureUsages::RENDER_ATTACHMENT.into(),
             screen_space_specular_transmission_steps: 1,

crates/bevy_core_pipeline/src/core_3d/main_opaque_pass_3d_node.rs

@@ -1,25 +1,20 @@
 use crate::{
-    clear_color::{ClearColor, ClearColorConfig},
-    core_3d::{Camera3d, Opaque3d},
-    prepass::{DeferredPrepass, DepthPrepass, MotionVectorPrepass, NormalPrepass},
+    core_3d::Opaque3d,
     skybox::{SkyboxBindGroup, SkyboxPipelineId},
 };
 use bevy_ecs::{prelude::*, query::QueryItem};
 use bevy_render::{
     camera::ExtractedCamera,
     render_graph::{NodeRunError, RenderGraphContext, ViewNode},
     render_phase::RenderPhase,
-    render_resource::{
-        LoadOp, Operations, PipelineCache, RenderPassDepthStencilAttachment, RenderPassDescriptor,
-        StoreOp,
-    },
+    render_resource::{PipelineCache, RenderPassDescriptor, StoreOp},
     renderer::RenderContext,
     view::{ViewDepthTexture, ViewTarget, ViewUniformOffset},
 };
 #[cfg(feature = "trace")]
 use bevy_utils::tracing::info_span;
 
-use super::{AlphaMask3d, Camera3dDepthLoadOp};
+use super::AlphaMask3d;
 
 /// A [`bevy_render::render_graph::Node`] that runs the [`Opaque3d`] and [`AlphaMask3d`] [`RenderPhase`].
 #[derive(Default)]
@@ -29,13 +24,8 @@ impl ViewNode for MainOpaquePass3dNode {
         &'static ExtractedCamera,
         &'static RenderPhase<Opaque3d>,
         &'static RenderPhase<AlphaMask3d>,
-        &'static Camera3d,
         &'static ViewTarget,
         &'static ViewDepthTexture,
-        Option<&'static DepthPrepass>,
-        Option<&'static NormalPrepass>,
-        Option<&'static MotionVectorPrepass>,
-        Option<&'static DeferredPrepass>,
         Option<&'static SkyboxPipelineId>,
         Option<&'static SkyboxBindGroup>,
         &'static ViewUniformOffset,
@@ -49,30 +39,14 @@ impl ViewNode for MainOpaquePass3dNode {
             camera,
             opaque_phase,
             alpha_mask_phase,
-            camera_3d,
             target,
             depth,
-            depth_prepass,
-            normal_prepass,
-            motion_vector_prepass,
-            deferred_prepass,
             skybox_pipeline,
             skybox_bind_group,
             view_uniform_offset,
         ): QueryItem<Self::ViewData>,
         world: &World,
     ) -> Result<(), NodeRunError> {
-        let load = if deferred_prepass.is_none() {
-            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,
-            }
-        } else {
-            // If the deferred lighting pass has run, don't clear again in this pass.
-            LoadOp::Load
-        };
-
         // Run the opaque pass, sorted front-to-back
         // NOTE: Scoped to drop the mutable borrow of render_context
         #[cfg(feature = "trace")]
@@ -81,33 +55,8 @@ impl ViewNode for MainOpaquePass3dNode {
         // Setup render pass
         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,
-                store: StoreOp::Store,
-            }))],
-            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()
-                        || motion_vector_prepass.is_some()
-                        || deferred_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: StoreOp::Store,
-                }),
-                stencil_ops: None,
-            }),
+            color_attachments: &[Some(target.get_color_attachment())],
+            depth_stencil_attachment: Some(depth.get_attachment(StoreOp::Store)),
             timestamp_writes: None,
             occlusion_query_set: None,
         });

crates/bevy_core_pipeline/src/core_3d/main_transmissive_pass_3d_node.rs

@@ -5,10 +5,7 @@ use bevy_render::{
     camera::ExtractedCamera,
     render_graph::{NodeRunError, RenderGraphContext, ViewNode},
     render_phase::RenderPhase,
-    render_resource::{
-        Extent3d, LoadOp, Operations, RenderPassDepthStencilAttachment, RenderPassDescriptor,
-        StoreOp,
-    },
+    render_resource::{Extent3d, RenderPassDescriptor, StoreOp},
     renderer::RenderContext,
     view::{ViewDepthTexture, ViewTarget},
 };
@@ -45,20 +42,8 @@ impl ViewNode for MainTransmissivePass3dNode {
 
         let render_pass_descriptor = RenderPassDescriptor {
             label: Some("main_transmissive_pass_3d"),
-            // NOTE: The transmissive pass loads the color buffer as well as overwriting it where appropriate.
-            color_attachments: &[Some(target.get_color_attachment(Operations {
-                load: LoadOp::Load,
-                store: StoreOp::Store,
-            }))],
-            depth_stencil_attachment: Some(RenderPassDepthStencilAttachment {
-                view: &depth.view,
-                // NOTE: The transmissive main pass loads the depth buffer and possibly overwrites it
-                depth_ops: Some(Operations {
-                    load: LoadOp::Load,
-                    store: StoreOp::Store,
-                }),
-                stencil_ops: None,
-            }),
+            color_attachments: &[Some(target.get_color_attachment())],
+            depth_stencil_attachment: Some(depth.get_attachment(StoreOp::Store)),
             timestamp_writes: None,
             occlusion_query_set: None,
         };

crates/bevy_core_pipeline/src/core_3d/main_transparent_pass_3d_node.rs

@@ -4,9 +4,7 @@ use bevy_render::{
     camera::ExtractedCamera,
     render_graph::{NodeRunError, RenderGraphContext, ViewNode},
     render_phase::RenderPhase,
-    render_resource::{
-        LoadOp, Operations, RenderPassDepthStencilAttachment, RenderPassDescriptor, StoreOp,
-    },
+    render_resource::{RenderPassDescriptor, StoreOp},
     renderer::RenderContext,
     view::{ViewDepthTexture, ViewTarget},
 };
@@ -41,25 +39,14 @@ impl ViewNode for MainTransparentPass3dNode {
 
             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: StoreOp::Store,
-                }))],
-                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: StoreOp::Store,
-                    }),
-                    stencil_ops: None,
-                }),
+                color_attachments: &[Some(target.get_color_attachment())],
+                // 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_stencil_attachment: Some(depth.get_attachment(StoreOp::Store)),
                 timestamp_writes: None,
                 occlusion_query_set: None,
             });
@@ -79,13 +66,8 @@ impl ViewNode for MainTransparentPass3dNode {
             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: StoreOp::Store,
-                }))],
+                color_attachments: &[Some(target.get_color_attachment())],
                 depth_stencil_attachment: None,
-                timestamp_writes: None,
-                occlusion_query_set: None,
             };
 
             render_context

crates/bevy_core_pipeline/src/core_3d/mod.rs

@@ -42,6 +42,7 @@ use bevy_app::{App, Plugin, PostUpdate};
 use bevy_ecs::prelude::*;
 use bevy_render::{
     camera::{Camera, ExtractedCamera},
+    color::Color,
     extract_component::ExtractComponentPlugin,
     prelude::Msaa,
     render_graph::{EmptyNode, RenderGraphApp, ViewNodeRunner},
@@ -54,7 +55,7 @@ use bevy_render::{
         TextureDescriptor, TextureDimension, TextureFormat, TextureUsages, TextureView,
     },
     renderer::RenderDevice,
-    texture::{BevyDefault, TextureCache},
+    texture::{BevyDefault, ColorAttachment, TextureCache},
     view::{ExtractedView, ViewDepthTexture, ViewTarget},
     Extract, ExtractSchedule, Render, RenderApp, RenderSet,
 };
@@ -526,7 +527,7 @@ pub fn prepare_core_3d_depth_textures(
     }
 
     let mut textures = HashMap::default();
-    for (entity, camera, _, _) in &views_3d {
+    for (entity, camera, _, camera_3d) in &views_3d {
         let Some(physical_target_size) = camera.physical_target_size else {
             continue;
         };
@@ -560,10 +561,13 @@ pub fn prepare_core_3d_depth_textures(
             })
             .clone();
 
-        commands.entity(entity).insert(ViewDepthTexture {
-            texture: cached_texture.texture,
-            view: cached_texture.default_view,
-        });
+        commands.entity(entity).insert(ViewDepthTexture::new(
+            cached_texture,
+            match camera_3d.depth_load_op {
+                Camera3dDepthLoadOp::Clear(v) => Some(v),
+                Camera3dDepthLoadOp::Load => None,
+            },
+        ));
     }
 }
 
@@ -824,10 +828,14 @@ pub fn prepare_prepass_textures(
         });
 
         commands.entity(entity).insert(ViewPrepassTextures {
-            depth: cached_depth_texture,
-            normal: cached_normals_texture,
-            motion_vectors: cached_motion_vectors_texture,
-            deferred: cached_deferred_texture,
+            depth: cached_depth_texture.map(|t| ColorAttachment::new(t, None, Color::BLACK)),
+            normal: cached_normals_texture.map(|t| ColorAttachment::new(t, None, Color::BLACK)),
+            // Red and Green channels are X and Y components of the motion vectors
+            // Blue channel doesn't matter, but set to 0.0 for possible faster clear
+            // https://gpuopen.com/performance/#clears
+            motion_vectors: cached_motion_vectors_texture
+                .map(|t| ColorAttachment::new(t, None, Color::BLACK)),
+            deferred: cached_deferred_texture.map(|t| ColorAttachment::new(t, None, Color::BLACK)),
             deferred_lighting_pass_id: deferred_lighting_pass_id_texture,
             size,
         });