Sort in desc order and fix early termination in blending

Author: beicause

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

@@ -54,7 +54,9 @@ fn fragment(in: FullscreenVertexOutput) -> @location(0) vec4<f32> {
 
 fn resolve(header: u32, opaque_depth: f32) -> vec4<f32> {
     // Contains all the colors and depth for this specific fragment
-    // Fragments are sorted from back to front.
+    // Fragments are sorted from front to back (depth values are in descending order)
+    // This should make insertion sort slightly faster
+    // because transparent pass sorts objects so the linked list iteration is usually in descending order.
     var fragment_list: array<OitFragment, SORTED_FRAGMENT_MAX_COUNT>;
     var final_color = vec4<f32>(0.0);
 
@@ -81,7 +83,7 @@ fn resolve(header: u32, opaque_depth: f32) -> vec4<f32> {
             var i = sorted_frag_count;
             for(; i > 0; i -= 1) {
                 // short-circuit can't be used in for(;;;), https://github.com/gfx-rs/wgpu/issues/4394
-                if depth_alpha.x < fragment_list[i - 1].depth {
+                if depth_alpha.x > fragment_list[i - 1].depth {
                     fragment_list[i] = fragment_list[i - 1];
                 } else {
                     break;
@@ -91,16 +93,18 @@ fn resolve(header: u32, opaque_depth: f32) -> vec4<f32> {
             fragment_list[i].alpha = depth_alpha.y;
             fragment_list[i].depth = depth_alpha.x;
             sorted_frag_count += 1;
-        } else if fragment_list[0].depth < depth_alpha.x {
-            // The fragment is closer than the farthest sorted one.
-            // First, make room by blending the farthest fragment from the sorted list.
+        } else if fragment_list[0].depth > depth_alpha.x {
+            // The fragment is farther than the nearest sorted one.
+            // First, make room by blending the nearest fragment from the sorted list.
             // Then, insert the fragment in the sorted list.
             // This is an approximation.
-            final_color = blend(vec4f(fragment_list[0].color * fragment_list[0].alpha, fragment_list[0].alpha), final_color);
+            let nearest_color = fragment_list[0].color;
+            let nearest_alpha = fragment_list[0].alpha;
+            final_color = blend(final_color, vec4f(nearest_color * nearest_alpha, nearest_alpha));
             var i = 0u;
             for(; i < SORTED_FRAGMENT_MAX_COUNT - 1; i += 1) {
                 // short-circuit can't be used in for(;;;), https://github.com/gfx-rs/wgpu/issues/4394
-                if fragment_list[i + 1].depth < depth_alpha.x {
+                if depth_alpha.x < fragment_list[i + 1].depth {
                     fragment_list[i] = fragment_list[i + 1];
                 } else {
                     break;
@@ -110,10 +114,10 @@ fn resolve(header: u32, opaque_depth: f32) -> vec4<f32> {
             fragment_list[i].alpha = depth_alpha.y;
             fragment_list[i].depth = depth_alpha.x;
         } else {
-            // The next fragment is farther than any of the sorted ones.
+            // The next fragment is nearer than any of the sorted ones.
             // Blend it early.
             // This is an approximation.
-            final_color = blend(vec4f(color * depth_alpha.y, depth_alpha.y), final_color);
+            final_color = blend(final_color, vec4f(color * depth_alpha.y, depth_alpha.y));
         }
     }
 
@@ -122,7 +126,7 @@ fn resolve(header: u32, opaque_depth: f32) -> vec4<f32> {
         let color = fragment_list[i].color;
         let alpha = fragment_list[i].alpha;
         var base_color = vec4(color.rgb * alpha, alpha);
-        final_color = blend(base_color, final_color);
+        final_color = blend(final_color, base_color);
         if final_color.a == 1.0 {
             break;
         }

examples/3d/order_independent_transparency.rs

@@ -101,19 +101,23 @@ fn cycle_scenes(
     mut materials: ResMut<Assets<StandardMaterial>>,
     q: Query<Entity, With<Mesh3d>>,
     mut scene_id: Local<usize>,
+    asset_server: Res<AssetServer>,
 ) {
     if keyboard_input.just_pressed(KeyCode::KeyC) {
         // despawn current scene
         for e in &q {
             commands.entity(e).despawn();
         }
         // increment scene_id
-        *scene_id = (*scene_id + 1) % 3;
+        *scene_id = (*scene_id + 1) % 4;
         // spawn next scene
         match *scene_id {
             0 => spawn_spheres(&mut commands, &mut meshes, &mut materials),
             1 => spawn_quads(&mut commands, &mut meshes, &mut materials),
             2 => spawn_occlusion_test(&mut commands, &mut meshes, &mut materials),
+            3 => {
+                spawn_auto_instancing_test(&mut commands, &mut meshes, &mut materials, asset_server)
+            }
             _ => unreachable!(),
         }
     }
@@ -304,3 +308,34 @@ fn spawn_occlusion_test(
         render_layers.clone(),
     ));
 }
+
+fn spawn_auto_instancing_test(
+    commands: &mut Commands,
+    meshes: &mut Assets<Mesh>,
+    materials: &mut Assets<StandardMaterial>,
+    asset_server: Res<AssetServer>,
+) {
+    let render_layers = RenderLayers::layer(1);
+
+    let cube = meshes.add(Cuboid::new(1.0, 1.0, 1.0));
+    let material_handle = materials.add(StandardMaterial {
+        alpha_mode: AlphaMode::Blend,
+        base_color_texture: Some(asset_server.load("textures/slice_square.png")),
+        ..Default::default()
+    });
+    let mut bundles = Vec::with_capacity(3 * 3 * 3);
+
+    for z in -1..=1 {
+        for y in -1..=1 {
+            for x in -1..=1 {
+                bundles.push((
+                    Mesh3d(cube.clone()),
+                    MeshMaterial3d(material_handle.clone()),
+                    Transform::from_xyz(x as f32 * 2.0, y as f32 * 2.0, z as f32 * 2.0),
+                    render_layers.clone(),
+                ));
+            }
+        }
+    }
+    commands.spawn_batch(bundles);
+}