@woosh/meep-engine 3.60.3 → 3.60.4

package/src/shade/renderer/atmosphere/shader_multiscatter_lut.js

@@ -1,164 +1,164 @@
-import { WebGPUExtensionType } from "../../descriptor/WebGPUExtensionType.js";
-import { ATMOSPHERE_HEIGHT_DECLARATION } from "../shader/chunk/atmosphere/ATMOSPHERE_HEIGHT_DECLARATION.js";
-import { chunk_safe_acos } from "../shader/chunk/math/chunk_safe_acos.js";
-import { CodeChunk } from "../shader/compiler/CodeChunk.js";
-import { ComputeShader } from "../shader/ComputeShader.js";
-import { ShaderResourceSetDescriptor } from "../shader/resource/ShaderResourceSetDescriptor.js";
-import { chunk_get_multiscatter_values } from "./chunk_get_multiscatter_values.js";
-import { chunk_multiscatter_sample_direction } from "./chunk_multiscatter_sample_direction.js";
-import { chunk_sky_lut_texel_to_unit } from "./chunk_sky_lut_texel_to_unit.js";
-import {
-    MULTISCATTER_LUT_DIRECTION_COUNT,
-    MULTISCATTER_LUT_MAX_SUBGROUP_PARTIALS
-} from "./MULTISCATTER_LUT_CONFIG.js";
-import { SAMPLER_SKY_LUT } from "./SAMPLER_SKY_LUT.js";
-
-const resources = new ShaderResourceSetDescriptor();
-resources.createGroup()
-    // "float" rather than the default "unfilterable-float": rgba16float is filterable in
-    // core WebGPU, so the LUT goes through the texture unit instead of a 4-tap manual
-    // bilinear.
-    .addTexture("tSkyLutTransmittance", "float")
-    .addSampler("sSkyLut", "filtering", SAMPLER_SKY_LUT)
-    .addStorageTexture("tSkyLutMultiscatterOut", "rgba16float")
-;
-
-
-/**
- * the multiple-scattering LUT. Each pixel coordinate corresponds to a height and sun zenith angle, and
- * the value is the multiple scattering approximation (Psi_ms from the paper, Eq. 10).
- *
- * One workgroup per LUT texel, one thread per direction, mirroring Hillaire's
- * `[numthreads(1,1,64)]` `NewMultiScattCS`. The 64 directions used to be a serial loop
- * inside a fragment shader, which left the whole pass with 32*32 = 1024 threads of
- * parallelism -- a few dozen waves, one per scheduler at best, with nothing to hide the
- * latency of the transmittance fetches. Per-thread it is now a single direction's 20-step
- * march.
- *
- * The per-direction results are summed with `subgroupAdd` and then across subgroups through
- * workgroup memory; Hillaire uses a six-step groupshared log-reduction, which the subgroup
- * op collapses into one instruction plus a handful of partials.
- *
- * @see "A Scalable and Production Ready Sky and Atmosphere Rendering Technique", Hillaire (2020)
- * @see https://www.shadertoy.com/view/slSXRW
- * @type {CodeChunk}
- */
-const body = CodeChunk.from(
-    //language=WGSL
-    `
-const MULTISCATTER_DIRECTION_COUNT = ${MULTISCATTER_LUT_DIRECTION_COUNT}u;
-const MULTISCATTER_MAX_SUBGROUP_PARTIALS = ${MULTISCATTER_LUT_MAX_SUBGROUP_PARTIALS}u;
-
-var<workgroup> wg_partial_count: atomic<u32>;
-var<workgroup> wg_lum: array<vec3<f32>, MULTISCATTER_MAX_SUBGROUP_PARTIALS>;
-var<workgroup> wg_fms: array<vec3<f32>, MULTISCATTER_MAX_SUBGROUP_PARTIALS>;
-
-@compute @workgroup_size(${MULTISCATTER_LUT_DIRECTION_COUNT}, 1, 1)
-fn main(
-    @builtin(workgroup_id) workgroup_id: vec3<u32>,
-    @builtin(local_invocation_index) thread_index: u32,
-) {
-
-    if (thread_index == 0u) {
-        atomicStore(&wg_partial_count, 0u);
-    }
-
-    // Every thread is here together anyway, so the counter's initialisation costs nothing
-    // beyond the barrier itself. WGSL does not promise workgroup variables start zeroed.
-    workgroupBarrier();
-
-    // one workgroup per texel; the dispatch is sized from the texture, so this is in range
-    let texel = workgroup_id.xy;
-
-    let lut_size = vec2<f32>(textureDimensions(tSkyLutMultiscatterOut));
-
-    // The point of each range this texel stands for: texel 0 carries the bottom and the last
-    // texel the top, which is what lets a lookup at either end read a value computed there
-    // rather than one from half a texel inside. sky_lut_uv is the other half of this.
-    let unit = sky_lut_texel_to_unit(vec2<f32>(texel), lut_size);
-
-    let sunCosTheta = 2.0*unit.x - 1.0;
-    let sunTheta = safe_acos(sunCosTheta);
-
-    let height = ATMOSPHERE_HEIGHT*unit.y;
-
-    let pos = vec3(0.0, height, 0.0);
-    let sunDir = normalize(vec3(0.0, sunCosTheta, -sin(sunTheta)));
-
-    // pos on the +y axis and sunDir with a zero x component are exactly the preconditions
-    // multiscatter_sample_direction's half-azimuth sample set needs
-    let rayDir = multiscatter_sample_direction(thread_index);
-
-    var lum:vec3<f32>;
-    var f_ms:vec3<f32>;
-
-    get_multiscatter_values(pos, sunDir, rayDir, &lum, &f_ms);
-
-    // Uniform control flow up to here, so every one of the workgroup's threads is an active
-    // lane and the subgroup sum covers all of them.
-    let lum_subgroup = subgroupAdd(lum);
-    let fms_subgroup = subgroupAdd(f_ms);
-
-    // subgroupElect picks exactly one active invocation per subgroup, and the slot it claims
-    // is whichever the counter hands out. Deriving the slot from local_invocation_index /
-    // subgroup_size instead would assume invocations are packed into subgroups in contiguous
-    // index order, which WGSL leaves unspecified: a mapping that is not contiguous blocks
-    // would collide two subgroups onto one slot and silently drop a partial sum. Which slot
-    // a subgroup lands in does not matter, only that it gets its own.
-    //
-    // Every lane holds the same subgroup sum, so letting them all store it would be a data
-    // race on one address even though the values agree.
-    if (subgroupElect()) {
-        let slot = atomicAdd(&wg_partial_count, 1u);
-
-        wg_lum[slot] = lum_subgroup;
-        wg_fms[slot] = fms_subgroup;
-    }
-
-    workgroupBarrier();
-
-    if (thread_index != 0u) {
-        return;
-    }
-
-    // WGSL pins the subgroup size to a power of two in [4, 128], so the workgroup cannot hold
-    // more subgroups than the partials array has room for. The clamp keeps a driver that
-    // broke that promise reading initialised slots rather than garbage.
-    let partial_count = min(atomicLoad(&wg_partial_count), MULTISCATTER_MAX_SUBGROUP_PARTIALS);
-
-    var lum_total = vec3(0.0);
-    var fms_total = vec3(0.0);
-
-    for (var i = 0u; i < partial_count; i++) {
-        lum_total += wg_lum[i];
-        fms_total += wg_fms[i];
-    }
-
-    // The directions carry equal solid angle, so the mean over them is the spherical average
-    // the paper's uniform phase reduces to.
-    let inv_samples = 1.0 / f32(MULTISCATTER_DIRECTION_COUNT);
-
-    lum_total *= inv_samples;
-    fms_total *= inv_samples;
-
-    // Equation 10 from the paper.
-    let psi = lum_total / (1.0 - fms_total);
-
-    textureStore(tSkyLutMultiscatterOut, texel, vec4(psi, 1.0));
-}
-    `, [
-        chunk_safe_acos,
-        ATMOSPHERE_HEIGHT_DECLARATION,
-        chunk_multiscatter_sample_direction,
-        chunk_sky_lut_texel_to_unit,
-        chunk_get_multiscatter_values,
-    ]
-);
-
-body.addExtension(WebGPUExtensionType.Subgroups);
-
-export const shader_multiscatter_lut = ComputeShader.from({
-    label: "Sky / multi-scatter LUT",
-    body,
-    resources,
-});
+import { WebGPUExtensionType } from "../../descriptor/WebGPUExtensionType.js";
+import { ATMOSPHERE_HEIGHT_DECLARATION } from "../shader/chunk/atmosphere/ATMOSPHERE_HEIGHT_DECLARATION.js";
+import { chunk_safe_acos } from "../shader/chunk/math/chunk_safe_acos.js";
+import { CodeChunk } from "../shader/compiler/CodeChunk.js";
+import { ComputeShader } from "../shader/ComputeShader.js";
+import { ShaderResourceSetDescriptor } from "../shader/resource/ShaderResourceSetDescriptor.js";
+import { chunk_get_multiscatter_values } from "./chunk_get_multiscatter_values.js";
+import { chunk_multiscatter_sample_direction } from "./chunk_multiscatter_sample_direction.js";
+import { chunk_sky_lut_texel_to_unit } from "./chunk_sky_lut_texel_to_unit.js";
+import {
+    MULTISCATTER_LUT_DIRECTION_COUNT,
+    MULTISCATTER_LUT_MAX_SUBGROUP_PARTIALS
+} from "./MULTISCATTER_LUT_CONFIG.js";
+import { SAMPLER_SKY_LUT } from "./SAMPLER_SKY_LUT.js";
+
+const resources = new ShaderResourceSetDescriptor();
+resources.createGroup()
+    // "float" rather than the default "unfilterable-float": rgba16float is filterable in
+    // core WebGPU, so the LUT goes through the texture unit instead of a 4-tap manual
+    // bilinear.
+    .addTexture("tSkyLutTransmittance", "float")
+    .addSampler("sSkyLut", "filtering", SAMPLER_SKY_LUT)
+    .addStorageTexture("tSkyLutMultiscatterOut", "rgba16float")
+;
+
+
+/**
+ * the multiple-scattering LUT. Each pixel coordinate corresponds to a height and sun zenith angle, and
+ * the value is the multiple scattering approximation (Psi_ms from the paper, Eq. 10).
+ *
+ * One workgroup per LUT texel, one thread per direction (64 threads per workgroup).
+ * The 64 directions used to be a serial loop
+ * inside a fragment shader, which left the whole pass with 32*32 = 1024 threads of
+ * parallelism -- a few dozen waves, one per scheduler at best, with nothing to hide the
+ * latency of the transmittance fetches. Per-thread it is now a single direction's 20-step
+ * march.
+ *
+ * The per-direction results are summed with `subgroupAdd` and then across subgroups through
+ * workgroup memory, collapsing a six-step groupshared log-reduction into one subgroup
+ * instruction plus a handful of partials.
+ *
+ * @see "A Scalable and Production Ready Sky and Atmosphere Rendering Technique", Hillaire (2020)
+ * @see https://www.shadertoy.com/view/slSXRW
+ * @type {CodeChunk}
+ */
+const body = CodeChunk.from(
+    //language=WGSL
+    `
+const MULTISCATTER_DIRECTION_COUNT = ${MULTISCATTER_LUT_DIRECTION_COUNT}u;
+const MULTISCATTER_MAX_SUBGROUP_PARTIALS = ${MULTISCATTER_LUT_MAX_SUBGROUP_PARTIALS}u;
+
+var<workgroup> wg_partial_count: atomic<u32>;
+var<workgroup> wg_lum: array<vec3<f32>, MULTISCATTER_MAX_SUBGROUP_PARTIALS>;
+var<workgroup> wg_fms: array<vec3<f32>, MULTISCATTER_MAX_SUBGROUP_PARTIALS>;
+
+@compute @workgroup_size(${MULTISCATTER_LUT_DIRECTION_COUNT}, 1, 1)
+fn main(
+    @builtin(workgroup_id) workgroup_id: vec3<u32>,
+    @builtin(local_invocation_index) thread_index: u32,
+) {
+
+    if (thread_index == 0u) {
+        atomicStore(&wg_partial_count, 0u);
+    }
+
+    // Every thread is here together anyway, so the counter's initialisation costs nothing
+    // beyond the barrier itself. WGSL does not promise workgroup variables start zeroed.
+    workgroupBarrier();
+
+    // one workgroup per texel; the dispatch is sized from the texture, so this is in range
+    let texel = workgroup_id.xy;
+
+    let lut_size = vec2<f32>(textureDimensions(tSkyLutMultiscatterOut));
+
+    // The point of each range this texel stands for: texel 0 carries the bottom and the last
+    // texel the top, which is what lets a lookup at either end read a value computed there
+    // rather than one from half a texel inside. sky_lut_uv is the other half of this.
+    let unit = sky_lut_texel_to_unit(vec2<f32>(texel), lut_size);
+
+    let sunCosTheta = 2.0*unit.x - 1.0;
+    let sunTheta = safe_acos(sunCosTheta);
+
+    let height = ATMOSPHERE_HEIGHT*unit.y;
+
+    let pos = vec3(0.0, height, 0.0);
+    let sunDir = normalize(vec3(0.0, sunCosTheta, -sin(sunTheta)));
+
+    // pos on the +y axis and sunDir with a zero x component are exactly the preconditions
+    // multiscatter_sample_direction's half-azimuth sample set needs
+    let rayDir = multiscatter_sample_direction(thread_index);
+
+    var lum:vec3<f32>;
+    var f_ms:vec3<f32>;
+
+    get_multiscatter_values(pos, sunDir, rayDir, &lum, &f_ms);
+
+    // Uniform control flow up to here, so every one of the workgroup's threads is an active
+    // lane and the subgroup sum covers all of them.
+    let lum_subgroup = subgroupAdd(lum);
+    let fms_subgroup = subgroupAdd(f_ms);
+
+    // subgroupElect picks exactly one active invocation per subgroup, and the slot it claims
+    // is whichever the counter hands out. Deriving the slot from local_invocation_index /
+    // subgroup_size instead would assume invocations are packed into subgroups in contiguous
+    // index order, which WGSL leaves unspecified: a mapping that is not contiguous blocks
+    // would collide two subgroups onto one slot and silently drop a partial sum. Which slot
+    // a subgroup lands in does not matter, only that it gets its own.
+    //
+    // Every lane holds the same subgroup sum, so letting them all store it would be a data
+    // race on one address even though the values agree.
+    if (subgroupElect()) {
+        let slot = atomicAdd(&wg_partial_count, 1u);
+
+        wg_lum[slot] = lum_subgroup;
+        wg_fms[slot] = fms_subgroup;
+    }
+
+    workgroupBarrier();
+
+    if (thread_index != 0u) {
+        return;
+    }
+
+    // WGSL pins the subgroup size to a power of two in [4, 128], so the workgroup cannot hold
+    // more subgroups than the partials array has room for. The clamp keeps a driver that
+    // broke that promise reading initialised slots rather than garbage.
+    let partial_count = min(atomicLoad(&wg_partial_count), MULTISCATTER_MAX_SUBGROUP_PARTIALS);
+
+    var lum_total = vec3(0.0);
+    var fms_total = vec3(0.0);
+
+    for (var i = 0u; i < partial_count; i++) {
+        lum_total += wg_lum[i];
+        fms_total += wg_fms[i];
+    }
+
+    // The directions carry equal solid angle, so the mean over them is the spherical average
+    // the paper's uniform phase reduces to.
+    let inv_samples = 1.0 / f32(MULTISCATTER_DIRECTION_COUNT);
+
+    lum_total *= inv_samples;
+    fms_total *= inv_samples;
+
+    // Equation 10 from the paper.
+    let psi = lum_total / (1.0 - fms_total);
+
+    textureStore(tSkyLutMultiscatterOut, texel, vec4(psi, 1.0));
+}
+    `, [
+        chunk_safe_acos,
+        ATMOSPHERE_HEIGHT_DECLARATION,
+        chunk_multiscatter_sample_direction,
+        chunk_sky_lut_texel_to_unit,
+        chunk_get_multiscatter_values,
+    ]
+);
+
+body.addExtension(WebGPUExtensionType.Subgroups);
+
+export const shader_multiscatter_lut = ComputeShader.from({
+    label: "Sky / multi-scatter LUT",
+    body,
+    resources,
+});

