Fix energy loss in multi-scattering term (#23203)

dylansechet · mockersf · web-flow · commit 1108f27f36e4 · 2026-03-05T01:48:07.000Z
# Objective With #23194 applied, the white furnace test passes for pure metals and dielectrics, but fails for anything in between. ## Solution The issue seems to be the multi-scattering term used in `environment_map_light`. The current code computes `FmsEms(mix(F0_dielectric, F0_metal, metalness))` when it should be computing `mix(FmsEms(F0_dielectric), FmsEms(F0_metal), metalness)`, which causes an issue as FmsEms is non-linear in F0. The bug is also present in the [blogpost](https://bruop.github.io/ibl/) that was used as inspiration for the implementation, where the author mentions that the results with multi-scattering are darker than they should be. ## Testing - Ran `cargo run --example testbed_white_furnace`. I've never been so happy to see a gray image :) - Ran `cargo run --example pbr`. --- ## Showcase White furnace test (with #23194 also applied): **Before:** <img width="1280" height="720" alt="fix_vndf" src="https://github.com/user-attachments/assets/03d93be5-7a7f-4015-9cd7-2d1f3b25f09d" /> **After:** <img width="1280" height="720" alt="fix_multiscatter+vndf" src="https://github.com/user-attachments/assets/2aa6fc31-f25c-420a-a759-44e83f47cf9f" /> PBR test [also on imgsli](https://imgsli.com/NDUzNjU2) **Before:** <img width="1280" height="720" alt="main" src="https://github.com/user-attachments/assets/2cd1622a-42a0-4595-ae26-5cc4f50a9221" /> **After:** <img width="1280" height="720" alt="this_pr" src="https://github.com/user-attachments/assets/d29773a0-8445-4942-b118-6905e01b2f0a" /> --------- Co-authored-by: François Mockers <francois.mockers@vleue.com>
diff --git a/crates/bevy_pbr/src/light_probe/environment_map.wgsl b/crates/bevy_pbr/src/light_probe/environment_map.wgsl
@@ -23,6 +23,12 @@ struct EnvironmentMapRadiances {
     radiance: vec3<f32>,
 }
 
+struct MultiscatterResult {
+    FssEss: vec3<f32>,
+    FmsEms: vec3<f32>,
+    Edss: vec3<f32>,
+}
+
 // Computes the direction at which to sample the reflection probe.
 //
 // * `light_from_world` is the matrix that transforms world space into light
@@ -307,6 +313,24 @@ fn environment_map_light_clearcoat(
 
 #endif  // STANDARD_MATERIAL_CLEARCOAT
 
+// Multiscattering approximation: https://www.jcgt.org/published/0008/01/03/paper.pdf
+//
+// We initially used this (https://bruop.github.io/ibl) reference with Roughness Dependent
+// Fresnel, but it made fresnel very bright so we reverted to the "typical" fresnel term.
+fn compute_multiscatter(
+    F0: vec3<f32>,
+    F_ab: vec2<f32>,
+    Ems: f32,
+    specular_occlusion: f32,
+) -> MultiscatterResult {
+    let FssEss = (F0 * F_ab.x + F_ab.y) * specular_occlusion;
+    let Favg = F0 + (1.0 - F0) / 21.0;
+    let FmsEms = FssEss * Favg / (1.0 - Ems * Favg) * Ems;
+    let Edss = 1.0 - (FssEss + FmsEms);
+
+    return MultiscatterResult(FssEss, FmsEms, Edss);
+}
+
 fn environment_map_light(
     input: ptr<function, LightingInput>,
     clusterable_object_index_ranges: ptr<function, ClusterableObjectIndexRanges>,
@@ -315,9 +339,11 @@ fn environment_map_light(
     // Unpack.
     let roughness = (*input).layers[LAYER_BASE].roughness;
     let diffuse_color = (*input).diffuse_color;
+    let metallic = (*input).metallic;
     let NdotV = (*input).layers[LAYER_BASE].NdotV;
     let F_ab = (*input).F_ab;
-    let F0 = (*input).F0_;
+    let F0_dielectric = (*input).F0_dielectric;
+    let F0_metallic = (*input).F0_metallic;
     let world_position = (*input).P;
 
     var out: EnvironmentMapLight;
@@ -338,18 +364,19 @@ fn environment_map_light(
     // No real world material has specular values under 0.02, so we use this range as a
     // "pre-baked specular occlusion" that extinguishes the fresnel term, for artistic control.
     // See: https://google.github.io/filament/Filament.html#specularocclusion
-    let specular_occlusion = saturate(dot(F0, vec3(50.0 * 0.33)));
+    let F0_surface = mix(F0_dielectric, F0_metallic, metallic);
+    let specular_occlusion = saturate(dot(F0_surface, vec3(50.0 * 0.33)));
 
-    // Multiscattering approximation: https://www.jcgt.org/published/0008/01/03/paper.pdf
-    // We initially used this (https://bruop.github.io/ibl) reference with Roughness Dependent
-    // Fresnel, but it made fresnel very bright so we reverted to the "typical" fresnel term.
-    let FssEss = (F0 * F_ab.x + F_ab.y) * specular_occlusion;
+    // Compute per-material (dielectric and metallic separately) then mix the results. 
+    // We can't use F0 directly as the multiscattering term is nonlinear.
     let Ems = 1.0 - (F_ab.x + F_ab.y);
-    let Favg = F0 + (1.0 - F0) / 21.0;
-    let Fms = FssEss * Favg / (1.0 - Ems * Favg);
-    let FmsEms = Fms * Ems;
-    let Edss = 1.0 - (FssEss + FmsEms);
-    let kD = diffuse_color * Edss;
+
+    let ms_dielectric = compute_multiscatter(F0_dielectric, F_ab, Ems, specular_occlusion);
+    let ms_metallic = compute_multiscatter(F0_metallic, F_ab, Ems, specular_occlusion);
+
+    let FssEss = mix(ms_dielectric.FssEss, ms_metallic.FssEss, metallic);
+    let FmsEms = mix(ms_dielectric.FmsEms, ms_metallic.FmsEms, metallic);
+    let kD = diffuse_color * ms_dielectric.Edss;
 
     if (!found_diffuse_indirect) {
         out.diffuse = (FmsEms + kD) * radiances.irradiance;
diff --git a/crates/bevy_pbr/src/render/pbr_functions.wgsl b/crates/bevy_pbr/src/render/pbr_functions.wgsl
@@ -276,10 +276,15 @@ fn calculate_diffuse_color(
         (1.0 - diffuse_transmission);
 }
 
+// Remapping [0,1] reflectance to F0 for dielectrics
+fn calculate_F0_dielectric(reflectance: vec3<f32>) -> vec3<f32> {
+    return 0.16 * reflectance * reflectance;
+}
+
 // Remapping [0,1] reflectance to F0
 // See https://google.github.io/filament/Filament.html#materialsystem/parameterization/remapping
 fn calculate_F0(base_color: vec3<f32>, metallic: f32, reflectance: vec3<f32>) -> vec3<f32> {
-    return 0.16 * reflectance * reflectance * (1.0 - metallic) + base_color * metallic;
+    return mix(calculate_F0_dielectric(reflectance), base_color, metallic);
 }
 
 #ifdef DEPTH_PREPASS
@@ -388,7 +393,9 @@ fn apply_pbr_lighting(
     lighting_input.P = in.world_position.xyz;
     lighting_input.V = in.V;
     lighting_input.diffuse_color = diffuse_color;
-    lighting_input.F0_ = F0;
+    lighting_input.metallic = metallic;
+    lighting_input.F0_dielectric = calculate_F0_dielectric(reflectance);
+    lighting_input.F0_metallic = output_color.rgb;
     lighting_input.F_ab = F_ab;
 #ifdef STANDARD_MATERIAL_CLEARCOAT
     lighting_input.layers[LAYER_CLEARCOAT].NdotV = clearcoat_NdotV;
@@ -415,7 +422,9 @@ fn apply_pbr_lighting(
     transmissive_lighting_input.P = diffuse_transmissive_lobe_world_position.xyz;
     transmissive_lighting_input.V = -in.V;
     transmissive_lighting_input.diffuse_color = diffuse_transmissive_color;
-    transmissive_lighting_input.F0_ = vec3(0.0);
+    transmissive_lighting_input.metallic = 0.0;
+    transmissive_lighting_input.F0_dielectric = vec3(0.0);
+    transmissive_lighting_input.F0_metallic = vec3(0.0);
     transmissive_lighting_input.F_ab = vec2(0.1);
 #ifdef STANDARD_MATERIAL_CLEARCOAT
     transmissive_lighting_input.layers[LAYER_CLEARCOAT].NdotV = 0.0;
@@ -735,7 +744,7 @@ fn apply_pbr_lighting(
     // diffuse_color = vec3<f32>(1.0) // later we use `diffuse_transmissive_color` and `specular_transmissive_color`
     // NdotV = 1.0;
     // R = T // see definition below
-    // F0 = vec3<f32>(1.0)
+    // F0 = vec3<f32>(1.0) (using F0_dielectric = 1, F0_metallic = 0 and metallic = 0)
     // diffuse_occlusion = 1.0
     //
     // (This one is slightly different from the other light types above, because the environment
@@ -755,7 +764,9 @@ fn apply_pbr_lighting(
     transmissive_environment_light_input.layers[LAYER_BASE].R = T;
     transmissive_environment_light_input.layers[LAYER_BASE].perceptual_roughness = perceptual_roughness;
     transmissive_environment_light_input.layers[LAYER_BASE].roughness = roughness;
-    transmissive_environment_light_input.F0_ = vec3<f32>(1.0);
+    transmissive_environment_light_input.metallic = 0.0;
+    transmissive_environment_light_input.F0_dielectric = vec3<f32>(1.0);
+    transmissive_environment_light_input.F0_metallic = vec3<f32>(0.0);
     transmissive_environment_light_input.F_ab = vec2(0.1);
 #ifdef STANDARD_MATERIAL_CLEARCOAT
     // No clearcoat.
diff --git a/crates/bevy_pbr/src/render/pbr_lighting.wgsl b/crates/bevy_pbr/src/render/pbr_lighting.wgsl
@@ -78,10 +78,13 @@ struct LightingInput {
     // The diffuse color of the material.
     diffuse_color: vec3<f32>,
 
+    // The 0-1 metallic factor of the material.
+    metallic: f32,
+
     // Specular reflectance at the normal incidence angle.
-    //
-    // This should be read F₀, but due to Naga limitations we can't name it that.
-    F0_: vec3<f32>,
+    F0_dielectric: vec3<f32>,
+    F0_metallic: vec3<f32>,
+    
     // Constants for the BRDF approximation.
     //
     // See `EnvBRDFApprox` in
@@ -400,7 +403,7 @@ fn specular(
 ) -> vec3<f32> {
     // Unpack.
     let NdotV = (*input).layers[LAYER_BASE].NdotV;
-    let F0 = (*input).F0_;
+    let F0 = mix((*input).F0_dielectric, (*input).F0_metallic, (*input).metallic);
     let NdotL = (*derived_input).NdotL;
     let NdotH = (*derived_input).NdotH;
     let LdotH = (*derived_input).LdotH;
@@ -456,7 +459,7 @@ fn specular_anisotropy(
     // Unpack.
     let NdotV = (*input).layers[LAYER_BASE].NdotV;
     let V = (*input).V;
-    let F0 = (*input).F0_;
+    let F0 = mix((*input).F0_dielectric, (*input).F0_metallic, (*input).metallic);
     let anisotropy = (*input).anisotropy;
     let Ta = (*input).Ta;
     let Ba = (*input).Ba;
diff --git a/crates/bevy_pbr/src/ssr/ssr.wgsl b/crates/bevy_pbr/src/ssr/ssr.wgsl
@@ -263,7 +263,7 @@ fn fragment(in: FullscreenVertexOutput) -> @location(0) vec4<f32> {
     );
     let NdotV = max(dot(N, V), 0.0001);
     let F_ab = lighting::F_AB(perceptual_roughness, NdotV);
-    let F0_env = pbr_functions::calculate_F0(base_color, metallic, reflectance);
+    let F0_dielectric = pbr_functions::calculate_F0_dielectric(reflectance);
 
     // Don't add stochastic noise to hits that sample the prefiltered env map.
     // The prefiltered env map already accounts for roughness.
@@ -279,7 +279,9 @@ fn fragment(in: FullscreenVertexOutput) -> @location(0) vec4<f32> {
     lighting_input.P = world_position.xyz;
     lighting_input.V = V;
     lighting_input.diffuse_color = diffuse_color;
-    lighting_input.F0_ = F0_env;
+    lighting_input.metallic = metallic;
+    lighting_input.F0_dielectric = F0_dielectric;
+    lighting_input.F0_metallic = base_color;
     lighting_input.F_ab = F_ab;
 #ifdef STANDARD_MATERIAL_CLEARCOAT
     lighting_input.layers[LAYER_CLEARCOAT].NdotV = clearcoat_NdotV;
diff --git a/release-content/release-notes/white_furnace.md b/release-content/release-notes/white_furnace.md
@@ -0,0 +1,15 @@
+---
+title: White furnace test
+authors: ["@dylansechet"]
+pull_requests: [23194, 23203]
+---
+The [white furnace test](https://lousodrome.net/blog/light/2023/10/21/the-white-furnace-test/) is a classic sanity check for physically-based renderers. Place a perfectly reflective object inside a uniform white environment, and it should be indistinguishable from the background, no matter how metallic and rough. Any object that remains visible is a sign that the shader is creating or absorbing energy it shouldn't.
+
+Bevy used to fail this test, meaning something was wrong with our shader math. Two bugs were responsible:
+
+- Seams were visible when using `GeneratedEnvironmentMapLight` for certain surface orientations.
+- Partially metallic materials absorbed energy, appearing darker than they should be.
+
+After fixing those, Bevy passes the test. That means your materials will behave more correctly under image-based lighting.
+
+A gray image has never been so exciting!
