@woosh/meep-engine 3.60.3 → 3.60.5

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/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/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/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/shadow/map/GPUSceneShadowmapContext.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"GPUSceneShadowmapContext.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/shadow/map/GPUSceneShadowmapContext.js"],"names":[],"mappings":"AA0JA;;GAEG;AACH;IA8aI;;;;;;;;OAQG;IACH,sBAPW,eAAe,aACf,eAAe,SAGf,kBAAkB,EAiE5B;IApfD,2BAAwG;IAExG;;;OAGG;IACH,SAFU,iBAAiB,CAEnB;IAQR;;;;;;;;OAQG;IACH,qBAFU,WAAW,CAED;IAsCpB;;;;;;;;OAQG;IACH,SAFU,OAAO,CAEF;IAEf;;;;;;;;;;OAUG;IACH,+BAFU,OAAO,CAEqB;IAEtC;;;;;;OAMG;IACH,yBAFU,OAAO,CAEe;IAehC;;;;;OAKG;IACH,mCAIC;IAjBD;;OAEG;IACH,kCAEC;IAcD;;;;;OAKG;IACH,kBAFU,MAAM,CAEK;IAiBrB;;;;OAIG;IACH,uCAMC;IAlBD;;OAEG;IACH,sCAEC;IA6BD;;;;OAIG;IACH,uCAMC;IAlBD;;OAEG;IACH,sCAEC;IA6BD;;;;OAIG;IACH,4CAKC;IAjBD;;OAEG;IACH,2CAEC;IA2BD;;;;;OAKG;IACH,wCAKC;IAlBD;;OAEG;IACH,uCAEC;IA4BD;;;;;;;;OAQG;IACH,6BAIC;IApBD;;OAEG;IACH,4BAEC;IA0CD;;;;OAIG;IACH,6BAIC;IAhBD;;OAEG;IACH,4BAEC;IA2FD;;OAEG;IACH,iCAEC;IAED;;;;;;OAMG;IACH,oCAEC;IAED;;;;;OAKG;IACH,oCAEC;IAoGD;;;;;OAKG;IACH,4BAMC;IA2MD;;;;;;;;;;;;OAYG;IACH;QAN+B,KAAK,EAAzB,UAAU;QACqD,IAAI,EAAnE,OAAO,8BAA8B,EAAE,cAAc;QACrC,KAAK,EAArB,MAAM;QACU,MAAM,EAAtB,MAAM;aA+BhB;IA0LD;;;;OAIG;IACH,eAHW,KAAK,GACH,SAAS,GAAC,SAAS,CAI/B;IAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OA4CG;IACH,6BAPW,MAAM,SAEN,eAAe,eACf,MAAM,mBACN,UAAU,MAAM,CAAC,QA0G3B;IA2GD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OA+BG;IACH,kBAFW,sBAAsB,QA0FhC;IAwbD;;;;;;;;;;;;;;;;;;;;OAoBG;IACH,kBALa,OAAO,CAsTnB;IAED;;;;;;;;;;OAUG;IACH,iBALW,MAAM,SACN,MAAM,GACJ,KAAK,CAejB;IA2DD,gBAiBC;;CACJ;qCAruEY,OAAO,2CAA2C,EAAE,sBAAsB;8BAC1E,OAAO,0BAA0B,EAAE,eAAe;qBAClD,OAAO,wBAAwB,EAAE,MAAM;iCACvC,OAAO,mCAAmC,EAAE,kBAAkB;oBAC9D,OAAO,4BAA4B,EAAE,KAAK;8BAC1C,OAAO,gCAAgC,EAAE,eAAe;wBACxD,OAAO,gBAAgB,EAAE,SAAS;8BAClC,OAAO,oDAAoD,EAAE,eAAe;oCAhFrD,+DAA+D;kCAkBjE,oCAAoC;4BAG1C,2BAA2B;2BApB5B,8DAA8D;kBAFvE,wCAAwC"}
+{"version":3,"file":"GPUSceneShadowmapContext.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/shadow/map/GPUSceneShadowmapContext.js"],"names":[],"mappings":"AA+JA;;GAEG;AACH;IA8aI;;;;;;;;OAQG;IACH,sBAPW,eAAe,aACf,eAAe,SAGf,kBAAkB,EAiE5B;IApfD,2BAAwG;IAExG;;;OAGG;IACH,SAFU,iBAAiB,CAEnB;IAQR;;;;;;;;OAQG;IACH,qBAFU,WAAW,CAED;IAsCpB;;;;;;;;OAQG;IACH,SAFU,OAAO,CAEF;IAEf;;;;;;;;;;OAUG;IACH,+BAFU,OAAO,CAEqB;IAEtC;;;;;;OAMG;IACH,yBAFU,OAAO,CAEe;IAehC;;;;;OAKG;IACH,mCAIC;IAjBD;;OAEG;IACH,kCAEC;IAcD;;;;;OAKG;IACH,kBAFU,MAAM,CAEK;IAiBrB;;;;OAIG;IACH,uCAMC;IAlBD;;OAEG;IACH,sCAEC;IA6BD;;;;OAIG;IACH,uCAMC;IAlBD;;OAEG;IACH,sCAEC;IA6BD;;;;OAIG;IACH,4CAKC;IAjBD;;OAEG;IACH,2CAEC;IA2BD;;;;;OAKG;IACH,wCAKC;IAlBD;;OAEG;IACH,uCAEC;IA4BD;;;;;;;;OAQG;IACH,6BAIC;IApBD;;OAEG;IACH,4BAEC;IA0CD;;;;OAIG;IACH,6BAIC;IAhBD;;OAEG;IACH,4BAEC;IA2FD;;OAEG;IACH,iCAEC;IAED;;;;;;OAMG;IACH,oCAEC;IAED;;;;;OAKG;IACH,oCAEC;IAoGD;;;;;OAKG;IACH,4BAMC;IA2MD;;;;;;;;;;;;OAYG;IACH;QAN+B,KAAK,EAAzB,UAAU;QACqD,IAAI,EAAnE,OAAO,8BAA8B,EAAE,cAAc;QACrC,KAAK,EAArB,MAAM;QACU,MAAM,EAAtB,MAAM;aA+BhB;IA0LD;;;;OAIG;IACH,eAHW,KAAK,GACH,SAAS,GAAC,SAAS,CAI/B;IAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OA4CG;IACH,6BAPW,MAAM,SAEN,eAAe,eACf,MAAM,mBACN,UAAU,MAAM,CAAC,QA0G3B;IA2GD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OA+BG;IACH,kBAFW,sBAAsB,QA0FhC;IAwbD;;;;;;;;;;;;;;;;;;;;OAoBG;IACH,kBALa,OAAO,CAsTnB;IAED;;;;;;;;;;OAUG;IACH,iBALW,MAAM,SACN,MAAM,GACJ,KAAK,CAejB;IA2DD,gBAiBC;;CACJ;qCA1uEY,OAAO,2CAA2C,EAAE,sBAAsB;8BAC1E,OAAO,0BAA0B,EAAE,eAAe;qBAClD,OAAO,wBAAwB,EAAE,MAAM;iCACvC,OAAO,mCAAmC,EAAE,kBAAkB;oBAC9D,OAAO,4BAA4B,EAAE,KAAK;8BAC1C,OAAO,gCAAgC,EAAE,eAAe;wBACxD,OAAO,gBAAgB,EAAE,SAAS;8BAClC,OAAO,oDAAoD,EAAE,eAAe;oCAhFrD,+DAA+D;kCAkBjE,oCAAoC;4BAG1C,2BAA2B;2BApB5B,8DAA8D;kBAFvE,wCAAwC"}

