@woosh/meep-engine 3.47.0 → 3.50.0

package/src/shade/renderer/shader/chunk/grid/chunk_grid_tile_window.js

@@ -0,0 +1,88 @@
+import { CodeChunk } from "../../compiler/CodeChunk.js";
+import { chunk_grid3d_to_index } from "./chunk_grid3d_to_index.js";
+import { chunk_index_to_grid3d } from "./chunk_index_to_grid3d.js";
+
+/**
+ * Interior cells of a tile on each axis: 8 x 8 x 4, one cell per invocation of a 256-invocation
+ * workgroup.
+ * @type {number[]}
+ */
+export const GRID_TILE_SIZE = Object.freeze([8, 8, 4]);
+
+/**
+ * The tile with a one-cell halo on every side: 10 x 10 x 6.
+ * @type {number[]}
+ */
+export const GRID_TILE_HALO_SIZE = Object.freeze(GRID_TILE_SIZE.map(n => n + 2));
+
+/**
+ * Cells of the tile with its halo, 600: 2400 bytes of workgroup memory as f32, 9600 as vec4.
+ * @type {number}
+ */
+export const GRID_TILE_HALO_CELLS = GRID_TILE_HALO_SIZE[0] * GRID_TILE_HALO_SIZE[1] * GRID_TILE_HALO_SIZE[2];
+
+/**
+ * Invocations of a workgroup that loads a tile: one per interior cell.
+ * @type {number}
+ */
+export const GRID_TILE_THREADS = GRID_TILE_SIZE[0] * GRID_TILE_SIZE[1] * GRID_TILE_SIZE[2];
+
+/**
+ * Cells each invocation loads at most: 600 over 256 invocations.
+ * @type {number}
+ */
+export const GRID_TILE_LOAD_ROUNDS = Math.ceil(GRID_TILE_HALO_CELLS / GRID_TILE_THREADS);
+
+/**
+ * The index maths shared by {@link chunk_grid_tile_halo_f32} and {@link chunk_grid_tile_halo_vec4}:
+ * the halo block's layout, and where a window-local cell is stored. All of it is per invocation and
+ * pure; the halo chunks are the workgroup memory and the barrier around it.
+ *
+ * **Tile-local** coordinates are relative to a tile's first interior cell, so the block a tile
+ * loads spans `[-1, 8] x [-1, 8] x [-1, 4]` and its interior `[0, 8) x [0, 8) x [0, 4)`. The block
+ * is stored x fastest, then y, then z.
+ *
+ * Window-local, world and storage cells are as in {@link GRID_TILE_WINDOW_STRUCT}.
+ *
+ * @type {CodeChunk}
+ */
+export const chunk_grid_tile_window = CodeChunk.from(
+    //language=WGSL
+    `
+const GRID_TILE_SIZE = vec3<i32>(${GRID_TILE_SIZE.join(', ')});
+const GRID_TILE_HALO_CELLS = ${GRID_TILE_HALO_CELLS}u;
+const GRID_TILE_THREADS = ${GRID_TILE_THREADS}u;
+const GRID_TILE_LOAD_ROUNDS = ${GRID_TILE_LOAD_ROUNDS}u;
+
+// The tile-local cell at index of the halo block.
+fn grid_tile_halo_local(index: u32) -> vec3<i32> {
+    let block = index_to_grid3d(index, vec2<u32>(${GRID_TILE_HALO_SIZE[0]}u, ${GRID_TILE_HALO_SIZE[1]}u));
+
+    return vec3<i32>(block) - vec3<i32>(1);
+}
+
+// The index in the halo block of a tile-local cell, which must lie in the block.
+fn grid_tile_halo_index(local: vec3<i32>) -> u32 {
+    return grid3d_to_index(
+        vec3<u32>(local + vec3<i32>(1)),
+        vec2<u32>(${GRID_TILE_HALO_SIZE[0]}u, ${GRID_TILE_HALO_SIZE[1]}u)
+    );
+}
+
+// Whether a window-local cell lies inside a window of size cells on each axis.
+fn grid_tile_window_contains(window_local: vec3<i32>, size: vec3<u32>) -> bool {
+    return all(window_local >= vec3<i32>(0)) && all(window_local < vec3<i32>(size));
+}
+
+// Where a window-local cell inside the window is stored: the corner's storage cell plus the
+// offset, which is below twice the period because the offset is below the size and the size at
+// most the period, so one conditional subtract wraps it.
+fn grid_tile_window_storage(window_local: vec3<i32>, corner_storage: vec3<u32>, period: vec3<u32>) -> vec3<u32> {
+    let unwrapped = corner_storage + vec3<u32>(window_local);
+
+    return select(unwrapped, unwrapped - period, unwrapped >= period);
+}
+`, [
+    chunk_grid3d_to_index,
+    chunk_index_to_grid3d,
+]);

package/src/shade/renderer/shader/chunk/light/chunk_compute_multiscattering_specular.d.ts

@@ -1,6 +1,10 @@
 /**
  * @see "Practical multiple scattering compensation for microfacet models" by Emmanuel Turquin
  * Approximates multiple-scattering to preserve energy.
+ *
+ * `specularF0` is the surface's F0, the metalness blend of `specularF0_dielectric` and `specularF0_metal`.
+ * The pure two are needed because the term is quadratic in F0 while metalness blends linearly; see
+ * `MULTISCATTER.md` in `chunk/material`.
  */
 export const chunk_compute_multiscattering_specular: CodeChunk;
 import { CodeChunk } from "../../compiler/CodeChunk.js";

