Add Order Independent Transparency

crates/bevy_core_pipeline/Cargo.toml

@@ -33,6 +33,7 @@ bevy_render = { path = "../bevy_render", version = "0.15.0-dev" }
 bevy_transform = { path = "../bevy_transform", version = "0.15.0-dev" }
 bevy_math = { path = "../bevy_math", version = "0.15.0-dev" }
 bevy_utils = { path = "../bevy_utils", version = "0.15.0-dev" }
+bevy_window = { path = "../bevy_window", version = "0.15.0-dev" }
 
 serde = { version = "1", features = ["derive"] }
 bitflags = "2.3"

crates/bevy_core_pipeline/src/oit/mod.rs

@@ -1,17 +1,32 @@
+//! # Order Independent Transparency (OIT)
+//!
+//! This implementation uses 2 passes.
+//!
+//! The first pass writes the depth and color of all the fragments to a big buffer.
+//! The buffer contains N layers for each pixel.
+//! This pass is essentially a forward pass.
+//!
+//! The second pass is a single fullscreen triangle pass that sorts all the fragments then blends them together
+//! and outputs the result to the screen.
+//!
+//! If you want to use OIT for your custom material you need to call `oit_draw(position, color)` in your fragment shader.
+//! You also need to make sure that your fragment shader doesn't output any colors.
+
 use bevy_app::prelude::*;
 use bevy_asset::{load_internal_asset, Handle};
 use bevy_ecs::prelude::*;
 use bevy_math::UVec2;
 use bevy_render::{
-    camera::ExtractedCamera,
+    camera::{Camera, ExtractedCamera},
     extract_component::{ExtractComponent, ExtractComponentPlugin},
     render_graph::{RenderGraphApp, ViewNodeRunner},
     render_resource::{BufferUsages, BufferVec, DynamicUniformBuffer, Shader, TextureUsages},
     renderer::{RenderDevice, RenderQueue},
     view::Msaa,
     Render, RenderApp, RenderSet,
 };