package/src/shade/renderer/shadow/map/GPUSceneShadowmapContext.js

@@ -95,11 +95,16 @@ const DEFAULT_SHADOWMAP_ATLAS_RESOLUTION = 4096;
 /**
  * Resolution by cascade.
  * If the number of cascades is greater than the array length, the last resolution is used.
+ *
+ * 1536 is chosen for the cascade's HZB: half of it, 768 = 3·2⁸, is a mip 0 the HZB takes as it is, with
+ * no padding, so mip 0 halves the cascade exactly (a 2x2 footprint) and the rest of the pyramid is two
+ * 4-mip SPD passes and one single-mip pass. 1740 and 1440 padded mip 0 to 880 and 736, a 3x3 footprint
+ * and five single-mip passes each. Three cascades at 1536² hold about the texels 1740² + 2·1440² did.
+ *
  * @type {number[]}
  */
 const DEFAULT_SHADOWMAP_DIRECTIONAL_RESOLUTION = [
-    1740, // first cascade
-    1440,
+    1536,
 ];
 
 /**

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

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

@@ -1,12 +1,12 @@
-/**
- * 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`).
- *
- * 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
- * resolution throttling.
- *
- * @type {number}
- */
-export const DEFAULT_VSM_MAX_LOAD_FACTOR = 0.85;
+/**
+ * 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.
+ *
+ * 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
+ * resolution throttling.
+ *
+ * @type {number}
+ */
+export const DEFAULT_VSM_MAX_LOAD_FACTOR = 0.85;

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

@@ -146,7 +146,7 @@ export class VSMPageManager {
     set max_load_factor(v: number);
     /**
      * High-watermark pool demand ratio `(wants + requests_dropped) / slots.capacity` above which
-     * {@link dynamic_lod_bias} steps up to coarsen requested pages (UE 5.4+ `MaxPagePoolLoadFactor`).
+     * {@link dynamic_lod_bias} steps up to coarsen requested pages.
      * `0` disables dynamic resolution throttling.
      * @returns {number}
      */
@@ -166,7 +166,7 @@ export class VSMPageManager {
      */
     set max_lod_bias(v: number);
     /**
-     * Ceiling on {@link dynamic_lod_bias} (UE 5.4+ `MaxResolutionLodBias`). `0` disables dynamic
+     * Ceiling on {@link dynamic_lod_bias}. `0` disables dynamic
      * resolution throttling.
      * @returns {number}
      */

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

@@ -1 +1 @@
-{"version":3,"file":"VSMPageManager.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/shadow/vsm/VSMPageManager.js"],"names":[],"mappings":"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"}
+{"version":3,"file":"VSMPageManager.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/shadow/vsm/VSMPageManager.js"],"names":[],"mappings":"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"}

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

