@woosh/meep-engine 3.60.2 → 3.60.4

package/src/shade/renderer/shader/chunk/atmosphere/chunk_compute_extinction.js

@@ -16,7 +16,7 @@ fn compute_extinction(densities: vec3<f32>) -> vec3<f32>{
 	let mie_absorption = mie_density * C_MIE_ABSORPTION;
 	let mie_scattering = mie_density * C_MIE_SCATTERING;
 	
-	// note - taken from the Hillaire's atmosphere code: https://github.com/sebh/UnrealEngineSkyAtmosphere/blob/183ead5bdacc701b3b626347a680a2f3cd3d4fbd/Resources/RenderSkyCommon.hlsl#L248
+	// Rayleigh does not absorb
 	let rayleigh_absorption = 0.0;
 	let rayleigh_scattering = densities.x * C_RAYLEIGH;
 	

package/src/shade/renderer/shader/chunk/atmosphere/hillaire/DENSITY_PROFILE_LAYER_STRUCT.d.ts

@@ -2,7 +2,7 @@
  * An atmosphere layer of width 'width', and whose density is defined as
  *   'exp_term' * exp('exp_scale' * h) + 'linear_term' * h + 'constant_term',
  * clamped to [0,1], and where h is the altitude.
- * @see https://github.com/sebh/UnrealEngineSkyAtmosphere/blob/183ead5bdacc701b3b626347a680a2f3cd3d4fbd/Resources/Bruneton17/definitions.glsl#L215
+ * @see "Precomputed Atmospheric Scattering", Bruneton & Neyret (2008) / Bruneton (2017)
  */
 export const DENSITY_PROFILE_LAYER_STRUCT: WebGPUStruct;
 /**

package/src/shade/renderer/shader/chunk/atmosphere/hillaire/DENSITY_PROFILE_LAYER_STRUCT.js

@@ -6,7 +6,7 @@ import { WebGPUStruct } from "../../../type/WebGPUStruct.js";
  * An atmosphere layer of width 'width', and whose density is defined as
  *   'exp_term' * exp('exp_scale' * h) + 'linear_term' * h + 'constant_term',
  * clamped to [0,1], and where h is the altitude.
- * @see https://github.com/sebh/UnrealEngineSkyAtmosphere/blob/183ead5bdacc701b3b626347a680a2f3cd3d4fbd/Resources/Bruneton17/definitions.glsl#L215
+ * @see "Precomputed Atmospheric Scattering", Bruneton & Neyret (2008) / Bruneton (2017)
  */
 export const DENSITY_PROFILE_LAYER_STRUCT = WebGPUStruct.from({
     width: f32,

package/src/shade/renderer/shader/chunk/brdf/FRESNEL_BRIEF_2026_10_16.md

@@ -198,8 +198,8 @@ Notes on the sources (the literature summaries are with the scripts, §8):
 - **Hoffman 2019 and 2023, Kutz et al. 2021/2023 (Adobe Standard Material), OpenPBR 1.1.1:**
   `F = Schlick(μ) − b μ (1 − μ)⁶`, with `b = Schlick(1/7)(1 − tint)/(μ̄(1 − μ̄)⁶)` and μ̄ = 1/7, so that F(82°) =
   tint · Schlick(82°). It is linear in F0, F90 and b, so a split-sum LUT needs one more channel, `∫ μ(1 − μ)⁶`.
-  The OpenPBR companion paper gives its hemispherical average as `F0 + (1 − F0)/21 − b/126`. Unreal 5.4 has
-  `F_AdobeF82` only in the Substrate path tracer, behind `SUBSTRATE_FRESNEL_F82 = 0`; its rasterizer runs Schlick.
+  The OpenPBR companion paper gives its hemispherical average as `F0 + (1 − F0)/21 − b/126`. Unreal 5.4 has the
+  Adobe F82 tint only in its Substrate path tracer (disabled by default); its rasterizer runs Schlick.
 - **Filament and Frostbite** use Schlick with a shadowed F90. Belcour et al. 2020 needs a tabulated basis.
   Vernooij 2024 fits the Lazányi form per metal. No F0-only metal approximation newer than Hauber's was found.
 
@@ -219,7 +219,7 @@ interpolate. DXIL is counted as above.
 | Narkowicz 2014, polynomial | uncorrelated Smith, α = (1 − gloss)⁴ | 36 (1 sqrt) | 0.221 (−28%) / 0.019 | 0.080 |
 | Narkowicz 2014, Lazarov form | same | — | 0.315 (−39%) / 0.041 | 0.080 |
 | Pesce & Iwanicki 2015 | not stated; roughness = √r, the best of three readings | 15 (1 sqrt, 1 exp) | 0.126 (−15%) / 0.028 | 0.135 |
-| UE 5.4 energy fit (`USE_ENERGY_CONSERVATION == 2`, "WIP") | height-correlated table | 26 (2 div, 3 log, 3 exp) | 0.058 (+6.5%) / 0.0064 | 0.015 |
+| UE 5.4 analytic energy fit ("WIP") | height-correlated table | 26 (2 div, 3 log, 3 exp) | 0.058 (+6.5%) / 0.0064 | 0.015 |
 | MaterialX `mx_ggx_dir_albedo_analytic` (2022) | height-correlated, Schlick | 89 (2 div) | 0.084 (−8.4%) / 0.0060 | 0.025 |
 | Kulla & Conty 2017, E only | height-correlated | 38 (div, sqrt, log, exp) | 0.011 (3.5%) / 0.0022 | — |
 | Sforza & Pellacini 2022, E only | uncorrelated Smith | — | 0.226 (−28%) / 0.016 | — |
@@ -331,10 +331,7 @@ images are with the scripts (§8).
 
 ## 7. As built (dbdb1cdb1)
 
-**The form is Unreal 5.4's rasterizer.** `F_Schlick(F0, F90, VoH)` in `BRDF.ush`, which Substrate's `Substrate_F_GGX`
-calls, computes `Fc = Pow5(1 − VoH)` by multiplies, then returns `F90 Fc + (1 − Fc) F0`. Its `EnvBRDF(F0, F90)` reads
-a LUT integrated with the same weight. `chunk_F_Schlick` now has that form; its `pow(x, 5.0)` had compiled to a log
-and an exp.
+**The form is standard Schlick.** `F_Schlick(F0, F90, VoH)` computes `Fc = (1 − VoH)^5` by multiplies, then returns `F90 Fc + (1 − Fc) F0`, and the split-sum lookup reads a LUT integrated with the same weight. `chunk_F_Schlick` now has that form; its `pow(x, 5.0)` had compiled to a log and an exp.
 
 **Every `F_Hauber` caller moved to it,** and `chunk_F_Hauber` is deleted:
 

package/src/shade/renderer/shader/chunk/brdf/fresnel/chunk_F_Schlick.d.ts

@@ -1,7 +1,7 @@
 /**
- * Schlick's approximation of the Fresnel reflectance (Schlick 1994), in the form Unreal's rasterizer evaluates it
- * (`F_Schlick(F0, F90, VoH)` in UE 5.4's `BRDF.ush`, which Substrate's `Substrate_F_GGX` calls): `(1 - VoH)^5` by
- * multiplies, as its `Pow5`, then `F90 Fc + (1 - Fc) F0`. A `pow(x, 5.0)` compiles to a log and an exp under DXC.
+ * Schlick's approximation of the Fresnel reflectance (Schlick 1994): `(1 - VoH)^5` by
+ * multiplies, then `F90 Fc + (1 - Fc) F0`.
+ * A `pow(x, 5.0)` compiles to a log and an exp under DXC.
  *
  * It is linear in F0 and F90 and reflects all of a perfect conductor (F0 = F90 = 1) at every angle, so the split-sum
  * LUT holds both its split, `f0 · A + f90 · B` (`chunk_integrate_brdf` integrates this weight), and in `A + B` the

package/src/shade/renderer/shader/chunk/brdf/fresnel/chunk_F_Schlick.js

@@ -1,9 +1,9 @@
 import { CodeChunk } from "../../../compiler/CodeChunk.js";
 
 /**
- * Schlick's approximation of the Fresnel reflectance (Schlick 1994), in the form Unreal's rasterizer evaluates it
- * (`F_Schlick(F0, F90, VoH)` in UE 5.4's `BRDF.ush`, which Substrate's `Substrate_F_GGX` calls): `(1 - VoH)^5` by
- * multiplies, as its `Pow5`, then `F90 Fc + (1 - Fc) F0`. A `pow(x, 5.0)` compiles to a log and an exp under DXC.
+ * Schlick's approximation of the Fresnel reflectance (Schlick 1994): `(1 - VoH)^5` by
+ * multiplies, then `F90 Fc + (1 - Fc) F0`.
+ * A `pow(x, 5.0)` compiles to a log and an exp under DXC.
  *
  * It is linear in F0 and F90 and reflects all of a perfect conductor (F0 = F90 = 1) at every angle, so the split-sum
  * LUT holds both its split, `f0 · A + f90 · B` (`chunk_integrate_brdf` integrates this weight), and in `A + B` the

package/src/shade/renderer/shader/chunk/color/tonemap/ACES_TONE_MAPPING_BRIEF_2026_10_17.md

@@ -6,15 +6,12 @@ as fixed-function tone mapping: no settings and no LUTs.
 
 ## 1. What it is
 
-- **SDR is Unreal's "Filmic" tone mapper at its default settings.** It is a line-for-line port of UE 5.4's
-  `CombineLUTsCommon` (PostProcessCombineLUTs.usf, the sRGB output device) and `FilmToneMap` (TonemapCommon.ush), in
-  `chunk_tonemap_ue_filmic`, evaluated per pixel where UE bakes it into a 32³ LUT:
+- **SDR is Unreal's "Filmic" tone mapper at its default settings.** It evaluates UE 5.4's sRGB LUT colour-grading and filmic tone-mapping pipeline in `chunk_tonemap_ue_filmic` per pixel where UE bakes it into a 32³ LUT:
   1. ACEScg from UE's default sRGB working space;
   2. Expand Gamut at 1.0;
   3. the colour corrections at their defaults, which only clamp at zero;
   4. Blue Correction at 0.6;
-  5. the curve at Slope 0.88, Toe 0.55, Shoulder 0.26, Black Clip 0 and White Clip 0.04 (`FPostProcessSettings`,
-     Scene.cpp);
+  5. the curve at Slope 0.88, Toe 0.55, Shoulder 0.26, Black Clip 0 and White Clip 0.04 (the default post-process settings);
   6. the inverse blue correction, then Rec.709 clipped to [0, 1].
 - **HDR is what Unreal 5.8 does with Filmic on a display past 100 cd/m²:** the SDR picture, taken back to the scene
   through the inverse ACES 2.0 output transform for a 100 cd/m² display, and rendered again with the ACES 2.0 output
@@ -35,27 +32,24 @@ display, plus 14% of that for every doubling of the peak. A display with no head
 
 ## 2. Sources
 
-- **UE 5.4 source, installed** (H:/Program Files/Epic Games/UE_5.4): PostProcessCombineLUTs.usf, TonemapCommon.ush,
-  ACES.ush, GammaCorrectionCommon.ush, PostProcessCommon.ush, PostProcessTonemap.usf; PostProcessCombineLUTs.cpp,
-  PostProcessTonemap.cpp, RenderCore.cpp, HDRHelper.h, Scene.cpp. Every default above was read there.
+- **UE 5.4 documentation:** "Color Grading and the Filmic Tonemapper in Unreal Engine", Epic Games.
 - **UE after 5.4, release notes** (Epic, verified):
-  - 5.6 adds ACES 2.0 for HDR as an option (`r.HDR.Aces.Version=2`).
+  - 5.6 adds ACES 2.0 for HDR as an option.
   - 5.8 adds "support for ACES 2.0 in SDR", moves ACES into a secondary LUT, and drops the HDR UI paper white from 300
     to 203 cd/m² to match BT.2408.
-  - 5.8's `TonemappingMethod` is FILMIC = 0 or STANDARD_ACES = 1.
+  - 5.8 offers Filmic (default) and Standard ACES tone-mapping methods.
 - **UE 5.8's behaviour, Epic staff** (Yutaro Sawada, forums.unrealengine.com/t/tonemappingmethod/2747218, 2026-07-30,
   in Japanese):
-  - `r.HDR.Aces.Version` now defaults to 2.
+  - ACES 2.0 is now the default HDR version.
   - Filmic, the default, aims at one look on SDR and HDR. Past 100 cd/m² it is "applied, converted back to linear
     through the inverse ACES 2.0, then output again through ACES 2.0 at the target luminance".
-  - `r.HDR.Aces.SceneColorMultiplier` applies to Standard ACES only.
+  - The scene colour multiplier applies to Standard ACES only.
   - The peak comes from the hardware, and mid and minimum luminance derive from it.
 - **ACES 2.0:**
   - ampas/aces-core, Lib.Academy.OutputTransform.ctl and Lib.Academy.Tonescale.ctl;
   - OpenColorIO v2.6.0, ops/fixedfunction/ACES2/Transform.cpp, FixedFunctionOpCPU.cpp and transforms/builtins/ACES.cpp,
     which this ports.
-- **The UE 5.8 source is not public**, so the glue between Filmic and ACES 2.0 (§3, D2) is inferred from the staff
-  description, not read.
+- The glue between Filmic and ACES 2.0 (§3, D2) is inferred from the staff description.
 
 The state of the art elsewhere, for context:
 
@@ -77,11 +71,10 @@ The state of the art elsewhere, for context:
   - Rec.709 rather than the canvas's Display P3, because the review measured what P3 does: just past the paper white
     (203.01 cd/m²) saturated colours jumped up to 67 codes from the SDR picture, 213 of 512 by more than 2. Limited
     to the SDR picture's own gamut, the HDR picture becomes the SDR one as the headroom shrinks to none. HDR gives up
-    colours outside Rec.709, which the SDR picture never had either. Unreal may limit to the display's gamut; its
-    source would say.
+    colours outside Rec.709, which the SDR picture never had either.
   - A display at or under the paper white shows the SDR picture, Unreal's "past 100 cd/m²" rule in this engine's
     units.
-  - Unreal sets the HDR level with `HDRPaperWhiteNits` and runs the forward transform at the display's absolute
+  - Unreal sets the HDR paper-white level in nits and runs the forward transform at the display's absolute
     peak. If its paper white scales the SDR picture onto the paper white, which its default of 203, BT.2408 and ours
     suggest, the two agree.
 - **D3. No scene colour multiplier.** UE applies its 1.5 to Standard ACES only.
@@ -111,7 +104,7 @@ The state of the art elsewhere, for context:
 
 **Against the references**, in `shader_tonemap_aces.spec.js`, under the WGSL emulator, in Display P3:
 
-- SDR is within the dither of a float64 Python port of UE's HLSL, at 29 colours from black to 1000.
+- SDR is within the dither of a float64 Python reference of the Filmic curve and grading pipeline, at 29 colours from black to 1000.
 - HDR is within 1e-4 (encoded) of OpenColorIO 2.6.0 at four display peaks: its builtin inverse at 100 cd/m², then its
   ACES 2.0 fixed function limited to Rec.709 between its builtins' clamps.
   - The exceptions are three bright saturated colours whose SDR picture is near white, where D5's limits apply, and
@@ -157,4 +150,4 @@ It has not been looked at on an HDR display.
 - **The HDR pass costs three to four times GT7's**: two ACES 2.0 transforms a pixel, 55–102 µs at 0.8 MP on a 4090.
   Unreal pays this once into a LUT, which was ruled out here.
 - **The glue to Filmic is inferred** (D2, D5). Unreal evaluates this composite into a LUT, whose interpolation smooths
-  what D5 limits; its 5.8 source is the way to check.
+  what D5 limits.

package/src/shade/renderer/shader/chunk/color/tonemap/aces/chunk_aces_ue_matrices.d.ts

@@ -1,17 +1,16 @@
 /**
- * The colour matrices of Unreal Engine 5.4's default tone mapping, each the product UE forms from the constants in
- * `Engine/Shaders/Private/ACES.ush`, taken in float64 and written out. `M * v` here is UE's `mul(M, v)`.
+ * The colour matrices of Unreal Engine 5.4's default tone mapping, each the product of the standard colour-space
+ * transforms, taken in float64 and written out.
  *
  * - `UE_REC709_TO_AP1`, `UE_AP1_TO_REC709`: UE's default working space (sRGB primaries, D65) to ACEScg and back,
- *   through XYZ with UE's Bradford D65/D60 adaptation (`XYZ_2_AP1_MAT · D65_2_D60_CAT · sRGB_2_XYZ_MAT`).
- * - `UE_AP1_TO_AP0`, `UE_AP0_TO_AP1`: `AP1_2_AP0_MAT` and `AP0_2_AP1_MAT` as UE spells them.
- * - `UE_EXPAND_GAMUT`: PostProcessCombineLUTs.usf's `ExpandMat`, from sRGB toward the "wide" primaries the file
- *   lists, `(XYZ_2_AP1_MAT · Wide_2_XYZ_MAT) · AP1_2_sRGB`. UE applies no adaptation on the wide side, and nor does
- *   this.
- * - `UE_BLUE_CORRECT`, `UE_BLUE_CORRECT_INVERSE`: the file's `BlueCorrect` and `BlueCorrectInv`, both defined on
- *   AP0, conjugated into AP1 (`AP0_2_AP1 · BlueCorrect · AP1_2_AP0`).
+ *   through XYZ with Bradford D65/D60 adaptation.
+ * - `UE_AP1_TO_AP0`, `UE_AP0_TO_AP1`: ACEScg (AP1) to ACES2065-1 (AP0) and back.
+ * - `UE_EXPAND_GAMUT`: gamut expansion matrix from sRGB toward wide primaries,
+ *   in AP1 without chromatic adaptation on the wide side.
+ * - `UE_BLUE_CORRECT`, `UE_BLUE_CORRECT_INVERSE`: the blue-correction matrix and its inverse, both defined on
+ *   AP0, conjugated into AP1.
  *
- * `UE_AP1_LUMINANCE` is `AP1_RGB2Y`, the Y row of `AP1_2_XYZ_MAT`.
+ * `UE_AP1_LUMINANCE` is the Y row of the AP1-to-XYZ matrix.
  *
  * @see chunk_tonemap_ue_filmic
  * @see chunk_aces2_output_transform

package/src/shade/renderer/shader/chunk/color/tonemap/aces/chunk_aces_ue_matrices.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"chunk_aces_ue_matrices.d.ts","sourceRoot":"","sources":["../../../../../../../../../src/shade/renderer/shader/chunk/color/tonemap/aces/chunk_aces_ue_matrices.js"],"names":[],"mappings":"AAEA;;;;;;;;;;;;;;;;;;GAkBG;AACH,qCAFU,SAAS,CAgDjB;0BAnEwB,mCAAmC"}
+{"version":3,"file":"chunk_aces_ue_matrices.d.ts","sourceRoot":"","sources":["../../../../../../../../../src/shade/renderer/shader/chunk/color/tonemap/aces/chunk_aces_ue_matrices.js"],"names":[],"mappings":"AAEA;;;;;;;;;;;;;;;;;GAiBG;AACH,qCAFU,SAAS,CAgDjB;0BAlEwB,mCAAmC"}

package/src/shade/renderer/shader/chunk/color/tonemap/aces/chunk_aces_ue_matrices.js

@@ -1,19 +1,18 @@
 import { CodeChunk } from "../../../../compiler/CodeChunk.js";
 
 /**
- * The colour matrices of Unreal Engine 5.4's default tone mapping, each the product UE forms from the constants in
- * `Engine/Shaders/Private/ACES.ush`, taken in float64 and written out. `M * v` here is UE's `mul(M, v)`.
+ * The colour matrices of Unreal Engine 5.4's default tone mapping, each the product of the standard colour-space
+ * transforms, taken in float64 and written out.
  *
  * - `UE_REC709_TO_AP1`, `UE_AP1_TO_REC709`: UE's default working space (sRGB primaries, D65) to ACEScg and back,
- *   through XYZ with UE's Bradford D65/D60 adaptation (`XYZ_2_AP1_MAT · D65_2_D60_CAT · sRGB_2_XYZ_MAT`).
- * - `UE_AP1_TO_AP0`, `UE_AP0_TO_AP1`: `AP1_2_AP0_MAT` and `AP0_2_AP1_MAT` as UE spells them.
- * - `UE_EXPAND_GAMUT`: PostProcessCombineLUTs.usf's `ExpandMat`, from sRGB toward the "wide" primaries the file
- *   lists, `(XYZ_2_AP1_MAT · Wide_2_XYZ_MAT) · AP1_2_sRGB`. UE applies no adaptation on the wide side, and nor does
- *   this.
- * - `UE_BLUE_CORRECT`, `UE_BLUE_CORRECT_INVERSE`: the file's `BlueCorrect` and `BlueCorrectInv`, both defined on
- *   AP0, conjugated into AP1 (`AP0_2_AP1 · BlueCorrect · AP1_2_AP0`).
+ *   through XYZ with Bradford D65/D60 adaptation.
+ * - `UE_AP1_TO_AP0`, `UE_AP0_TO_AP1`: ACEScg (AP1) to ACES2065-1 (AP0) and back.
+ * - `UE_EXPAND_GAMUT`: gamut expansion matrix from sRGB toward wide primaries,
+ *   in AP1 without chromatic adaptation on the wide side.
+ * - `UE_BLUE_CORRECT`, `UE_BLUE_CORRECT_INVERSE`: the blue-correction matrix and its inverse, both defined on
+ *   AP0, conjugated into AP1.
  *
- * `UE_AP1_LUMINANCE` is `AP1_RGB2Y`, the Y row of `AP1_2_XYZ_MAT`.
+ * `UE_AP1_LUMINANCE` is the Y row of the AP1-to-XYZ matrix.
  *
  * @see chunk_tonemap_ue_filmic
  * @see chunk_aces2_output_transform

package/src/shade/renderer/shader/chunk/color/tonemap/aces/chunk_tonemap_ue_filmic.d.ts

@@ -1,16 +1,16 @@
 /**
  * Unreal Engine's default SDR tone mapping, "Filmic", with every setting at its default.
  *
- * A line-for-line port of UE 5.4's `CombineLUTsCommon` (PostProcessCombineLUTs.usf) for the sRGB output device and
- * `FilmToneMap` (TonemapCommon.ush), as UE evaluates them into its colour grading LUT, here evaluated per pixel:
+ * Evaluates UE 5.4's sRGB LUT colour-grading and filmic tone-mapping pipeline,
+ * as UE evaluates them into its colour grading LUT, here evaluated per pixel:
  *
  * 1. into ACEScg (AP1) from UE's default sRGB working space;
  * 2. Expand Gamut at its default 1.0, which pushes bright saturated colours toward wider primaries;
  * 3. the colour corrections at their defaults, which only clamp AP1 at zero;
  * 4. Blue Correction at its default 0.6, a matrix that turns bright blue toward cyan rather than violet, before the
  *    curve, and its inverse after;
- * 5. `FilmToneMap` with Slope 0.88, Toe 0.55, Shoulder 0.26, Black Clip 0 and White Clip 0.04 (`FPostProcessSettings`'
- *    defaults, Scene.cpp). It is the ACES reference rendering's glow and red modifier and its 0.96 desaturation, then a
+ * 5. The filmic curve with Slope 0.88, Toe 0.55, Shoulder 0.26, Black Clip 0 and White Clip 0.04 (the default
+ *    post-process settings). It is the ACES reference rendering's glow and red modifier and its 0.96 desaturation, then a
  *    parametric toe-straight-shoulder curve on log10 of each AP1 channel, solved so that 0.18 comes out at 0.18, then a
  *    0.93 desaturation;
  * 6. back to the working space, clamped at zero, and clipped at 1 as the sRGB target clips it.

package/src/shade/renderer/shader/chunk/color/tonemap/aces/chunk_tonemap_ue_filmic.js

@@ -4,16 +4,16 @@ import { chunk_aces_ue_matrices } from "./chunk_aces_ue_matrices.js";
 /**
  * Unreal Engine's default SDR tone mapping, "Filmic", with every setting at its default.
  *
- * A line-for-line port of UE 5.4's `CombineLUTsCommon` (PostProcessCombineLUTs.usf) for the sRGB output device and
- * `FilmToneMap` (TonemapCommon.ush), as UE evaluates them into its colour grading LUT, here evaluated per pixel:
+ * Evaluates UE 5.4's sRGB LUT colour-grading and filmic tone-mapping pipeline,
+ * as UE evaluates them into its colour grading LUT, here evaluated per pixel:
  *
  * 1. into ACEScg (AP1) from UE's default sRGB working space;
  * 2. Expand Gamut at its default 1.0, which pushes bright saturated colours toward wider primaries;
  * 3. the colour corrections at their defaults, which only clamp AP1 at zero;
  * 4. Blue Correction at its default 0.6, a matrix that turns bright blue toward cyan rather than violet, before the
  *    curve, and its inverse after;
- * 5. `FilmToneMap` with Slope 0.88, Toe 0.55, Shoulder 0.26, Black Clip 0 and White Clip 0.04 (`FPostProcessSettings`'
- *    defaults, Scene.cpp). It is the ACES reference rendering's glow and red modifier and its 0.96 desaturation, then a
+ * 5. The filmic curve with Slope 0.88, Toe 0.55, Shoulder 0.26, Black Clip 0 and White Clip 0.04 (the default
+ *    post-process settings). It is the ACES reference rendering's glow and red modifier and its 0.96 desaturation, then a
  *    parametric toe-straight-shoulder curve on log10 of each AP1 channel, solved so that 0.18 comes out at 0.18, then a
  *    0.93 desaturation;
  * 6. back to the working space, clamped at zero, and clipped at 1 as the sRGB target clips it.
@@ -80,7 +80,7 @@ fn ue_film_hue(rgb: vec3<f32>) -> f32 {
     return clamp(hue, 0.0, 360.0);
 }
 
-// FilmToneMap: AP1 in, AP1 out
+// Filmic curve: AP1 in, AP1 out
 fn ue_film_tone_map(color_ap1: vec3<f32>) -> vec3<f32> {
     var aces = UE_AP1_TO_AP0 * color_ap1;
 

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

@@ -63,7 +63,7 @@ the diffuse as well: under a uniform sky a white dielectric returned 1.01 – 1.
 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
+light (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).

package/src/shade/renderer/shader/chunk/math/chunk_f16_round_stochastic.d.ts

@@ -13,8 +13,7 @@
  * it stops short of `x` by up to a ULP/α: half of that rounded to nearest, a whole one rounded toward zero, and
  * one-sided. WGSL leaves rounding an f32 to a half to the implementation. An RTX 4090 and an RDNA2 iGPU were
  * measured to round toward zero on every path: `pack2x16float`, `textureStore` and a render target's write. The
- * result here is a half already, which any store keeps exactly. UE 5.4's TSR stores its history through
- * `QuantizeForFloatRenderTarget` for the same reason.
+ * result here is a half already, which any store keeps exactly.
  *
  * Within the half's finite range: past 65504 the half above is not finite.
  *

package/src/shade/renderer/shader/chunk/math/chunk_f16_round_stochastic.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"chunk_f16_round_stochastic.d.ts","sourceRoot":"","sources":["../../../../../../../src/shade/renderer/shader/chunk/math/chunk_f16_round_stochastic.js"],"names":[],"mappings":"AAEA;;;;;;;;;;;;;;;;;;;;;GAqBG;AACH,yCAFU,SAAS,CAoBhB;0BA1CuB,6BAA6B"}
+{"version":3,"file":"chunk_f16_round_stochastic.d.ts","sourceRoot":"","sources":["../../../../../../../src/shade/renderer/shader/chunk/math/chunk_f16_round_stochastic.js"],"names":[],"mappings":"AAEA;;;;;;;;;;;;;;;;;;;;GAoBG;AACH,yCAFU,SAAS,CAoBhB;0BAzCuB,6BAA6B"}

package/src/shade/renderer/shader/chunk/math/chunk_f16_round_stochastic.js

@@ -15,8 +15,7 @@ import { CodeChunk } from "../../compiler/CodeChunk.js";
  * it stops short of `x` by up to a ULP/α: half of that rounded to nearest, a whole one rounded toward zero, and
  * one-sided. WGSL leaves rounding an f32 to a half to the implementation. An RTX 4090 and an RDNA2 iGPU were
  * measured to round toward zero on every path: `pack2x16float`, `textureStore` and a render target's write. The
- * result here is a half already, which any store keeps exactly. UE 5.4's TSR stores its history through
- * `QuantizeForFloatRenderTarget` for the same reason.
+ * result here is a half already, which any store keeps exactly.
  *
  * Within the half's finite range: past 65504 the half above is not finite.
  *

package/src/shade/renderer/shader/chunk/noise/chunk_stbn_sample_vec2.d.ts

@@ -1,5 +1,18 @@
 /**
- * Sampling "Spatio-Temoral Blue Noise" texture (see STBN paper by NVIDIA)
+ * Two numbers in (0, 1) from the spatio-temporal blue noise texture (NVIDIA, "Spatiotemporal Blue Noise Masks",
+ * EGSR 2022), tiled 128 × 128 over the first two axes and 64 slices over the third.
+ *
+ * ```wgsl
+ * fn stbn_sample_vec2(index: vec3<u32>) -> vec2<f32>
+ * ```
+ *
+ * The generator quantises a value x in [0, 1) as `byte = floor(x · 256)` (NVIDIA-RTX/STBN,
+ * BlueNoiseTexturesND.cpp and RGBAExporters.cpp), so byte k stands for x in [k/256, (k+1)/256). A `unorm` texture
+ * hands it over as k/255, the inverse of a `round(x · 255)` encoding, which puts two of the 256 values on 0 and 1
+ * exactly. The value is read as its bin's centre, (k + ½)/256, the mean of x over the bin: the 256 values sit
+ * evenly inside (0, 1), symmetric about ½, and a draw that needs u in [0, 1) never meets either end (at u = 0 a
+ * weighted draw takes the last item of any weight, however small; at u = 1 none).
+ *
  * @type {CodeChunk}
  */
 export const chunk_stbn_sample_vec2: CodeChunk;

package/src/shade/renderer/shader/chunk/noise/chunk_stbn_sample_vec2.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"chunk_stbn_sample_vec2.d.ts","sourceRoot":"","sources":["../../../../../../../src/shade/renderer/shader/chunk/noise/chunk_stbn_sample_vec2.js"],"names":[],"mappings":"AAGA;;;GAGG;AACH,qCAFU,SAAS,CAYlB;0BAjByB,6BAA6B"}
+{"version":3,"file":"chunk_stbn_sample_vec2.d.ts","sourceRoot":"","sources":["../../../../../../../src/shade/renderer/shader/chunk/noise/chunk_stbn_sample_vec2.js"],"names":[],"mappings":"AAGA;;;;;;;;;;;;;;;;GAgBG;AACH,qCAFU,SAAS,CAYlB;0BA9ByB,6BAA6B"}

package/src/shade/renderer/shader/chunk/noise/chunk_stbn_sample_vec2.js

@@ -2,19 +2,32 @@ import { CodeChunk } from "../../compiler/CodeChunk.js";
 import { STBN_VEC2_RESOURCE } from "../../../STATIC_GRAPHICS_ENGINE_ASSET_RESOURCES.js";
 
 /**
- * Sampling "Spatio-Temoral Blue Noise" texture (see STBN paper by NVIDIA)
+ * Two numbers in (0, 1) from the spatio-temporal blue noise texture (NVIDIA, "Spatiotemporal Blue Noise Masks",
+ * EGSR 2022), tiled 128 × 128 over the first two axes and 64 slices over the third.
+ *
+ * ```wgsl
+ * fn stbn_sample_vec2(index: vec3<u32>) -> vec2<f32>
+ * ```
+ *
+ * The generator quantises a value x in [0, 1) as `byte = floor(x · 256)` (NVIDIA-RTX/STBN,
+ * BlueNoiseTexturesND.cpp and RGBAExporters.cpp), so byte k stands for x in [k/256, (k+1)/256). A `unorm` texture
+ * hands it over as k/255, the inverse of a `round(x · 255)` encoding, which puts two of the 256 values on 0 and 1
+ * exactly. The value is read as its bin's centre, (k + ½)/256, the mean of x over the bin: the 256 values sit
+ * evenly inside (0, 1), symmetric about ½, and a draw that needs u in [0, 1) never meets either end (at u = 0 a
+ * weighted draw takes the last item of any weight, however small; at u = 1 none).
+ *
  * @type {CodeChunk}
  */
 export const chunk_stbn_sample_vec2 = CodeChunk.from(
     //language=WGSL
     `
-fn stbn_sample_vec2(index: vec3<u32> ) -> vec2<f32>{
+fn stbn_sample_vec2(index: vec3<u32>) -> vec2<f32> {
+    let noise_coord = index % vec3(128, 128, 64);
 
-    let noise_coord = index % vec3(128,128,64);
-    
-    return textureLoad(tSTBN_vec2, noise_coord, 0).rg;
+    // k/255 to (k + 1/2)/256
+    return fma(textureLoad(tSTBN_vec2, noise_coord, 0).rg, vec2(255.0 / 256.0), vec2(0.5 / 256.0));
 }
     `
 )
 
-chunk_stbn_sample_vec2.requireResource(STBN_VEC2_RESOURCE);
+chunk_stbn_sample_vec2.requireResource(STBN_VEC2_RESOURCE);

package/src/shade/renderer/shader/chunk/noise/chunk_stbn_sample_vec3.d.ts

@@ -1,5 +1,14 @@
 /**
- * Sampling "Spatio-Temoral Blue Noise" texture (see STBN paper by NVIDIA)
+ * Three numbers in (0, 1) from the spatio-temporal blue noise texture (NVIDIA, "Spatiotemporal Blue Noise Masks",
+ * EGSR 2022), tiled 128 × 128 over the first two axes and 64 slices over the third.
+ *
+ * ```wgsl
+ * fn stbn_sample_vec3(index: vec3<u32>) -> vec3<f32>
+ * ```
+ *
+ * Each byte is read as the centre of the bin the generator quantised it from, (k + ½)/256, rather than the
+ * `unorm` k/255; see {@link chunk_stbn_sample_vec2}.
+ *
  * @type {CodeChunk}
  */
 export const chunk_stbn_sample_vec3: CodeChunk;

package/src/shade/renderer/shader/chunk/noise/chunk_stbn_sample_vec3.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"chunk_stbn_sample_vec3.d.ts","sourceRoot":"","sources":["../../../../../../../src/shade/renderer/shader/chunk/noise/chunk_stbn_sample_vec3.js"],"names":[],"mappings":"AAGA;;;GAGG;AACH,qCAFU,SAAS,CAYlB;0BAjByB,6BAA6B"}
+{"version":3,"file":"chunk_stbn_sample_vec3.d.ts","sourceRoot":"","sources":["../../../../../../../src/shade/renderer/shader/chunk/noise/chunk_stbn_sample_vec3.js"],"names":[],"mappings":"AAGA;;;;;;;;;;;;GAYG;AACH,qCAFU,SAAS,CAYlB;0BA1ByB,6BAA6B"}

package/src/shade/renderer/shader/chunk/noise/chunk_stbn_sample_vec3.js

@@ -2,20 +2,28 @@ import { CodeChunk } from "../../compiler/CodeChunk.js";
 import { STBN_VEC3_RESOURCE } from "../../../STATIC_GRAPHICS_ENGINE_ASSET_RESOURCES.js";
 
 /**
- * Sampling "Spatio-Temoral Blue Noise" texture (see STBN paper by NVIDIA)
+ * Three numbers in (0, 1) from the spatio-temporal blue noise texture (NVIDIA, "Spatiotemporal Blue Noise Masks",
+ * EGSR 2022), tiled 128 × 128 over the first two axes and 64 slices over the third.
+ *
+ * ```wgsl
+ * fn stbn_sample_vec3(index: vec3<u32>) -> vec3<f32>
+ * ```
+ *
+ * Each byte is read as the centre of the bin the generator quantised it from, (k + ½)/256, rather than the
+ * `unorm` k/255; see {@link chunk_stbn_sample_vec2}.
+ *
  * @type {CodeChunk}
  */
 export const chunk_stbn_sample_vec3 = CodeChunk.from(
     //language=WGSL
     `
-fn stbn_sample_vec3(index: vec3<u32> ) -> vec3<f32>{
+fn stbn_sample_vec3(index: vec3<u32>) -> vec3<f32> {
+    let noise_coord = index % vec3(128, 128, 64);
 
-    let noise_coord = index % vec3(128,128,64);
-    
-    return textureLoad(tSTBN_vec3, noise_coord, 0).rgb;
+    // k/255 to (k + 1/2)/256
+    return fma(textureLoad(tSTBN_vec3, noise_coord, 0).rgb, vec3(255.0 / 256.0), vec3(0.5 / 256.0));
 }
     `
 )
 
 chunk_stbn_sample_vec3.requireResource(STBN_VEC3_RESOURCE);
-

package/src/shade/renderer/shader/chunk/random/murmur/chunk_murmur3_vec3u.d.ts

@@ -1,5 +1,5 @@
 /**
- * Reference https://github.com/markjarzynski/HashFunctionsForGPURendering_Unreal/blob/master/Shaders/Random.ush
+ * MurmurHash3 3D integer hash (Jarzynski & Olano 2020, "Hash Functions for GPU Rendering", JCGT).
  * @type {CodeChunk}
  */
 export const chunk_murmur3_vec3u: CodeChunk;

package/src/shade/renderer/shader/chunk/random/murmur/chunk_murmur3_vec3u.js

@@ -3,7 +3,7 @@ import { chunk_u32_rotate_left } from "../chunk_u32_rotate_left.js";
 import { chunk_murmur3_fmix } from "./chunk_murmur3_fmix.js";
 
 /**
- * Reference https://github.com/markjarzynski/HashFunctionsForGPURendering_Unreal/blob/master/Shaders/Random.ush
+ * MurmurHash3 3D integer hash (Jarzynski & Olano 2020, "Hash Functions for GPU Rendering", JCGT).
  * @type {CodeChunk}
  */
 export const chunk_murmur3_vec3u = CodeChunk.from(

package/src/shade/renderer/shader/compiler/SHADER_SWITCH_PROPOSAL_2026_10_16.md

@@ -135,29 +135,24 @@ Neither replaces the other.
 
 ## 3. What other engines do
 
-Read from source or primary docs. Unreal was read in the installed UE 5.4 tree. The rest comes from the research brief
+Read from primary docs and references. The rest comes from the research brief
 `shader-switch-prior-art.md` in the side-notes folder of this session group, which has the URLs and identifiers; its
 Bevy and gpuweb claims were re-checked against the pages.
 
-**Unreal: permutation domains.** `RenderCore/Public/ShaderPermutation.h`. A dimension is a C++ type made by
-`SHADER_PERMUTATION_BOOL` / `_INT` / `_RANGE_INT` / `_SPARSE_INT` / `_ENUM_CLASS`, each carrying a `DefineName`.
-`TShaderPermutationDomain<…>` is their product, and its permutation id is mixed-radix over the dimensions
-(`ToDimensionValueId`). A shader class lists its dimensions. `FDeferredLightPS` (`Renderer/Private/LightRendering.cpp:816`)
-has 14 of them, including `FVirtualShadowMapMask`.
+**Unreal: permutation domains.** A dimension is a C++ type (bool, int, range, sparse int, or enum), each carrying a preprocessor define name. Their product is a permutation domain whose permutation id is mixed-radix over the dimensions. A shader class lists its dimensions (for example, the deferred light pixel shader has 14 of them, including the virtual shadow map mask).
 
-- `ShouldCompilePermutation` culls combinations: a directional light × the VSM mask is never compiled.
-- `RemapPermutation` folds combinations together: visualize-culling forces the others off.
-- `ModifyCompilationEnvironment` adds the VSM defines only when that dimension is on.
-- The draw site sets every dimension by hand (`LightRendering.cpp:2804-2833`), then asks the shader map for
+- Unused combinations are culled before compilation (e.g., a directional light × the VSM mask is never compiled).
+- Redundant combinations are remapped together (e.g., visualize-culling forces the others off).
+- Conditional defines (such as VSM defines) are added to the compilation environment only when that dimension is on.
+- The draw site sets every dimension by hand, then asks the shader map for
   `(shader type, permutation id)`. **The owner knows every dimension.** Nothing derives the domain: the shader class lists it
   and the draw site sets it.
 - Dimensions select `#if` blocks. Dependencies are `#include`s, which can sit inside an `#if`, but nothing declares
   what each value pulls in.
 
 **Unreal: vertex factories and materials.** These are the other half of Unreal's answer, and they are an *interface
-slot*. `FVertexFactoryType::ModifyCompilationEnvironment` maps the virtual include path
-`/Engine/Generated/VertexFactory.ush` to `#include "<this factory's file>"` (`RenderCore/Public/VertexFactory.h:418-420`).
-`/Engine/Generated/Material.ush` is mapped to the generated material code (`Engine/Private/Materials/MaterialShared.cpp:3357`).
+slot*. The vertex factory compilation environment maps a virtual include path to the concrete implementation's source file.
+
 Every shader that includes the path gets the implementation the compile supplies, and nothing in between is twinned.
 The shader map is keyed by material × vertex factory × shader type × permutation.
 
@@ -587,7 +582,7 @@ Risks:
 | piece | reuses / generalises |
 |---|---|
 | specialization | `CodeChunk`'s own graph and private fields, with the same identity-based dedup the linker relies on. No second linker; `compile()` is untouched. |
-| values | engine enums as they are (`ShadeIndirectLightingMode` unchanged), or a bool. The shape of Unreal's `SHADER_PERMUTATION_ENUM_CLASS`/`_BOOL`, and like its `SPARSE_INT` an enum need not be contiguous. |
+| values | engine enums as they are (`ShadeIndirectLightingMode` unchanged), or a bool. Like Unreal's enum/bool/sparse-int permutation dimensions, an enum need not be contiguous. |
 | variant objects | `ShaderDescriptor`, `ImageShader`, `ComputeShader` and `TemplatePassDescriptor` themselves. A variant is one of them, so draw, dispatch, validation and the profiler need nothing new. |
 | GPU pipeline cache | `RenderPipelineManager` / `ComputePipelineManager` unchanged. Text equality separates and shares variants. |
 | preparation | `PipelineEnquiry` and `prepare()` at start-up, offering the selected variants. A flip uses `obtain` as anything made on first use does. |

package/src/shade/renderer/shadow/contact/FINDINGS.md

@@ -60,20 +60,20 @@ summed over the ten scenes, with less false shadow on fine detail, at 3.4× its
 
 ## 1. The failure modes, and why they happen
 
-From the primary sources. Paths under `UE_5.4/Engine/` are Epic's installed source; Bend is
+From the primary sources. Bend is
 `bend_sss_gpu.h` / `bend_sss_cpu.h` (Sony, Apache 2.0) and the SIGGRAPH 2023 talk's slide text.
 
 | # | Failure mode | Cause | What shipping code does about it |
 |---|---|---|---|
-| 1 | **Heightfield thickness**: thin casters smear, thick ones leak | The depth buffer holds each caster's front and nothing behind it, so every method assumes a slab thickness | Bend: 0.5% of the sample's depth to the far plane (here: in front of the ray by up to 1% of its view depth). UE desktop: ≈ L/2, set by ray length and 8 steps (`ScreenSpaceShadowRayCast.ush:26-32`, `DeferredLightingCommon.ush:63-64`). Filament ≈ 7.5 cm, three.js 1 cm, Bevy 10 cm, all world space. Nobody reconstructs back faces |
+| 1 | **Heightfield thickness**: thin casters smear, thick ones leak | The depth buffer holds each caster's front and nothing behind it, so every method assumes a slab thickness | Bend: 0.5% of the sample's depth to the far plane (here: in front of the ray by up to 1% of its view depth). UE desktop: ≈ L/2, set by ray length and 8 steps. Filament ≈ 7.5 cm, three.js 1 cm, Bevy 10 cm, all world space. Nobody reconstructs back faces |
 | 2 | **Self-shadowing** where the sun or the view grazes a surface, and on normal-mapped surfaces | A ray leaving a surface at a grazing angle runs along it, so the surface's own neighbouring depths sit just in front of it; depth is quantised per pixel; the shading normal and the depth disagree | Bend: an edge-aware bilinear read across the ray's minor axis, pushing the casting depth back by the step across the pixel; a start bias "suppressed legitimate detail" (talk). UE: skip samples bit-equal to the start depth. Bevy: an open draft (#25355) bends the ray toward the normal. Normal maps are invisible to all of them; Days Gone wrote a ±8 cm material displacement into depth to get that detail |
 | 3 | **View dependence** | Only casters that are on screen and in front cast; the reach is counted in pixels (Bend, Godot, UE screen mode) or the screen reach shrinks with distance (world-space methods) | Bend: "they cannot replace shadow maps, only complement them" (talk). Nothing fixes it |
 | 4 | **Noise and TAA instability** | Jittered starts and few steps (UE 8 steps + IGN over 8 frames, Bevy, three.js, Filament) need TAA to converge; the jittered depth buffer changes what is in it | Bend is deterministic: 4 interleaved min-reductions averaged, 4 hard near samples, an 8-sample fade. Every other source leans on the scene's TAA |
 | 5 | **Disocclusion trails** | Temporal accumulation of a term that changes with the view | No source keeps contact-shadow history; trails are whatever TAA does |
 | 6 | **Screen edges** | Off-screen casters are not in the depth buffer | Bend reads off-screen as the far plane (clamp-to-border); UE treats an off-screen hit as a miss; Filament fades by the ray's end. A fade only hides the pop |
-| 7 | **Scale with distance** | A pixel reach means a world reach growing with depth; a world reach shrinks below a pixel | Bend 60 px fixed; UE screen mode L ∝ depth (`DeferredLightingCommon.ush:162-168`); world-space methods vanish far away |
-| 8 | **Alpha-tested foliage** | Cut-outs alias per texel, cards are millimetres thick, two-sided leaves are their own receivers | Bend's `IgnoreEdgePixels` "can also thin out otherwise valid shadows, especially on foliage edges". UE attenuates subsurface/foliage receivers by 1 − exp(−density·distance) (`DeferredLightingCommon.ush:197-211`) |
-| 9 | **Double darkening** against the shadow map | Multiplying two partial visibilities (a PCF penumbra and a partial contact) is darker than either | UE desktop multiplies (`DeferredLightingCommon.ush:213-216`); UE mobile and Godot take the min; Filament and Bevy multiply but skip pixels the map already shadows fully |
+| 7 | **Scale with distance** | A pixel reach means a world reach growing with depth; a world reach shrinks below a pixel | Bend 60 px fixed; UE screen mode L ∝ depth; world-space methods vanish far away |
+| 8 | **Alpha-tested foliage** | Cut-outs alias per texel, cards are millimetres thick, two-sided leaves are their own receivers | Bend's `IgnoreEdgePixels` "can also thin out otherwise valid shadows, especially on foliage edges". UE attenuates subsurface/foliage receivers by 1 − exp(−density·distance) |
+| 9 | **Double darkening** against the shadow map | Multiplying two partial visibilities (a PCF penumbra and a partial contact) is darker than either | UE desktop multiplies; UE mobile and Godot take the min; Filament and Bevy multiply but skip pixels the map already shadows fully |
 | 10 | **The light's point on screen** | Rays converge on it, so near it every ray is a few pixels long; Bend widens its window there | Bend: `min(sample_distance + direction, 1/thickness)` in the window scale |
 
 ## 2. Measured

package/src/shade/renderer/shadow/vsm/DEFAULT_VSM_MAX_DYNAMIC_LOD_BIAS.d.ts

@@ -1,7 +1,6 @@
 /**
- * Default ceiling on the dynamic LOD bias a virtual shadow map may add under pool pressure (matches
- * UE 5.4+'s `MaxResolutionLodBias = 2.0`, up to a 4× linear / 16× area reduction). Setting `0`
- * disables dynamic resolution throttling.
+ * Default ceiling on the dynamic LOD bias a virtual shadow map may add under pool pressure (up to a
+ * 4× linear / 16× area reduction). Setting `0` disables dynamic resolution throttling.
  *
  * @type {number}
  */

package/src/shade/renderer/shadow/vsm/DEFAULT_VSM_MAX_DYNAMIC_LOD_BIAS.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"DEFAULT_VSM_MAX_DYNAMIC_LOD_BIAS.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/shadow/vsm/DEFAULT_VSM_MAX_DYNAMIC_LOD_BIAS.js"],"names":[],"mappings":"AAAA;;;;;;GAMG;AACH,+CAFU,MAAM,CAEkC"}
+{"version":3,"file":"DEFAULT_VSM_MAX_DYNAMIC_LOD_BIAS.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/shadow/vsm/DEFAULT_VSM_MAX_DYNAMIC_LOD_BIAS.js"],"names":[],"mappings":"AAAA;;;;;GAKG;AACH,+CAFU,MAAM,CAEkC"}