package/src/shade/renderer/shader/chunk/light/chunk_compute_multiscattering_specular.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"chunk_compute_multiscattering_specular.d.ts","sourceRoot":"","sources":["../../../../../../../src/shade/renderer/shader/chunk/light/chunk_compute_multiscattering_specular.js"],"names":[],"mappings":"AAEA;;;GAGG;AACH,+DAoCC;0BA1CyB,6BAA6B"}
+{"version":3,"file":"chunk_compute_multiscattering_specular.d.ts","sourceRoot":"","sources":["../../../../../../../src/shade/renderer/shader/chunk/light/chunk_compute_multiscattering_specular.js"],"names":[],"mappings":"AAEA;;;;;;;GAOG;AACH,+DA2CC;0BArDyB,6BAA6B"}

package/src/shade/renderer/shader/chunk/light/chunk_compute_multiscattering_specular.js

@@ -3,6 +3,10 @@ import { CodeChunk } from "../../compiler/CodeChunk.js";
 /**
  * @see "Practical multiple scattering compensation for microfacet models" by Emmanuel Turquin
  * Approximates multiple-scattering to preserve energy.
+ *
+ * `specularF0` is the surface's F0, the metalness blend of `specularF0_dielectric` and `specularF0_metal`.
+ * The pure two are needed because the term is quadratic in F0 while metalness blends linearly; see
+ * `MULTISCATTER.md` in `chunk/material`.
  */
 export const chunk_compute_multiscattering_specular = CodeChunk.from(
 // language=WGSL
@@ -10,6 +14,8 @@ export const chunk_compute_multiscattering_specular = CodeChunk.from(
 fn compute_multiscattering_specular( 
     AB: vec2<f32>,
     specularF0: vec3<f32>,
+    specularF0_dielectric: vec3<f32>,
+    specularF0_metal: vec3<f32>,
     specularF90: f32,
     single_scatter: ptr<function, vec3<f32>>,
     multi_scatter: ptr<function, vec3<f32>> 
@@ -30,13 +36,18 @@ fn compute_multiscattering_specular(
 	
     let Ess_clamped = max(Ess, 1e-4); // Avoid div by zero
     let Kms = Ems / Ess_clamped;
+
+    // Fms = F0 makes the term quadratic in F0, so at the metalness blend of two F0s it is not the blend of
+    // the term at each: it falls short by Kms * A * m(1 - m)(F0_metal - F0_dielectric)^2. That is the
+    // product below, written without the metalness; zero for a pure dielectric and for a pure metal.
+    let F0_variance = (f0 - specularF0_dielectric) * (specularF0_metal - f0);
             
     // write out
 	*single_scatter += FssEss;
 	
     // The multi-scattering contribution is the single scattering scaled by (Fms * Kms).
     // Note: This maintains the "shape" of the specular highlight.
-	*multi_scatter += FssEss * (Fms * Kms);
+	*multi_scatter += FssEss * (Fms * Kms) + Kms * AB.x * F0_variance;
 	
 }
     `

package/src/shade/renderer/shader/chunk/light/lpv/chunk_lpv_mesh_get_vertices.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"chunk_lpv_mesh_get_vertices.d.ts","sourceRoot":"","sources":["../../../../../../../../src/shade/renderer/shader/chunk/light/lpv/chunk_lpv_mesh_get_vertices.js"],"names":[],"mappings":"AAIA,oDAcE;0BAjBwB,gCAAgC"}
+{"version":3,"file":"chunk_lpv_mesh_get_vertices.d.ts","sourceRoot":"","sources":["../../../../../../../../src/shade/renderer/shader/chunk/light/lpv/chunk_lpv_mesh_get_vertices.js"],"names":[],"mappings":"AAKA,oDAcE;0BAlBwB,gCAAgC"}

package/src/shade/renderer/shader/chunk/light/lpv/chunk_lpv_mesh_get_vertices.js

@@ -1,6 +1,7 @@
 import { TETRAHEDRAL_MESH_CELL_STRUCT } from "../../../../global_illumination/lpv/TETRAHEDRAL_MESH_CELL_STRUCT.js";
 import { CodeChunk } from "../../../compiler/CodeChunk.js";
 import { chunk_u32_array_as_vec4 } from "../../geometry/vec4/chunk_f32_array_as_vec4.js";
+import { LPV_MESH_RESOURCE } from "../../../../global_illumination/probe/octahedral/LPV_SHADER_RESOURCE_GROUP.js";
 
 export const chunk_lpv_mesh_get_vertices = CodeChunk.from(
     //language=WGSL
@@ -16,4 +17,6 @@ fn lpv_mesh_get_vertices(tet_index: u32) -> vec4<u32>{
     [
         TETRAHEDRAL_MESH_CELL_STRUCT.declaration_chunk,
     ]
-);
+);
+
+chunk_lpv_mesh_get_vertices.requireResource(LPV_MESH_RESOURCE);

package/src/shade/renderer/shader/chunk/light/lpv/chunk_lpv_mesh_lookup_nearest_cell.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"chunk_lpv_mesh_lookup_nearest_cell.d.ts","sourceRoot":"","sources":["../../../../../../../../src/shade/renderer/shader/chunk/light/lpv/chunk_lpv_mesh_lookup_nearest_cell.js"],"names":[],"mappings":"AAMA,2DAyDO;0BA/DmB,gCAAgC"}
+{"version":3,"file":"chunk_lpv_mesh_lookup_nearest_cell.d.ts","sourceRoot":"","sources":["../../../../../../../../src/shade/renderer/shader/chunk/light/lpv/chunk_lpv_mesh_lookup_nearest_cell.js"],"names":[],"mappings":"AAOA,2DAyDO;0BAhEmB,gCAAgC"}

package/src/shade/renderer/shader/chunk/light/lpv/chunk_lpv_mesh_lookup_nearest_cell.js

@@ -3,6 +3,7 @@ import { BVH_NULL_NODE_DEFINITION } from "../../bvh/BVH_NULL_NODE_DEFINITION.js"
 import { chunk_aabb3_intersects_point } from "../../geometry/aabb3/chunk_aabb3_intersects_point.js";
 import { chunk_lpv_mesh_get_barycentric_coordinates } from "./chunk_lpv_mesh_get_barycentric_coordinates.js";
 import { INVALID_TET_DECLARATION } from "./INVALID_TET_DECLARATION.js";
+import { LPV_LOOKUP_RESOURCE } from "../../../../global_illumination/probe/octahedral/LPV_SHADER_RESOURCE_GROUP.js";
 
 export const chunk_lpv_mesh_lookup_nearest_cell = CodeChunk.from(
     //language=WGSL
@@ -61,4 +62,6 @@ fn lpv_mesh_lookup_nearest_cell(position: vec3<f32>, out_weights:ptr<function, v
         BVH_NULL_NODE_DEFINITION,
         chunk_aabb3_intersects_point,
         chunk_lpv_mesh_get_barycentric_coordinates,
-    ]);
+    ]);
+
+chunk_lpv_mesh_lookup_nearest_cell.requireResource(LPV_LOOKUP_RESOURCE);

package/src/shade/renderer/shader/chunk/light/lpv/chunk_lpv_probe_get_data.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"chunk_lpv_probe_get_data.d.ts","sourceRoot":"","sources":["../../../../../../../../src/shade/renderer/shader/chunk/light/lpv/chunk_lpv_probe_get_data.js"],"names":[],"mappings":"AAEA,iDAgBG;0BAlBuB,gCAAgC"}
+{"version":3,"file":"chunk_lpv_probe_get_data.d.ts","sourceRoot":"","sources":["../../../../../../../../src/shade/renderer/shader/chunk/light/lpv/chunk_lpv_probe_get_data.js"],"names":[],"mappings":"AAGA,iDAgBG;0BAnBuB,gCAAgC"}

package/src/shade/renderer/shader/chunk/light/lpv/chunk_lpv_probe_get_data.js

@@ -1,4 +1,5 @@
 import { CodeChunk } from "../../../compiler/CodeChunk.js";
+import { LPV_PROBES_RESOURCE } from "../../../../global_illumination/probe/octahedral/LPV_SHADER_RESOURCE_GROUP.js";
 
 export const chunk_lpv_probe_get_data = CodeChunk.from(
     //language=WGSL
@@ -16,4 +17,6 @@ fn lpv_probe_get_data(probe_index:u32) -> array< vec3<f32>, 4 >{
         
     return out;
 }
-`);
+`);
+
+chunk_lpv_probe_get_data.requireResource(LPV_PROBES_RESOURCE);

package/src/shade/renderer/shader/chunk/light/lpv/chunk_lpv_probe_get_position.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"chunk_lpv_probe_get_position.d.ts","sourceRoot":"","sources":["../../../../../../../../src/shade/renderer/shader/chunk/light/lpv/chunk_lpv_probe_get_position.js"],"names":[],"mappings":"AAGA,qDAUO;0BAbmB,gCAAgC"}
+{"version":3,"file":"chunk_lpv_probe_get_position.d.ts","sourceRoot":"","sources":["../../../../../../../../src/shade/renderer/shader/chunk/light/lpv/chunk_lpv_probe_get_position.js"],"names":[],"mappings":"AAIA,qDAUO;0BAdmB,gCAAgC"}

package/src/shade/renderer/shader/chunk/light/lpv/chunk_lpv_probe_get_position.js

@@ -1,5 +1,6 @@
 import { CodeChunk } from "../../../compiler/CodeChunk.js";
 import { chunk_f32_array_as_vec3 } from "../../geometry/vec3/chunk_f32_array_as_vec3.js";
+import { LPV_PROBES_RESOURCE } from "../../../../global_illumination/probe/octahedral/LPV_SHADER_RESOURCE_GROUP.js";
 
 export const chunk_lpv_probe_get_position = CodeChunk.from(
     //language=WGSL
@@ -11,4 +12,6 @@ fn lpv_probe_get_position(probe_index: u32) -> vec3<f32>{
 }
 `, [
         chunk_f32_array_as_vec3
-    ]);
+    ]);
+
+chunk_lpv_probe_get_position.requireResource(LPV_PROBES_RESOURCE);

