Fix corrupted linked list on startup

Author: beicause

crates/bevy_core_pipeline/src/core_3d/main_transparent_pass_3d_node.rs

@@ -1,12 +1,15 @@
-use crate::core_3d::Transparent3d;
+use crate::{
+    core_3d::Transparent3d,
+    oit::{resolve::OitResolvePipelineId, OrderIndependentTransparencySettings},
+};
 use bevy_camera::{MainPassResolutionOverride, Viewport};
 use bevy_ecs::{prelude::*, query::QueryItem};
 use bevy_render::{
     camera::ExtractedCamera,
     diagnostic::RecordDiagnostics,
     render_graph::{NodeRunError, RenderGraphContext, ViewNode},
     render_phase::ViewSortedRenderPhases,
-    render_resource::{RenderPassDescriptor, StoreOp},
+    render_resource::{PipelineCache, RenderPassDescriptor, StoreOp},
     renderer::RenderContext,
     view::{ExtractedView, ViewDepthTexture, ViewTarget},
 };
@@ -26,12 +29,14 @@ impl ViewNode for MainTransparentPass3dNode {
         &'static ViewTarget,
         &'static ViewDepthTexture,
         Option<&'static MainPassResolutionOverride>,
+        Has<OrderIndependentTransparencySettings>,
+        Option<&'static OitResolvePipelineId>,
     );
     fn run(
         &self,
         graph: &mut RenderGraphContext,
         render_context: &mut RenderContext,
-        (camera, view, target, depth, resolution_override): QueryItem<Self::ViewQuery>,
+        (camera, view, target, depth, resolution_override, has_oit,oit_resolve_pipeline_id): QueryItem<Self::ViewQuery>,
         world: &World,
     ) -> Result<(), NodeRunError> {
         let view_entity = graph.view_entity();
@@ -47,6 +52,22 @@ impl ViewNode for MainTransparentPass3dNode {
         };
 
         if !transparent_phase.items.is_empty() {
+            if has_oit {
+                // We can't run transparent phase if OitResolvePipelineId is not ready
+                // Otherwise we will write to `oit_atomic_counter` and `oit_headers` buffer without resetting them
+                // which causes corrupted linked list(can have circular references) on the next pass
+                let Some(oit_resolve_pipeline_id) = oit_resolve_pipeline_id else {
+                    return Ok(());
+                };
+                let pipeline_cache = world.resource::<PipelineCache>();
+                if pipeline_cache
+                    .get_render_pipeline(oit_resolve_pipeline_id.0)
+                    .is_none()
+                {
+                    return Ok(());
+                }
+            }
+
             // Run the transparent pass, sorted back-to-front
             // NOTE: Scoped to drop the mutable borrow of render_context
             #[cfg(feature = "trace")]

crates/bevy_core_pipeline/src/oit/mod.rs

@@ -138,19 +138,9 @@ fn check_msaa(cameras: Query<&Msaa, With<OrderIndependentTransparencySettings>>)
 
 #[derive(Clone, Copy, ShaderType)]
 pub struct OitFragmentNode {
-    color: u32,
-    depth_alpha: u32,
-    next: u32,
-}
-
-impl Default for OitFragmentNode {
-    fn default() -> Self {
-        Self {
-            color: 0,
-            depth_alpha: 0,
-            next: u32::MAX,
-        }
-    }
+    pub color: u32,
+    pub depth_alpha: u32,
+    pub next: u32,
 }
 
 /// Holds the buffers that contain the data of all OIT layers.
@@ -176,8 +166,7 @@ pub fn init_oit_buffers(
 
     let mut nodes = BufferVec::new(BufferUsages::COPY_DST | BufferUsages::STORAGE);
     nodes.set_label(Some("oit_nodes"));
-    nodes.push(OitFragmentNode::default());
-    nodes.write_buffer(&render_device, &render_queue);
+    nodes.reserve(1, &render_device);
 
     let mut headers = BufferVec::new(BufferUsages::COPY_DST | BufferUsages::STORAGE);
     headers.set_label(Some("oit_headers"));
@@ -256,12 +245,7 @@ pub fn prepare_oit_buffers(
     let nodes_size = ((max_size.x * max_size.y) as f32 * fragments_per_pixel_average) as usize;
     if buffers.nodes.capacity() < nodes_size {
         let start = Instant::now();
-        buffers.nodes.clear();
         buffers.nodes.reserve(nodes_size, &render_device);
-        for _ in 0..nodes_size {
-            buffers.nodes.push(OitFragmentNode::default());
-        }
-        buffers.nodes.write_buffer(&render_device, &render_queue);
         trace!(
             "OIT nodes buffer updated in {:.01}ms with capacity {}, total size {} MiB",
             start.elapsed().as_millis(),

crates/bevy_core_pipeline/src/oit/resolve/node.rs

@@ -46,9 +46,10 @@ impl ViewNode for OitResolveNode {
         ): QueryItem<Self::ViewQuery>,
         world: &World,
     ) -> Result<(), NodeRunError> {
-        let Some(resolve_pipeline) = world.get_resource::<OitResolvePipeline>() else {
-            return Ok(());
-        };
+        // This *must* run after main_transparent_pass_3d to reset the `oit_atomic_counter` and `oit_headers` buffer
+        // Otherwise transparent pass will construct a corrupted linked list(can have circular references which causes infinite loop and device lost) on the next pass
+
+        let resolve_pipeline = world.get_resource::<OitResolvePipeline>().unwrap();
 
         // resolve oit
         // sorts the layers and renders the final blended color to the screen

crates/bevy_core_pipeline/src/oit/resolve/oit_resolve.wgsl

@@ -3,8 +3,8 @@
 
 @group(0) @binding(0) var<uniform> view: View;
 @group(0) @binding(1) var<storage, read> nodes: array<OitFragmentNode>;
-@group(0) @binding(2) var<storage, read_write> headers: array<u32>;
-@group(0) @binding(3) var<storage, read_write> atomic_counter: u32;
+@group(0) @binding(2) var<storage, read_write> headers: array<u32>; // No need to be atomic
+@group(0) @binding(3) var<storage, read_write> atomic_counter: u32; // No need to be atomic
 
 #ifndef DEPTH_PREPASS
 @group(1) @binding(0) var depth: texture_depth_2d;