package/src/shade/renderer/shadow/vsm/DEFAULT_VSM_MAX_DYNAMIC_LOD_BIAS.js

@@ -1,8 +1,7 @@
-/**
- * Default ceiling on the dynamic LOD bias a virtual shadow map may add under pool pressure (matches
- * UE 5.4+'s `MaxResolutionLodBias = 2.0`, up to a 4× linear / 16× area reduction). Setting `0`
- * disables dynamic resolution throttling.
- *
- * @type {number}
- */
-export const DEFAULT_VSM_MAX_DYNAMIC_LOD_BIAS = 2;
+/**
+ * Default ceiling on the dynamic LOD bias a virtual shadow map may add under pool pressure (up to a
+ * 4× linear / 16× area reduction). Setting `0` disables dynamic resolution throttling.
+ *
+ * @type {number}
+ */
+export const DEFAULT_VSM_MAX_DYNAMIC_LOD_BIAS = 2;

package/src/shade/renderer/shadow/vsm/DEFAULT_VSM_MAX_LOAD_FACTOR.d.ts

@@ -1,7 +1,7 @@
 /**
  * Default high-watermark pool demand ratio `(wants + requests_dropped) / slots.capacity` above
  * which a virtual shadow map steps its dynamic LOD bias up to coarsen requested pages and prevent
- * hard page-pool overflow (matches UE 5.4+'s `MaxPagePoolLoadFactor = 0.85`).
+ * hard page-pool overflow.
  *
  * Paired with {@link DEFAULT_VSM_LOW_LOAD_FACTOR} to form a hysteresis deadband so demand hovering
  * near capacity does not oscillate between adjacent clipmap levels. Setting `0` disables dynamic