package/src/shade/renderer/shader/chunk/light/lpv/chunk_lpv_sample_radiance.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"chunk_lpv_sample_radiance.d.ts","sourceRoot":"","sources":["../../../../../../../../src/shade/renderer/shader/chunk/light/lpv/chunk_lpv_sample_radiance.js"],"names":[],"mappings":"AAOA,kDAkDO;0BAvDmB,gCAAgC"}
+{"version":3,"file":"chunk_lpv_sample_radiance.d.ts","sourceRoot":"","sources":["../../../../../../../../src/shade/renderer/shader/chunk/light/lpv/chunk_lpv_sample_radiance.js"],"names":[],"mappings":"AAQA,kDAkDO;0BAxDmB,gCAAgC"}

package/src/shade/renderer/shader/chunk/light/lpv/chunk_lpv_sample_radiance.js

@@ -4,6 +4,7 @@ import { CodeChunk } from "../../../compiler/CodeChunk.js";
 import { chunk_lpv_mesh_lookup_nearest_cell } from "./chunk_lpv_mesh_lookup_nearest_cell.js";
 import { chunk_lpv_mask_weights_by_visibility } from "./depth/chunk_lpv_mask_weights_by_visibility.js";
 import { INVALID_TET_DECLARATION } from "./INVALID_TET_DECLARATION.js";