-use bevy_utils::{tracing::trace, warn_once, Instant};
+use bevy_utils::{tracing::trace, HashSet, Instant};
+use bevy_window::PrimaryWindow;
 use resolve::{
     node::{OitResolveNode, OitResolvePass},
     OitResolvePlugin,
@@ -29,7 +44,7 @@ pub mod resolve;
 pub const OIT_DRAW_SHADER_HANDLE: Handle<Shader> = Handle::weak_from_u128(4042527984320512);
 
 /// Used to identify which camera will use OIT to render transparent meshes
-/// Alos used to configure OIT
+/// and to configure OIT
 // TODO consider supporting multiple OIT techniques like WBOIT, Moment Based OIT,
 // depth peeling, stochastic transparency, ray tracing etc.
 // This should probably be done by adding an enum to this component
@@ -90,17 +105,32 @@ impl Plugin for OrderIndependentTransparencyPlugin {
 
 // WARN This should only happen for cameras with the [`OrderIndependentTransparencySettings`]
 // but when multiple cameras are present on the same window
-// bevy reuses the same depth texture so we need to set this on all cameras.
+// bevy reuses the same depth texture so we need to set this on all cameras with the same render target.
 fn configure_depth_texture_usages(
-    mut new_cameras: Query<
-        &mut Camera3d,
-        (Added<Camera3d>, With<OrderIndependentTransparencySettings>),
-    >,
+    p: Query<Entity, With<PrimaryWindow>>,
+    cameras: Query<(&Camera, Has<OrderIndependentTransparencySettings>)>,
+    mut new_cameras: Query<(&mut Camera3d, &Camera), Added<Camera3d>>,
 ) {
-    for mut camera in &mut new_cameras {
-        let mut usages = TextureUsages::from(camera.depth_texture_usages);
-        usages |= TextureUsages::RENDER_ATTACHMENT | TextureUsages::TEXTURE_BINDING;
-        camera.depth_texture_usages = usages.into();
+    if new_cameras.is_empty() {
+        return;
+    }
+
+    // Find all the render target that potentially uses OIT
+    let primary_window = p.get_single().expect("No primary window found");
+    let mut render_target_has_oit = HashSet::new();
+    for (camera, has_oit) in &cameras {
+        if has_oit {
+            render_target_has_oit.insert(camera.target.normalize(Some(primary_window)));
+        }
+    }
+
+    // Update the depth texture usage for cameras with a render target that has OIT
+    for (mut camera_3d, camera) in &mut new_cameras {
+        if render_target_has_oit.contains(&camera.target.normalize(Some(primary_window))) {
+            let mut usages = TextureUsages::from(camera_3d.depth_texture_usages);
+            usages |= TextureUsages::RENDER_ATTACHMENT | TextureUsages::TEXTURE_BINDING;
+            camera_3d.depth_texture_usages = usages.into();
+        }
     }
 }
 
@@ -203,7 +233,7 @@ pub fn prepare_oit_buffers(
         trace!(
             "OIT layers buffer updated in {:.01}ms with total size {} MiB",
             start.elapsed().as_millis(),
-            buffers.layers.capacity() * std::mem::size_of::<UVec2>() / 1024 / 1024,
+            buffers.layers.capacity() * size_of::<UVec2>() / 1024 / 1024,
         );
     }
 
@@ -223,7 +253,7 @@ pub fn prepare_oit_buffers(
         trace!(
             "OIT layer ids buffer updated in {:.01}ms with total size {} MiB",
             start.elapsed().as_millis(),
-            buffers.layer_ids.capacity() * std::mem::size_of::<UVec2>() / 1024 / 1024,
+            buffers.layer_ids.capacity() * size_of::<UVec2>() / 1024 / 1024,
         );
     }
 

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

@@ -18,7 +18,6 @@ use bevy_render::{
     view::{ExtractedView, ViewTarget, ViewUniform, ViewUniforms},
     Render, RenderApp, RenderSet,
 };
-use bevy_utils::HashMap;
 
 use crate::{
     fullscreen_vertex_shader::fullscreen_shader_vertex_state,

crates/bevy_pbr/src/render/mesh_view_bindings.rs

@@ -361,11 +361,11 @@ fn layout_entries(
     if layout_key.contains(MeshPipelineViewLayoutKey::OIT_ENABLED) {
         entries = entries.extend_with_indices((
             // oit_layers
-            (29, storage_buffer_sized(false, None)),
+            (31, storage_buffer_sized(false, None)),
             // oit_layer_ids,
-            (30, storage_buffer_sized(false, None)),
+            (32, storage_buffer_sized(false, None)),
             // oit_layer_count
-            (31, uniform_buffer::<i32>(true)),
+            (33, uniform_buffer::<i32>(true)),
         ));
     }
 
@@ -682,9 +682,9 @@ pub fn prepare_mesh_view_bind_groups(
                     oit_buffers.layers_count_uniforms.binding(),
                 ) {
                     entries = entries.extend_with_indices((
-                        (29, oit_layers_binding.clone()),
-                        (30, oit_layer_ids_binding.clone()),
-                        (31, oit_layers_count_uniforms_binding.clone()),
+                        (31, oit_layers_binding.clone()),
+                        (32, oit_layer_ids_binding.clone()),
+                        (33, oit_layers_count_uniforms_binding.clone()),
                     ));
                 }
             }

crates/bevy_pbr/src/render/mesh_view_bindings.wgsl

@@ -103,7 +103,7 @@ const VISIBILITY_RANGE_UNIFORM_BUFFER_SIZE: u32 = 64u;
 @group(0) @binding(30) var view_transmission_sampler: sampler;
 
 #ifdef OIT_ENABLED
-@group(0) @binding(29) var<storage, read_write> oit_layers: array<vec2<u32>>;
-@group(0) @binding(30) var<storage, read_write> oit_layer_ids: array<atomic<i32>>;
-@group(0) @binding(31) var<uniform> oit_layers_count: i32;
+@group(0) @binding(31) var<storage, read_write> oit_layers: array<vec2<u32>>;
+@group(0) @binding(32) var<storage, read_write> oit_layer_ids: array<atomic<i32>>;
+@group(0) @binding(33) var<uniform> oit_layers_count: i32;
 #endif OIT_ENABLED

examples/3d/order_independent_transparency.rs

@@ -1,4 +1,7 @@
-//! A simple 3D scene with light shining over a cube sitting on a plane.
+//! A simple 3D scene showing how alpha blending can break and how OIT can fix it.
+//!
+//! If you want to use OIT for your custom material you need to call `oit_draw(position, color)` in your fragment shader.
+//! You also need to make sure that your fragment shader doesn't output any colors.
 
 use bevy::{
     color::palettes::css::{BLUE, GREEN, RED},
@@ -29,12 +32,12 @@ fn setup(
                 transform: Transform::from_xyz(0.0, 0.0, 10.0).looking_at(Vec3::ZERO, Vec3::Y),
                 ..default()
             },
-            // Add this component so this camera to render transparent meshes using OIT
+            // Add this component to this camera to render transparent meshes using OIT
             OrderIndependentTransparencySettings::default(),
             RenderLayers::layer(1),
         ))
         .insert(
-            // Msaa currently doesn't work well with OIT
+            // Msaa currently doesn't work with OIT
             Msaa::Off,
         );