package/src/shade/renderer/atmosphere/shader_sky_irradiance_lut.js

@@ -116,7 +116,7 @@ fn raymarch_scattering(
         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 = local_density.x * C_RAYLEIGH;
         

package/src/shade/renderer/geometry/sdf/GPUGeometrySDFManager.d.ts

@@ -17,8 +17,8 @@ export const MESH_SDF_BAKE_BUDGET_MAX: number;
  * {@link alias} points a skinned clone's id at its source's cache, which readers follow.
  *
  * **Side.** A holder says whether it draws both sides of the geometry. A field is baked two-sided
- * while any of its holders does: its vote then counts no back face, so nothing is inside it (UE 5.4's
- * rule, which takes the side from the material). A field whose holders' side has changed since its
+ * while any of its holders does: its vote then counts no back face, so nothing is inside it.
+ * A field whose holders' side has changed since its
  * bake is baked again at the next bake, so holds moved within a frame bake nothing; a field no one
  * holds keeps the side it has.
  *

package/src/shade/renderer/geometry/sdf/GPUGeometrySDFManager.js

@@ -207,8 +207,8 @@ function grow_typed(array, length) {
  * {@link alias} points a skinned clone's id at its source's cache, which readers follow.
  *
  * **Side.** A holder says whether it draws both sides of the geometry. A field is baked two-sided
- * while any of its holders does: its vote then counts no back face, so nothing is inside it (UE 5.4's
- * rule, which takes the side from the material). A field whose holders' side has changed since its
+ * while any of its holders does: its vote then counts no back face, so nothing is inside it.
+ * A field whose holders' side has changed since its
  * bake is baked again at the next bake, so holds moved within a frame bake nothing; a field no one
  * holds keeps the side it has.
  *

package/src/shade/renderer/geometry/sdf/cards/mesh_cards_raster_pass_descriptor.js

@@ -216,8 +216,8 @@ const vertex_code = ShaderDescriptor.from({
 
 /*
  The template is handed what the G-buffer pass hands it, in the geometry's local space, the card
- being there: real derivatives, as this is a raster with neighbours of its own triangle, unbiased, as
- UE's card capture leaves its material mip bias at 0. Both functions run first, in uniform control
+ being there: real derivatives, as this is a raster with neighbours of its own triangle, unbiased (mip
+ bias at 0). Both functions run first, in uniform control
  flow, so a template may sample with implicit derivatives.
 
  Coverage is drawn as the trace draws it, a texel's surface opaque with probability its opacity, from

package/src/shade/renderer/geometry/sdf/cards/shader_mesh_cards_histogram.d.ts

@@ -7,7 +7,7 @@ export const MESH_CARDS_HISTOGRAM_SETTINGS: WebGPUStruct;
  * six directions, over a resident geometry's level-0 occupancy — a brick is occupied when its entry
  * holds a slot. Walking its column along the direction, a thread finds every run start: an occupied
  * brick at layer z whose predecessor is empty or outside the grid. A run start's m is the layer after
- * the previous run's end, or 0 for the first: UE's MinRayZ. The thread counts each run start into
+ * the previous run's end, or 0 for the first. The thread counts each run start into
  * its direction's histogram by (m, z), which the layout's scratch holds cleared.
  *
  * @type {ComputeShader}

package/src/shade/renderer/geometry/sdf/cards/shader_mesh_cards_histogram.js

@@ -31,7 +31,7 @@ resources.createGroup()
  * six directions, over a resident geometry's level-0 occupancy — a brick is occupied when its entry
  * holds a slot. Walking its column along the direction, a thread finds every run start: an occupied
  * brick at layer z whose predecessor is empty or outside the grid. A run start's m is the layer after
- * the previous run's end, or 0 for the first: UE's MinRayZ. The thread counts each run start into
+ * the previous run's end, or 0 for the first. The thread counts each run start into
  * its direction's histogram by (m, z), which the layout's scratch holds cleared.
  *
  * @type {ComputeShader}

package/src/shade/renderer/geometry/sdf/chunk_blas_query_band_sdf.d.ts

@@ -10,8 +10,7 @@ export const BLAS_BAND_VOTE_STRATA: number;
  */
 export const BLAS_BAND_VOTE_RAYS: number;
 /**
- * A geometry's signed distance within a band, signed by UE 5.4's vote (`MeshDistanceFieldUtilities.cpp`,
- * `FMeshDistanceFieldAsyncTask::DoWork`):
+ * A geometry's signed distance within a band, signed by a hemisphere ray vote:
  *
  * - The nearest point within the band, through the BLAS. With none, the point is a band away, outside,
  *   and casts no ray.
@@ -20,9 +19,9 @@ export const BLAS_BAND_VOTE_RAYS: number;
  *   than a quarter of them meet a back face.
  * - A two-sided geometry has no back face: it is outside throughout, and casts no ray either.
  *
- * The directions are UE's, made as its stream runs, ray after ray: `FRandomStream(0)` drives two
- * `GenerateStratifiedUniformHemisphereSamples(49)` on Shirley and Chiu's concentric map, and the second
- * hemisphere's Z is negated. UE's Z is our Y.
+ * The directions are made as the LCG stream runs, ray after ray: a seed of 0 drives two
+ * 49-sample stratified uniform hemisphere sets on Shirley and Chiu's concentric map, and the second
+ * hemisphere's pole is negated (+Y and -Y hemispheres).
  *
  * ```wgsl
  * fn blas_query_band_sdf(point: vec3<f32>, geometry_index: u32, band: f32, two_sided: bool, contact, stack, stack_top: u32) -> f32

package/src/shade/renderer/geometry/sdf/chunk_blas_query_band_sdf.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"chunk_blas_query_band_sdf.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/geometry/sdf/chunk_blas_query_band_sdf.js"],"names":[],"mappings":"AAgBA;;;;GAIG;AACH,oCAFU,MAAM,CAEuB;AAEvC;;;GAGG;AACH,kCAFU,MAAM,CAEqE;AAErF;;;;;;;;;;;;;;;;;;;;GAoBG;AACH,wCAFU,SAAS,CAgHjB;0BAlJwB,oCAAoC"}
+{"version":3,"file":"chunk_blas_query_band_sdf.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/geometry/sdf/chunk_blas_query_band_sdf.js"],"names":[],"mappings":"AAgBA;;;;GAIG;AACH,oCAFU,MAAM,CAEuB;AAEvC;;;GAGG;AACH,kCAFU,MAAM,CAEqE;AAErF;;;;;;;;;;;;;;;;;;;GAmBG;AACH,wCAFU,SAAS,CAgHjB;0BAjJwB,oCAAoC"}

package/src/shade/renderer/geometry/sdf/chunk_blas_query_band_sdf.js

@@ -28,8 +28,7 @@ export const BLAS_BAND_VOTE_STRATA = 7;
 export const BLAS_BAND_VOTE_RAYS = 2 * BLAS_BAND_VOTE_STRATA * BLAS_BAND_VOTE_STRATA;
 
 /**
- * A geometry's signed distance within a band, signed by UE 5.4's vote (`MeshDistanceFieldUtilities.cpp`,
- * `FMeshDistanceFieldAsyncTask::DoWork`):
+ * A geometry's signed distance within a band, signed by a hemisphere ray vote:
  *
  * - The nearest point within the band, through the BLAS. With none, the point is a band away, outside,
  *   and casts no ray.
@@ -38,9 +37,9 @@ export const BLAS_BAND_VOTE_RAYS = 2 * BLAS_BAND_VOTE_STRATA * BLAS_BAND_VOTE_ST
  *   than a quarter of them meet a back face.
  * - A two-sided geometry has no back face: it is outside throughout, and casts no ray either.
  *
- * The directions are UE's, made as its stream runs, ray after ray: `FRandomStream(0)` drives two
- * `GenerateStratifiedUniformHemisphereSamples(49)` on Shirley and Chiu's concentric map, and the second
- * hemisphere's Z is negated. UE's Z is our Y.
+ * The directions are made as the LCG stream runs, ray after ray: a seed of 0 drives two
+ * 49-sample stratified uniform hemisphere sets on Shirley and Chiu's concentric map, and the second
+ * hemisphere's pole is negated (+Y and -Y hemispheres).
  *
  * ```wgsl
  * fn blas_query_band_sdf(point: vec3<f32>, geometry_index: u32, band: f32, two_sided: bool, contact, stack, stack_top: u32) -> f32
@@ -55,7 +54,7 @@ const BLAS_BAND_VOTE_STRATA = ${BLAS_BAND_VOTE_STRATA}u;
 const BLAS_BAND_VOTE_HEMISPHERE = ${BLAS_BAND_VOTE_STRATA * BLAS_BAND_VOTE_STRATA}u;
 const BLAS_BAND_VOTE_RAYS = ${BLAS_BAND_VOTE_RAYS}u;
 
-/** FRandomStream::GetFraction: the stream's next fraction in [0, 1) */
+/** Next LCG fraction in [0, 1) */
 fn blas_band_vote_fraction(seed: ptr<function, u32>) -> f32 {
     *seed = *seed * 196314165u + 907633515u;
 
@@ -145,7 +144,7 @@ fn blas_query_band_sdf(
         }
     }
 
-    // UE's Hit > 0 && HitBack > 0.25 · samples, of which the first follows from the second
+    // Inside when hits > 0 and back-face hits > 0.25 · samples (the first follows from the second)
     return select(distance, -distance, 4u * back > BLAS_BAND_VOTE_RAYS);
 }
 `, [

package/src/shade/renderer/geometry/virtual/ATTRIBUTE_PLAN_2026_09_18.md

@@ -128,7 +128,7 @@ The pin was then added on top to protect cut seams. The pin is *correct* and mus
 Generalized quadrics — Garland & Heckbert 1998 (*Simplifying Surfaces with Color and Texture using
 Quadric Error Metrics*) for the naive `(3+m)`-dimensional lift, **Hoppe 1999** (*New Quadric Metric
 for Simplifying Meshes with Appearance Attributes*) for the form worth implementing. Unreal's Nanite
-uses the latter (`MeshSimplify.h` / `Quadric.h`: attribute-carrying quadrics, per-attribute weights,
+uses the latter (attribute-carrying quadrics, per-attribute weights,
 and a separate edge quadric for boundary and seam penalties); `meshoptimizer`'s
 `meshopt_simplifyWithAttributes` is a far more readable second reference for the same maths and for
 weight calibration.

package/src/shade/renderer/geometry/virtual/VIRTUAL_GEOMETRY_PLAN.md

@@ -179,10 +179,8 @@ band (`vgeo_assemble_pages`). A page is therefore spatially local, and a boundin
 one means something. Pack pages arbitrarily and every page bound covers the model.
 
 **Nanite does exactly this combination**, which settles the compatibility question outright.
-Cluster data lives in a paged, streamed virtual byte buffer
-(`Nanite.StreamingManager.ClusterPageData`) with the BVH in
-`Nanite.StreamingManager.Hierarchy`; nodes form a BVH within a mesh connecting clusters
-across detail levels; `PersistentNodeAndClusterCull` in `NaniteHierarchyTraversal.ush` walks
+Cluster data lives in a paged, streamed virtual byte buffer with a separate hierarchy;
+nodes form a BVH within a mesh connecting clusters across detail levels; a persistent traversal kernel walks
 it on the GPU from an MPMC queue, where only nodes generate new work and clusters are only
 consumed. And when a child's memory is not present, **processing stops at the parent and a
 request is made for the child** — a lower-detail LOD is what you see until it arrives. That

package/src/shade/renderer/geometry/virtual/WEDGE_PLAN_2026_09_18.md

@@ -207,7 +207,7 @@ With wedges, the same, once per wedge — plus the one new decision:
 > wedge count does.
 
 Attribute equality, within a tolerance. Two wedges that describe the same appearance are one wedge;
-two that do not stay two. This is Nanite's rule (`MeshSimplifier` matches corners by attribute
+two that do not stay two. This is Nanite's rule (matching corners by attribute
 equality on a collapse) and it has the properties that matter:
 
 - On a smooth mesh every wedge at a vertex is equal to every other, so there is exactly one, and the

package/src/shade/renderer/geometry/virtual/runtime/SHADOW_PLAN_2026_09_28.md

@@ -185,8 +185,7 @@ Revision 2 made τ an absolute per-view value. That splits the one quality lever
 slider sets `runtime.tau`, and an absolute shadow τ of 2 becomes *finer* than the main view the moment
 the slider goes to 4 — and the reference it cited is relative. So a view carries **`tau_scale`**,
 default 1, and cuts at `runtime.tau × tau_scale`. Whoever owns a view may set it; nothing in the runtime
-knows what kind of view it is. Unreal's `r.Shadow.NaniteLODBias` (default 1, scale 2^−bias) is the
-data point for shadow views; S4 measures before anything but 1 is set.
+knows what kind of view it is. S4 measures before anything but 1 is set.
 
 **Shadow views default to 2** *(after S4)*: the shadow context sets it on every view it owns
 (`SHADOWMAP_VGEO_TAU_SCALE`), and the runtime still knows nothing of what kind of view it cuts for.
@@ -235,8 +234,7 @@ re-selects it. Its first draw is forced at creation, when little but the roots i
 redraws it touches nothing, so the LRU evicts exactly the pages only it needs. Left alone it would keep
 a root-level cut indefinitely. So a map whose own views' last reading was **clamped**, and under which
 pages have installed since, is re-selected like an invalid one. That keys on the map's own incomplete
-cut rather than on every LOD change, which is what keeps it clear of the invalidation storm Unreal's
-`r.Nanite.VSMInvalidateOnLODDelta` warns about.
+cut rather than on every LOD change, which keeps it clear of an invalidation storm when pages stream in.
 
 ### 2.6 Room for proxies — not built
 
@@ -511,16 +509,11 @@ in turn. That flickers 0.17% of the screen per frame in the authored view and 0.
 
 ## References
 
-Read 2026-09-28. Unreal's source is not public; its facts here come from Epic's documentation and
-from a UE 5.4.4 console-variable reference that reproduces source locations.
+Read 2026-09-28.
 
 - Epic, *Virtual Shadow Maps in Unreal Engine* — per-view Nanite rendering, one pass per light
   class, 17 directional clipmap levels, page caching and invalidation.
   https://dev.epicgames.com/documentation/en-us/unreal-engine/virtual-shadow-maps-in-unreal-engine
-- `r.Shadow.NaniteLODBias`, default 1, scale 2^−bias (ShadowSceneRenderer.cpp:50, :103 in 5.4.4).
-  https://indxzero.github.io/ue544cvarwiki/articles/r.shadow.nanitelodbias/
-- `r.Nanite.VSMInvalidateOnLODDelta`, default 0, experimental (NaniteCullRaster.cpp:117).
-  https://indxzero.github.io/ue544cvarwiki/articles/r.nanite.vsminvalidateonloddelta/
 - Epic, *Hardware Ray Tracing* — ray-traced shadows trace the Nanite fallback mesh.
   https://dev.epicgames.com/documentation/en-us/unreal-engine/hardware-ray-tracing-in-unreal-engine
 - Bevy, `crates/bevy_pbr/src/meshlet/cull_shared.wesl` (`lod_error_is_imperceptible`) and

package/src/shade/renderer/global_illumination/probe_clipmap/GPUProbeClipmapGI.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"GPUProbeClipmapGI.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/global_illumination/probe_clipmap/GPUProbeClipmapGI.js"],"names":[],"mappings":"AAeA;;;;;;GAMG;AAEH;;;;;;;;;;;;;;;;;;;GAmBG;AACH;IA0DI;;OAEG;IACH,sBAFW,eAAe,EAMzB;IAED;;OAEG;IACH,qCAEC;IAED;;OAEG;IACH,qCAEC;IAED;;OAEG;IACH,oCAEC;IAED;;;;;;;;;;;;;;OAcG;IACH;QAT+B,KAAK,EAAzB,UAAU;QACc,IAAI,EAA5B,cAAc;QACgB,QAAQ,EAAtC,oBAAoB;QACJ,KAAK,EAArB,MAAM;QACU,MAAM,EAAtB,MAAM;QACK,IAAI;QACE,MAAM,GAAvB,MAAM;aAiGhB;IAED;;;OAGG;IACH,0BAEC;IAED;;;;;;;;;OASG;IACH,4CAUC;IAwDD;;;;;;;;;;OAUG;IACH;QAN+B,KAAK,EAAzB,UAAU;QACc,IAAI,EAA5B,cAAc;QACgB,QAAQ,EAAtC,oBAAoB;QACF,UAAU,EAA5B,MAAM,EAAE;QACN,MAAM,CAmBlB;IAED;;;;;OAKG;IACH,uBAFW,aAAa,QASvB;IAED;;;OAGG;IACH,0BAHW,aAAa,GACX,OAAO,CAanB;IAyCD;;;OAGG;IACH,gBAoBC;IAED,gBAcC;;CACJ;yBApcY,OAAO,8DAA8D,EAAE,UAAU;8BACjF,OAAO,0BAA0B,EAAE,eAAe;6BAClD,OAAO,8BAA8B,EAAE,cAAc;mCACrD,OAAO,2BAA2B,EAAE,oBAAoB;4BACxD,OAAO,4BAA4B,EAAE,aAAa;gCAjB/B,4BAA4B;gCAQ5B,4BAA4B;uCAErB,6BAA6B"}
+{"version":3,"file":"GPUProbeClipmapGI.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/global_illumination/probe_clipmap/GPUProbeClipmapGI.js"],"names":[],"mappings":"AAeA;;;;;;GAMG;AAEH;;;;;;;;;;;;;;;;;;;GAmBG;AACH;IA0DI;;OAEG;IACH,sBAFW,eAAe,EAMzB;IAED;;OAEG;IACH,qCAEC;IAED;;OAEG;IACH,qCAEC;IAED;;OAEG;IACH,oCAEC;IAED;;;;;;;;;;;;;;OAcG;IACH;QAT+B,KAAK,EAAzB,UAAU;QACc,IAAI,EAA5B,cAAc;QACgB,QAAQ,EAAtC,oBAAoB;QACJ,KAAK,EAArB,MAAM;QACU,MAAM,EAAtB,MAAM;QACK,IAAI;QACE,MAAM,GAAvB,MAAM;aAkGhB;IAED;;;OAGG;IACH,0BAEC;IAED;;;;;;;;;OASG;IACH,4CAUC;IAwDD;;;;;;;;;;OAUG;IACH;QAN+B,KAAK,EAAzB,UAAU;QACc,IAAI,EAA5B,cAAc;QACgB,QAAQ,EAAtC,oBAAoB;QACF,UAAU,EAA5B,MAAM,EAAE;QACN,MAAM,CAmBlB;IAED;;;;;OAKG;IACH,uBAFW,aAAa,QASvB;IAED;;;OAGG;IACH,0BAHW,aAAa,GACX,OAAO,CAanB;IAyCD;;;OAGG;IACH,gBAoBC;IAED,gBAcC;;CACJ;yBArcY,OAAO,8DAA8D,EAAE,UAAU;8BACjF,OAAO,0BAA0B,EAAE,eAAe;6BAClD,OAAO,8BAA8B,EAAE,cAAc;mCACrD,OAAO,2BAA2B,EAAE,oBAAoB;4BACxD,OAAO,4BAA4B,EAAE,aAAa;gCAjB/B,4BAA4B;gCAQ5B,4BAA4B;uCAErB,6BAA6B"}

package/src/shade/renderer/global_illumination/probe_clipmap/GPUProbeClipmapGI.js

@@ -237,6 +237,7 @@ export class GPUProbeClipmapGI {
             scene,
             materials,
             card_rows: this.#holds.rows_buffer,
+            resampling: settings.resampling,
         });
     }