+import { LPV_MESH_RESOURCE } from "../../../../global_illumination/probe/octahedral/LPV_SHADER_RESOURCE_GROUP.js";
 
 export const chunk_lpv_sample_radiance = CodeChunk.from(
     //language=WGSL
@@ -55,4 +56,6 @@ fn lpv_sample_radiance(
         chunk_lpv_mesh_lookup_nearest_cell,
         chunk_lpv_mask_weights_by_visibility,
 
-    ]);
+    ]);
+
+chunk_lpv_sample_radiance.requireResource(LPV_MESH_RESOURCE);

package/src/shade/renderer/shader/chunk/light/lpv/depth/chunk_lpv_mask_weights_by_visibility.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"chunk_lpv_mask_weights_by_visibility.d.ts","sourceRoot":"","sources":["../../../../../../../../../src/shade/renderer/shader/chunk/light/lpv/depth/chunk_lpv_mask_weights_by_visibility.js"],"names":[],"mappings":"AAMA,6DAqGO;AAGP,sEA+EO;0BA1LmB,mCAAmC"}
+{"version":3,"file":"chunk_lpv_mask_weights_by_visibility.d.ts","sourceRoot":"","sources":["../../../../../../../../../src/shade/renderer/shader/chunk/light/lpv/depth/chunk_lpv_mask_weights_by_visibility.js"],"names":[],"mappings":"AAOA,6DAqGO;AAKP,sEA+EO;0BA7LmB,mCAAmC"}

package/src/shade/renderer/shader/chunk/light/lpv/depth/chunk_lpv_mask_weights_by_visibility.js

@@ -3,6 +3,7 @@ import {
 } from "../../../../../global_illumination/lpv/deprecated/chunk_lpv_get_visibility_mask.js";
 import { CodeChunk } from "../../../../compiler/CodeChunk.js";
 import { chunk_lpv_mesh_get_vertices } from "../chunk_lpv_mesh_get_vertices.js";
+import { LPV_PROBES_RESOURCE } from "../../../../../global_illumination/probe/octahedral/LPV_SHADER_RESOURCE_GROUP.js";
 
 export const chunk_lpv_mask_weights_by_visibility = CodeChunk.from(
     //language=WGSL
@@ -107,6 +108,8 @@ fn lpv_mask_weights_by_visibility(
         chunk_lpv_get_visibility_mask
     ]);
 