@@ -327,8 +327,7 @@ export class VSMPageManager {
     #levels_dirty = false;
 
     /**
-     * Dynamic resolution throttling (UE 5.4+ `MaxPagePoolLoadFactor` / `MaxResolutionLodBias` with
-     * hysteresis deadband and readback-latency gating).
+     * Dynamic resolution throttling (with hysteresis deadband and readback-latency gating).
      */
     #max_load_factor = DEFAULT_VSM_MAX_LOAD_FACTOR;
     #low_load_factor = DEFAULT_VSM_LOW_LOAD_FACTOR;
@@ -486,7 +485,7 @@ export class VSMPageManager {
 
     /**
      * High-watermark pool demand ratio `(wants + requests_dropped) / slots.capacity` above which
-     * {@link dynamic_lod_bias} steps up to coarsen requested pages (UE 5.4+ `MaxPagePoolLoadFactor`).
+     * {@link dynamic_lod_bias} steps up to coarsen requested pages.
      * `0` disables dynamic resolution throttling.
      * @returns {number}
      */
@@ -530,7 +529,7 @@ export class VSMPageManager {
     }
 
     /**
-     * Ceiling on {@link dynamic_lod_bias} (UE 5.4+ `MaxResolutionLodBias`). `0` disables dynamic
+     * Ceiling on {@link dynamic_lod_bias}. `0` disables dynamic
      * resolution throttling.
      * @returns {number}
      */

package/src/shade/renderer/water/GPUWaterRenderer.d.ts

@@ -17,12 +17,6 @@ export class GPUWaterRenderer {
         inscatter_segments: number;
         tessellation_pixels: number;
     };
-    /**
-     * The frame's water bodies table, recorded by whoever owns the surfaces at the head of the frame;
-     * each drawable surface carries its row as `body_index`.
-     * @type {import("./medium/GPUWaterBodies.js").GPUWaterBodies|null}
-     */
-    bodies: import("./medium/GPUWaterBodies.js").GPUWaterBodies | null;
     /**
      * What the lattice's per-frame lists may hold (WATER_SURFACE_DISTANCE_LOD_PROPOSAL_2026_10_06.md §4.3). Grown from
      * each view's totals, read back a frame or two later; a frame over a budget drops its tail until then.

package/src/shade/renderer/water/GPUWaterRenderer.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"GPUWaterRenderer.d.ts","sourceRoot":"","sources":["../../../../../src/shade/renderer/water/GPUWaterRenderer.js"],"names":[],"mappings":"AAoBA,sFAAsF;AACtF;IACI,WAAa;IACb,mBAAe;IACf,yBAAqB;IACrB,aAAS;IACT,WAAa;IACb;;;;;;;;;;;MAE6B;IAC7B;;;;OAIG;IACH,QAFU,OAAO,4BAA4B,EAAE,cAAc,GAAC,IAAI,CAEpD;IAmBd;;;OAGG;IACH;;;;;MAA8F;IAC9F;;;OAGG;IACH,wBAAyD;IAMzD,oCAIC;IAED,8FAA8F;IAC9F,qCAgBC;IAED,gBASC;IAuDD;;;;;;;;;;;;;;;;;MAuIC;IAQD;;;;;YAMC;IAED;;;;;;;;;;MAOC;IAED;;;;;;;;;;;;;;MAwBC;IAED,gGAAgG;IAChG,mEAYC;;CA2BJ;gCA3X+B,uCAAuC"}
+{"version":3,"file":"GPUWaterRenderer.d.ts","sourceRoot":"","sources":["../../../../../src/shade/renderer/water/GPUWaterRenderer.js"],"names":[],"mappings":"AAqBA,sFAAsF;AACtF;IACI,WAAa;IACb,mBAAe;IACf,yBAAqB;IACrB,aAAS;IACT,WAAa;IACb;;;;;;;;;;;MAE6B;IAmB7B;;;OAGG;IACH;;;;;MAA8F;IAC9F;;;OAGG;IACH,wBAAyD;IAMzD,oCAIC;IAED,8FAA8F;IAC9F,qCAgBC;IAED,gBASC;IAuDD;;;;;;;;;;;;;;;;;MAyIC;IAQD;;;;;YAMC;IAED;;;;;;;;;;MAOC;IAED;;;;;;;;;;;;;;MAwBC;IAED,gGAAgG;IAChG,mEAYC;;CAyBJ;gCAtX+B,uCAAuC"}