Keep track of when a texture is first cleared

crates/bevy_core_pipeline/src/core_3d/main_opaque_pass_3d_node.rs

@@ -31,10 +31,6 @@ impl ViewNode for MainOpaquePass3dNode {
         &'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,
@@ -51,24 +47,19 @@ impl ViewNode for MainOpaquePass3dNode {
             camera_3d,
             target,
             depth,
-            depth_prepass,
-            normal_prepass,
-            motion_vector_prepass,
-            deferred_prepass,
             skybox_pipeline,
             skybox_bind_group,
             view_uniform_offset,
         ): QueryItem<Self::ViewQuery>,
         world: &World,
     ) -> Result<(), NodeRunError> {
-        let load = if deferred_prepass.is_none() {
+        let load = if target.is_first_write() {
             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
         };
 
@@ -89,17 +80,11 @@ impl ViewNode for MainOpaquePass3dNode {
                 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 {
+                    load: if depth.is_first_write() {
                         // NOTE: 0.0 is the far plane due to bevy's use of reverse-z projections.
                         camera_3d.depth_load_op.clone()
+                    } else {
+                        Camera3dDepthLoadOp::Load
                     }
                     .into(),
                     store: true,

crates/bevy_core_pipeline/src/core_3d/mod.rs

@@ -477,10 +477,10 @@ 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.texture,
+            cached_texture.default_view,
+        ));
     }
 }
 

crates/bevy_core_pipeline/src/deferred/node.rs

@@ -36,7 +36,6 @@ impl ViewNode for DeferredGBufferPrepassNode {
         &'static ViewDepthTexture,
         &'static ViewPrepassTextures,
         &'static Camera3d,
-        Option<&'static DepthPrepass>,
         Option<&'static NormalPrepass>,
         Option<&'static MotionVectorPrepass>,
     );
@@ -52,7 +51,6 @@ impl ViewNode for DeferredGBufferPrepassNode {
             view_depth_texture,
             view_prepass_textures,
             camera_3d,
-            depth_prepass,
             normal_prepass,
             motion_vector_prepass,
         ): QueryItem<Self::ViewQuery>,
@@ -154,15 +152,11 @@ impl ViewNode for DeferredGBufferPrepassNode {
                 depth_stencil_attachment: Some(RenderPassDepthStencilAttachment {
                     view: &view_depth_texture.view,
                     depth_ops: Some(Operations {
-                        load: if depth_prepass.is_some()
-                            || normal_prepass.is_some()
-                            || motion_vector_prepass.is_some()
-                        {
-                            // If any prepass runs, it will generate a depth buffer so we should use it.
-                            Camera3dDepthLoadOp::Load
-                        } else {
+                        load: if view_depth_texture.is_first_write() {
                             // NOTE: 0.0 is the far plane due to bevy's use of reverse-z projections.
                             camera_3d.depth_load_op.clone()
+                        } else {
+                            Camera3dDepthLoadOp::Load
                         }
                         .into(),
                         store: true,

crates/bevy_core_pipeline/src/prepass/node.rs

@@ -50,6 +50,8 @@ impl ViewNode for PrepassNode {
     ) -> Result<(), NodeRunError> {
         let view_entity = graph.view_entity();
 
+        let _ = view_depth_texture.is_first_write();
+
         let mut color_attachments = vec![
             view_prepass_textures
                 .normal

crates/bevy_pbr/src/deferred/mod.rs

@@ -197,18 +197,21 @@ impl ViewNode for DeferredOpaquePass3dPbrLightingNode {
             &BindGroupEntries::single(deferred_lighting_pass_id_binding),
         );
 
+        let load = if target.is_first_write() {
+            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 {
+            LoadOp::Load
+        };
+
         let mut render_pass = render_context.begin_tracked_render_pass(RenderPassDescriptor {
             label: Some("deferred_lighting_pass"),
-            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,
-            }))],
+            color_attachments: &[Some(
+                target.get_color_attachment(Operations { load, store: true }),
+            )],
             depth_stencil_attachment: Some(RenderPassDepthStencilAttachment {
                 view: &deferred_lighting_id_depth_texture.texture.default_view,
                 depth_ops: Some(Operations {

crates/bevy_render/src/view/mod.rs

@@ -191,6 +191,7 @@ pub struct ViewTarget {
     main_texture: Arc<AtomicUsize>,
     out_texture: TextureView,
     out_texture_format: TextureFormat,
+    first_write: Arc<AtomicBool>,
 }
 
 pub struct PostProcessWrite<'a> {
@@ -201,6 +202,10 @@ pub struct PostProcessWrite<'a> {
 impl ViewTarget {
     pub const TEXTURE_FORMAT_HDR: TextureFormat = TextureFormat::Rgba16Float;
 
+    pub fn is_first_write(&self) -> bool {
+        self.first_write.fetch_and(false, Ordering::SeqCst)
+    }
+
     /// Retrieve this target's color attachment. This will use [`Self::sampled_main_texture_view`] and resolve to [`Self::main_texture`] if
     /// the target has sampling enabled. Otherwise it will use [`Self::main_texture`] directly.
     pub fn get_color_attachment(&self, ops: Operations<Color>) -> RenderPassColorAttachment {
@@ -342,6 +347,21 @@ impl ViewTarget {
 pub struct ViewDepthTexture {
     pub texture: Texture,
     pub view: TextureView,
+    first_write: Arc<AtomicBool>,
+}
+
+impl ViewDepthTexture {
+    pub fn new(texture: Texture, view: TextureView) -> Self {
+        Self {
+            texture,
+            view,
+            first_write: Arc::new(AtomicBool::new(true)),
+        }
+    }
+
+    pub fn is_first_write(&self) -> bool {
+        self.first_write.fetch_and(false, Ordering::SeqCst)
+    }
 }
 
 pub fn prepare_view_uniforms(
@@ -511,6 +531,7 @@ fn prepare_view_targets(
                     main_texture: main_textures.main_texture.clone(),
                     out_texture: out_texture_view.clone(),
                     out_texture_format: out_texture_format.add_srgb_suffix(),
+                    first_write: Arc::new(AtomicBool::new(true)),
                 });
             }
         }