+chunk_lpv_mask_weights_by_visibility.requireResource(LPV_PROBES_RESOURCE);
+
 
 export const chunk_lpv_mask_weights_by_visibility_no_depth = CodeChunk.from(
     //language=WGSL
@@ -187,4 +190,6 @@ fn lpv_mask_weights_by_visibility(
 `, [
         chunk_lpv_mesh_get_vertices,
         chunk_lpv_get_visibility_mask
-    ]);
+    ]);
+
+chunk_lpv_mask_weights_by_visibility_no_depth.requireResource(LPV_PROBES_RESOURCE);

package/src/shade/renderer/shader/chunk/light/lpv/depth/chunk_lpv_sample_depth_atlas.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"chunk_lpv_sample_depth_atlas.d.ts","sourceRoot":"","sources":["../../../../../../../../../src/shade/renderer/shader/chunk/light/lpv/depth/chunk_lpv_sample_depth_atlas.js"],"names":[],"mappings":"AAUA,qDA4CC;AAGD,4DA2BC;0BApFyB,mCAAmC"}
+{"version":3,"file":"chunk_lpv_sample_depth_atlas.d.ts","sourceRoot":"","sources":["../../../../../../../../../src/shade/renderer/shader/chunk/light/lpv/depth/chunk_lpv_sample_depth_atlas.js"],"names":[],"mappings":"AAeA,qDA4CC;AAMD,4DA2BC;0BA5FyB,mCAAmC"}

package/src/shade/renderer/shader/chunk/light/lpv/depth/chunk_lpv_sample_depth_atlas.js

@@ -7,6 +7,11 @@ import {
     chunk_texture_octahedral_wrap_texel_coordinates
 } from "../../../texture/octahedral/chunk_texture_octahedral_wrap_texel_coordinates.js";
 import { chunk_get_bilinear_weights } from "../../../texture/sample/chunk_get_bilinear_weights.js";
+import {
+    LPV_ATLAS_DEPTH_RESOURCE,
+    LPV_METADATA_RESOURCE
+} from "../../../../../global_illumination/probe/octahedral/LPV_SHADER_RESOURCE_GROUP.js";
+import { SAMPLER_LINEAR_RESOURCE } from "../../../../../texture/SAMPLER_LINEAR_RESOURCE.js";
 
 export const chunk_lpv_sample_depth_atlas = CodeChunk.from(
     //language=WGSL
@@ -54,6 +59,9 @@ fn lpv_sample_depth_atlas( direction: vec3<f32>, probe_index: u32 ) -> vec2<f32>
     ]
 )
 
+chunk_lpv_sample_depth_atlas.requireResource(LPV_ATLAS_DEPTH_RESOURCE);
+chunk_lpv_sample_depth_atlas.requireResource(LPV_METADATA_RESOURCE);
+
 
 export const chunk_lpv_sample_depth_atlas_native = CodeChunk.from(
     //language=WGSL
@@ -82,4 +90,8 @@ fn lpv_sample_depth_atlas( direction: vec3<f32>, probe_index: u32 ) -> vec2<f32>
         chunk_uv_to_texel_coordinate,
         chunk_index_to_grid2d,
     ]
-)
+)
+
+chunk_lpv_sample_depth_atlas_native.requireResource(LPV_ATLAS_DEPTH_RESOURCE);
+chunk_lpv_sample_depth_atlas_native.requireResource(LPV_METADATA_RESOURCE);
+chunk_lpv_sample_depth_atlas_native.requireResource(SAMPLER_LINEAR_RESOURCE);

package/src/shade/renderer/shader/chunk/material/MATERIAL_SHADING_INFO_STRUCT.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"MATERIAL_SHADING_INFO_STRUCT.d.ts","sourceRoot":"","sources":["../../../../../../../src/shade/renderer/shader/chunk/material/MATERIAL_SHADING_INFO_STRUCT.js"],"names":[],"mappings":"AAIA,wDAgB0B;6BAnBG,4BAA4B"}
+{"version":3,"file":"MATERIAL_SHADING_INFO_STRUCT.d.ts","sourceRoot":"","sources":["../../../../../../../src/shade/renderer/shader/chunk/material/MATERIAL_SHADING_INFO_STRUCT.js"],"names":[],"mappings":"AAIA,wDAuB0B;6BA1BG,4BAA4B"}

package/src/shade/renderer/shader/chunk/material/MATERIAL_SHADING_INFO_STRUCT.js

@@ -16,6 +16,13 @@ export const MATERIAL_SHADING_INFO_STRUCT = WebGPUStruct.from({
     specularF0: vec3f,
     specularF90: f32,
 
+    /**
+     * The two F0s that `specularF0` blends by metalness: the dielectric's (from its IOR) and the metal's (its
+     * base color). Multiple-scattering compensation needs them apart, see `compute_multiscattering_specular`.
+     */
+    specularF0_dielectric: vec3f,
+    specularF0_metal: vec3f,
+
     emissive: vec3f,
     opacity: f32,
 }, "MaterialShadingInfo");

package/src/shade/renderer/shader/chunk/material/MULTISCATTER.md

@@ -0,0 +1,159 @@
+# Multiple-scattering specular compensation
+
+Single-scattering GGX loses the light that bounces between microfacets more than once, and it loses the most
+on rough metals: a white metal at roughness 1 reflects 0.31 of a uniform sky (1 − ln 2 at N·V = 1). Both
+paths now restore it with Turquin's compensation (2019, eq. 16), from the split-sum LUT `tSplitSum`:
+
+- **Indirect**, `compute_indirect_specular` → `compute_multiscattering_specular`, as before.
+- **Direct**, `re_direct_multiscatter`: one LUT fetch per pass that shades direct light, after its last
+  light, scales the accumulated direct specular by (single + multiple) / single scattering. The ratio
+  depends on N·V, roughness and F0 alone, so it serves every light. It is called by
+  `shade_standard_material_direct` (the deferred and the forward paths), its ReSTIR twin, and
+  `restir_resolve`, so a ReSTIR pixel fetches twice (its directional lights, then its resampled light);
+  that cost is not measured. Not by the ReSTIR target function: that is a resampling weight, and the
+  compensation is a per-pixel scale of one lobe.
+
+It uses the material's roughness, not the roughness a sphere light widens it to in `re_direct_physical`.
+
+The same call scales the direct diffuse by what the dielectric's specular leaves, from the same fetch; see
+[Direct diffuse under the specular](#direct-diffuse-under-the-specular).
+
+## Why GI does not already cover it
+
+The indirect path's compensation scales the environment's light. The sun and local lights reach a pixel
+only through `re_direct_physical`, a separate additive pass. Measured in the Sponza playground with its
+shipped sun (intensity 7.2) and default IBL environment, the G-buffer read as rough gold
+(F0 1.0, 0.766, 0.336) in both the deferred pass and the indirect resolve, each pass replayed into cleared
+targets so that each pass's own contribution is measured. Means over shaded pixels, linear:
+
+| view | roughness | direct red, before → after | indirect red | direct share | luminance lost before |
+|---|---|---|---|---|---|
+| sunlit exterior | 0.8 | 0.734 → 1.193 | 0.577 | 64% | 22% (26% in red) |
+| sunlit exterior | 0.5 | 0.939 → 1.063 | 0.576 | 61% | 6% |
+| shaded atrium | 0.8 | 0.013 → 0.022 | 1.170 | 2% | 0.6% |
+
+Where the sun does not reach, GI dominates and the loss was already compensated. On sunlit rough metal,
+direct light is most of the pixel. Dielectrics barely move: Turquin's scale at F0 0.04 is at most 1.09.
+
+## Metalness
+
+Turquin's Fms = F0 makes the term quadratic in F0; metalness blends a dielectric F0 and a metal F0
+linearly. Evaluated at the blend, the term falls short by Kms · A · m(1 − m)(F0_metal − F0_dielectric)², so
+`compute_multiscattering_specular` takes both pure F0s (`specularF0_dielectric` and `specularF0_metal` on
+`MaterialShadingInfo`) and adds that back, written as a product that needs no metalness. EEVEE, Frostbite
+and three.js (#32190) evaluate the two separately and mix. For the albedo this is the same sum: exactly so
+in the indirect path, and in the direct path summed over a sky. Per light it is not, because the direct
+path applies the sum as one per-pixel ratio to the blend's lobe: under one directional light, a white
+surface at metalness 0.5 comes out −1.8% to +7.8% of the separately evaluated mix (worst at roughness 1,
+N·V 0.2, the light in the mirror direction). The blended F0 it replaced was up to 30% short there (roughness
+1, N·V 0.9, lit from beside the viewer).
+
+The indirect diffuse sits under the dielectric part only, so it keeps what the *dielectric's* specular
+leaves, not the blend's: the blend's also subtracted the metal's reflection, which the `1 − metalness` in
+`diffuse` had already removed.
+
+Measured against applying the term at the blended F0 (`deferred/white_furnace.spec.js`, white base,
+metalness 0.5): the direct specular came up to 0.157 of the sky short, the indirect resolve up to 0.33.
+Split, the direct is within 0.0028 of the blend and the indirect is the blend to one f32 ulp.
+
+## Direct diffuse under the specular
+
+`re_direct_physical` adds the EON diffuse on top of the GGX specular, and the light the specular reflected reached
+the diffuse as well: under a uniform sky a white dielectric returned 1.01 – 1.40 of it through direct light, the
+most at low roughness and grazing view. `re_direct_multiscatter` now scales the accumulated direct diffuse by
+1 − the dielectric's specular albedo at N·V: `compute_multiscattering_specular` at `specularF0_dielectric`, on the
+`f_ab` it already fetched. That is the indirect path's factor, "albedo scaling"; UE 5.4 does the same for direct
+light (`ComputeEnergyPreservation`, by luminance: always under Substrate, in legacy shading only with the project's
+energy-conservation setting on), as do EEVEE Next (by the RGB maximum) and OpenPBR / MaterialX
+(`throughput = 1 − dirAlbedo`). Filament leaves direct diffuse uncoupled (a TODO in
+`surface_shading_model_standard.fs`); three.js since #33985 scales it per light by 1 − F(V·H).
+
+The candidates, measured through `shader_deferred_main` on a white dielectric (roughness 0.26 – 0.99, N·V 0.10 –
+0.99, the spec's grid), and their cost on "Shade From G-Buffer" in Sponza (RTX 4090, 1898 × 982, inside the
+atrium, 16 unshadowed point lights added so that a per-light term shows; with the one sun all were within noise).
+The furnace is to ±0.005, the sky sampled coarsely; under a finer one the taken coupling reads 0.932 – 1.000 and
+Kulla–Conty's at most 1.002. These were measured with the direct lobe on F_Hauber and the LUT on Schlick's fourth
+power; with both on Schlick's fifth (`brdf/FRESNEL_BRIEF_2026_10_16.md`) the LUT's dielectric albedo is the direct
+lobe's own and the taken coupling reads 1.000 – 1.001 under the spec's sky:
+
+| coupling | furnace | cost, 16 point lights |
+|---|---|---|
+| none (before) | 1.01 – 1.40 | 427.6 µs |
+| 1 − E(N·V), per pixel (taken) | 0.93 – 1.00 | +0.1 – 0.2% (copy twin 0.998 – 1.002) |
+| 1 − F(V·H), per light (three.js) | 0.97 – 1.34 | +1.3% |
+| Kulla–Conty, (1 − E(N·L))(1 − E(N·V)) / (1 − E_avg), per light | 0.93 – 1.00 | +1.5% |
+| the same without 1 / (1 − E_avg) | 0.86 – 0.98 | |
+
+Per light, the Fresnel at V·H does not hold the furnace at grazing view. Kulla–Conty's does, is reciprocal, and adds
+the light's side of the interface, at a `tSplitSum` fetch per light, an E_avg it would need from a fit or a third
+LUT channel, and `tSplitSum` in the two ReSTIR passes that reach `re_direct_physical` through the target function
+(resample, whose candidates and temporal reuse call it, and spatial reuse).
+
+The ReSTIR target function stays uncoupled: it is a resampling weight, and the coupling is a per-pixel scale.
+
+Shipped: "Shade From G-Buffer" 80.2 against 80.2 µs and 88.6 against 87.8 µs without the coupling's line (Sponza
+with its sun, the views above; copy twin 0.991 – 1.010), and the pass's mean output 3% lower. On a grid of
+dielectric spheres under a sun, the change is at the lit rims and falls with roughness.
+
+## What the furnace holds
+
+`deferred/white_furnace.spec.js` lights one texel through the real passes: `shader_deferred_main` (a
+uniform sky as directional lights from GGX visible-normal sampling, with cosine samples beside them where a
+diffuse is lit, or one point light through the cluster) and `shader_resolve_indirect_lighting`. It holds:
+
+1. a white metal's direct light is the sky, to the sampling and the LUT's error (0.32 – 0.99 before the
+   compensation, 0.93 – 1.00 while the direct lobe was F_Hauber, whose dip the LUT did not hold, 0.997 – 1.000
+   now);
+2. the direct specular at any metalness is the blend of the pure dielectric's and the pure metal's, white
+   and gold, every channel, to 1.3e-5 (0.0028 under F_Hauber's offset);
+3. the indirect resolve is that blend to float rounding (0.67 – 0.90 of the sky at metalness 0.25 – 0.75
+   before);
+4. for a pure dielectric and a pure gold, the indirect specular is the direct, to the sampling and the LUT's
+   error (up to 0.068 above it under F_Hauber): this, not the white furnace, is what sees where the LUT is read;
+5. a point light is compensated as a directional light is;
+6. the ReSTIR twin shades its directional lights as the brute-force pass does;
+7. each channel is shaded by its own colour alone;
+8. a white dielectric's direct light is at most the sky (1.01 – 1.40 before, 0.932 – 1.000 with the coupling
+   under F_Hauber, 1.000 – 1.001 now);
+9. a white dielectric's direct and indirect totals agree, to the sampling and the LUT's and EON's errors;
+10. the direct diffuse keeps the share of the sky the indirect diffuse keeps, to EON's own albedo error and
+    the sampling's, 0.0015: this sees the coupling's strength more sharply than the totals, which carry EON's
+    albedo and the sampling of both lobes as well.
+
+Every mutant of the adversarial review is killed — the call doubled or moved ahead of the cluster loop, F0
+for the variance, the variance's sign or half of it, either path's LUT read with its coordinates swapped or at
+roughness², the guard at 1e-1, the diffuse coupled to the blend, a dielectric F0 of 0.08, the term at
+0.5, 0.9, 0.97 or 1.1 of itself, Fms = 1, the diffuse compensated too, a metal F0 of 1 in either path, one
+channel's ratio for all or none for blue, the ReSTIR twin's call removed — but one: `restir_resolve`'s own
+call. That pass needs the ray-tracing group and is not run at this tier.
+
+So is every mutant of the diffuse coupling: removed, doubled, put on the specular, taken from the blend's albedo,
+without the dielectric's multiple scattering, at 0.9, 0.97, 1.03 or 1.1 of itself, at F0 0.08, by F0 alone, with
+F90 = 0, by the white lobe's albedo, or read at N·V = 1, with its coordinates swapped, at roughness² or at 0.8 N·V.
+The multiple-scattering and ±3% ones die only by item 10.
+
+What is left on purpose:
+
+- **The LUT's edge.** Texel centres are (i + 0.5) / 64, so roughness 1 reads 0.992's albedo: 3% at
+  roughness 1, N·V 1.
+- **The resolve's horizon occlusion.** Its bent-normal specular occlusion cuts a lobe reaching under the
+  horizon even with nothing there: 0.0041 at roughness 0.51, N·V 0.10. The spec divides it out.
+
+## Cost
+
+RTX 4090, Sponza from inside the atrium at 1898 × 982 (every pixel shaded), one sun, "Shade From G-Buffer"
+with and without the call, interleaved in one capture (4-frame blocks, alternating order, 4 captures per
+view): 79.8 against 74.6 µs and 89.6 against 83.0 µs, +7%, ~0.2% of the frame. A byte-identical twin read
+0.997 – 1.009 of the shipped pass.
+
+## Measured and not changed here
+
+- **The direct diffuse is coupled on the view's side only.** It keeps 1 − E(N·V) whatever the light's
+  angle, so a smooth dielectric's diffuse under a grazing light is not dimmed by the Fresnel the light meets on
+  the way in: at roughness 0.26, N·V 0.9, it keeps 0.96 of the uncoupled diffuse at every N·L, where
+  Kulla–Conty's keeps 0.57 at N·L 0.1 and 1.02 at N·L 1 (within 7% of each other at roughness 0.99). Under a
+  uniform sky the two agree within 0.007 of it; the cost of Kulla–Conty's is in the section above.
+- **Light the LPV injects is single-scattering.** `graph_lpv_shade.js` shades a probe ray's hit with its own
+  `BRDF_GGX` and (1 − F) diffuse, so in LPV mode a rough metal bounces its uncompensated direct light.
+- **The path tracer is single-scattering**, so for rough metals it is not the reference: it reflects what
+  the rasterizer did before this.

package/src/shade/renderer/shader/chunk/material/chunk_compute_indirect_specular.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"chunk_compute_indirect_specular.d.ts","sourceRoot":"","sources":["../../../../../../../src/shade/renderer/shader/chunk/material/chunk_compute_indirect_specular.js"],"names":[],"mappings":"AAKA,wDAmDC;0BAxDyB,6BAA6B"}
+{"version":3,"file":"chunk_compute_indirect_specular.d.ts","sourceRoot":"","sources":["../../../../../../../src/shade/renderer/shader/chunk/material/chunk_compute_indirect_specular.js"],"names":[],"mappings":"AAOA,wDAsEC;0BA7EyB,6BAA6B"}

package/src/shade/renderer/shader/chunk/material/chunk_compute_indirect_specular.js

@@ -2,6 +2,8 @@ import { CodeChunk } from "../../compiler/CodeChunk.js";
 import { chunk_max_v3 } from "../geometry/vec3/chunk_max_v3.js";
 import { chunk_compute_multiscattering_specular } from "../light/chunk_compute_multiscattering_specular.js";
 import { RECIPROCAL_PI_DECLARATION } from "../math/RECIPROCAL_PI_DECLARATION.js";
+import { SPLIT_SUM_LUT_RESOURCE } from "../../../STATIC_GRAPHICS_ENGINE_ASSET_RESOURCES.js";
+import { SAMPLER_LINEAR_RESOURCE } from "../../../texture/SAMPLER_LINEAR_RESOURCE.js";
 
 export const chunk_compute_indirect_specular = CodeChunk.from(
     //language=WGSL
@@ -13,6 +15,8 @@ fn compute_indirect_specular(
     view_direction: vec3<f32>,
     material_diffuse: vec3<f32>,
     material_specularF0: vec3<f32>,
+    material_specularF0_dielectric: vec3<f32>,
+    material_specularF0_metal: vec3<f32>,
     material_specularF90: f32,
     material_roughness: f32
 ) -> mat2x3<f32> {
@@ -28,17 +32,34 @@ fn compute_indirect_specular(
 	compute_multiscattering_specular(
         f_ab,
         material_specularF0,
+        material_specularF0_dielectric,
+        material_specularF0_metal,
         material_specularF90,
         &single_scattering,
-        &multi_scattering 
+        &multi_scattering
     );
 
 	let totalScattering = single_scattering + multi_scattering;
-	
+
 	var indirect_specular = radiance * totalScattering;
-	
+
+	// diffuse lies under the dielectric part of the surface only (material_diffuse carries its 1 - metalness),
+	// so it keeps what the dielectric's specular leaves; the blend's would subtract the metal's reflection too
+	var single_scattering_dielectric = vec3<f32>( 0.0 );
+	var multi_scattering_dielectric = vec3<f32>( 0.0 );
+
+	compute_multiscattering_specular(
+        f_ab,
+        material_specularF0_dielectric,
+        material_specularF0_dielectric,
+        material_specularF0_dielectric,
+        material_specularF90,
+        &single_scattering_dielectric,
+        &multi_scattering_dielectric
+    );
+
 	// diffuse refelections will only be a portion of whatever remain after spec
-	let conservation_factor = saturate(vec3<f32>(1.0) - totalScattering);
+	let conservation_factor = saturate(vec3<f32>(1.0) - (single_scattering_dielectric + multi_scattering_dielectric));
 	
 	let cosineWeightedIrradiance = irradiance * RECIPROCAL_PI;
 	let diffuse = material_diffuse * conservation_factor;
@@ -54,4 +75,7 @@ fn compute_indirect_specular(
         RECIPROCAL_PI_DECLARATION,
         chunk_max_v3,
     ]
-)
+)
+
+chunk_compute_indirect_specular.requireResource(SAMPLER_LINEAR_RESOURCE);
+chunk_compute_indirect_specular.requireResource(SPLIT_SUM_LUT_RESOURCE);

package/src/shade/renderer/shader/chunk/material/chunk_re_direct_multiscatter.d.ts

@@ -0,0 +1,24 @@
+/**
+ * Multiple-scattering compensation for the direct specular, and the direct diffuse's share of what the
+ * specular leaves, once per pixel after the last light.
+ *
+ * `re_direct_physical` evaluates single-scattering GGX per light, which loses the energy that bounces
+ * between microfacets more than once: a rough white metal reflects 0.31 of a uniform sky. Turquin's
+ * compensation (2019, eq. 16) scales the single-scattering lobe by the ratio of the lobe's total albedo to its
+ * single-scattering albedo, both from the split-sum LUT the indirect path already samples. The ratio depends
+ * on N·V, roughness and the material's F0s alone, so one LUT fetch here serves every light the pass
+ * accumulated, and the indirect path's `compute_multiscattering_specular` supplies it, so the two paths cannot
+ * disagree.
+ *
+ * `re_direct_physical` also adds its diffuse on top of the specular, and a white dielectric returned up to 1.4
+ * of a uniform sky that way. The diffuse is scaled here by 1 − the dielectric's specular albedo at N·V, from the
+ * same fetch: the indirect path's factor, and what UE5, EEVEE and OpenPBR apply ("albedo scaling"). It is
+ * the view's side of the interface only; the light's (Kulla–Conty's 1 − E(N·L)) would cost a fetch per light.
+ *
+ * Requires `tSplitSum` and `sLinear` in the shader's resources. See `MULTISCATTER.md` beside this chunk.
+ *
+ * @type {CodeChunk}
+ */
+export const chunk_re_direct_multiscatter: CodeChunk;
+import { CodeChunk } from "../../compiler/CodeChunk.js";
+//# sourceMappingURL=chunk_re_direct_multiscatter.d.ts.map

package/src/shade/renderer/shader/chunk/material/chunk_re_direct_multiscatter.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"chunk_re_direct_multiscatter.d.ts","sourceRoot":"","sources":["../../../../../../../src/shade/renderer/shader/chunk/material/chunk_re_direct_multiscatter.js"],"names":[],"mappings":"AAQA;;;;;;;;;;;;;;;;;;;;GAoBG;AACH,2CAFU,SAAS,CAqDjB;0BAhFwB,6BAA6B"}