@woosh/meep-engine 3.60.5 → 3.60.7

package/src/shade/renderer/global_illumination/probe_clipmap/probe/shader_probe_clipmap_candidate.js

@@ -0,0 +1,166 @@
+import { chunk_folded_workgroup_index } from "../../../shader/chunk/grid/chunk_folded_workgroup_index.js";
+import { chunk_hash_to_float01 } from "../../../shader/chunk/random/chunk_hash_to_float01.js";
+import { chunk_pcg3d } from "../../../shader/chunk/random/pcg/chunk_pcg3d.js";
+import { CodeChunk } from "../../../shader/compiler/CodeChunk.js";
+import { ComputeShader } from "../../../shader/ComputeShader.js";
+import { ShaderResourceSetDescriptor } from "../../../shader/resource/ShaderResourceSetDescriptor.js";
+import { u32 } from "../../../shader/type/WEBGPU_WGSL_PRIMITIVE_TYPES.js";
+import { WebGPUStruct } from "../../../shader/type/WebGPUStruct.js";
+import {
+    chunk_probe_clipmap,
+    chunk_probe_clipmap_listed,
+    PROBE_CANDIDATES_WRITE_RESOURCE,
+    PROBE_DEPTH_HISTORY_RESOURCE,
+    PROBE_LEVELS_RESOURCE,
+    PROBE_LISTED_READ_RESOURCE,
+    PROBE_ORIGINS_READ_RESOURCE,
+    PROBE_RECORDS_READ_RESOURCE,
+    PROBE_STATES_READ_RESOURCE,
+    PROBE_TRACE_READ_RESOURCE
+} from "./chunk_probe_clipmap.js";
+import {
+    chunk_probe_clipmap_pick,
+    PROBE_DEPTH_SAMPLER_RESOURCE,
+    PROBE_INDIRECTION_READ_RESOURCE,
+    PROBE_SAMPLING_RESOURCE
+} from "./chunk_probe_clipmap_pick.js";
+import { chunk_probe_clipmap_resample } from "./chunk_probe_clipmap_resample.js";
+import { PROBE_DEPTH_LIMIT, PROBE_THREAD_WORKGROUP_SIZE } from "./PROBE_CLIPMAP.js";
+
+/**
+ * @type {WebGPUStruct}
+ */
+export const PROBE_CANDIDATE_SETTINGS = WebGPUStruct.from({
+    /** probes a frame updates at most: the trace list's bound */
+    trace_capacity: u32,
+}, "ProbeCandidateSettings");
+
+const resources = new ShaderResourceSetDescriptor();
+
+resources.setImmediate("settings", PROBE_CANDIDATE_SETTINGS);
+
+resources.createGroup()
+    .add(PROBE_TRACE_READ_RESOURCE)
+    .add(PROBE_ORIGINS_READ_RESOURCE)
+    .add(PROBE_LISTED_READ_RESOURCE)
+    .add(PROBE_CANDIDATES_WRITE_RESOURCE);
+
+resources.createGroup()
+    .add(PROBE_LEVELS_RESOURCE)
+    .add(PROBE_SAMPLING_RESOURCE)
+    .add(PROBE_INDIRECTION_READ_RESOURCE)
+    .add(PROBE_STATES_READ_RESOURCE)
+    .add(PROBE_RECORDS_READ_RESOURCE)
+    .add(PROBE_DEPTH_HISTORY_RESOURCE)
+    .add(PROBE_DEPTH_SAMPLER_RESOURCE);
+
+/**
+ * The candidate (Enshrouded's "pick neighbor candidates"): a thread a listed probe B, dispatched through
+ * `PROBE_DISPATCH_TRACED` after relocation, draws the one neighbour whose rays of this frame it re-samples
+ * (`shader_probe_clipmap_resample_rays`), and writes it to `probe_candidates`: its place in the list, or
+ * `PROBE_CLIPMAP_NONE`, and the weight its rays take.
+ *
+ * - **The neighbours**: the 26 around B's lattice point in its cascade. One is a candidate if it is ALIVE, its
+ *   record holds that point (the storage wraps), and it is listed this frame (`probe_clipmap_listed`), so that its
+ *   rays are in `probe_rays`. A NEW one is not. M counts them.
+ * - **The importance**: the neighbour's radiance, its irradiance's L0 luma, times B's visibility of it: Chebyshev
+ *   over B's depth moments toward it (`probe_visibility_chebyshev`), its distance in B's spacings held to the depth
+ *   limit, as the moments are. A dark neighbour, or one behind a wall, weighs about nothing.
+ * - **The draw**: one by its importance, a reservoir of one through the 26 with a hash of the slot, the update count
+ *   and the neighbour.
+ * - **The weight**: the draw's density divided out, `(1 / M) / p`, p the drawn one's importance over the sum: the
+ *   rays B takes are then, in expectation, every candidate's alike.
+ * - A probe whose first update this is, or a DEAD one, draws nothing: its depth is not yet its own, or it is
+ *   inside a solid.
+ *
+ * Reads the depth atlas as the last publish left it, and the frame's origins, records and states, which no pass
+ * after relocation writes before accumulate.
+ *
+ * @type {ComputeShader}
+ */
+export const shader_probe_clipmap_candidate = ComputeShader.from({
+    label: "Probe Clipmap Candidate",
+    resources,
+    body: CodeChunk.from(
+        //language=WGSL
+        `
+@compute @workgroup_size(${PROBE_THREAD_WORKGROUP_SIZE})
+fn main(
+    @builtin(workgroup_id) workgroup_id: vec3<u32>,
+    @builtin(local_invocation_index) lane: u32,
+) {
+    let k = folded_workgroup_index(workgroup_id) * PROBE_THREAD_WORKGROUP_SIZE + lane;
+
+    if (k >= min(probe_trace.count, settings.trace_capacity)) {
+        return;
+    }
+
+    let slot = probe_trace.elements[k];
+    let state = probe_states[slot];
+
+    var drawn = PROBE_CLIPMAP_NONE;
+    var drawn_importance = 0.0;
+    var total = 0.0;
+    var candidates = 0u;
+
+    if (probe_state_kind(state.x) == PROBE_STATE_ALIVE) {
+        let record = probe_records[slot];
+        let cascade = probe_record_cascade(record.flags);
+        let origin = probe_origins[k];
+        let spacing = origin.w;
+        let updates = probe_state_updates(state.x);
+
+        for (var j = 0u; j < 26u; j++) {
+            let lattice = record.cell + probe_resample_offset(j);
+            let neighbour = probe_clipmap_corner_slot(cascade, lattice);
+
+            if (neighbour == PROBE_CLIPMAP_NONE) {
+                continue;
+            }
+
+            // the storage wraps: the slot is this point's only if its record says so
+            if (probe_state_kind(probe_states[neighbour].x) != PROBE_STATE_ALIVE || any(probe_records[neighbour].cell != lattice)) {
+                continue;
+            }
+
+            let listed = probe_clipmap_listed(neighbour, settings.trace_capacity);
+
+            if (listed == PROBE_CLIPMAP_NONE) {
+                continue;
+            }
+
+            candidates++;
+
+            let to_neighbour = probe_origins[listed].xyz - origin.xyz;
+            let distance = length(to_neighbour);
+            let toward = to_neighbour / max(distance, 1e-6);
+            let visibility = probe_visibility_chebyshev(probe_clipmap_depth_moments(slot, toward), min(distance / spacing, ${PROBE_DEPTH_LIMIT}));
+            let radiance = max(probe_record_sh_decode(probe_records[neighbour].sh).Y.w, 0.0);
+            let importance = radiance * visibility;
+
+            if (importance <= 0.0) {
+                continue;
+            }
+
+            total += importance;
+
+            if (hash_to_float01(pcg3d(vec3<u32>(slot, updates, j)).x) * total < importance) {
+                drawn = listed;
+                drawn_importance = importance;
+            }
+        }
+    }
+
+    probe_candidates[k].listed = drawn;
+    probe_candidates[k].weight = select(0.0, total / (f32(candidates) * drawn_importance), drawn != PROBE_CLIPMAP_NONE);
+}
+`, [
+            chunk_probe_clipmap,
+            chunk_probe_clipmap_listed,
+            chunk_probe_clipmap_pick,
+            chunk_probe_clipmap_resample,
+            chunk_folded_workgroup_index,
+            chunk_hash_to_float01,
+            chunk_pcg3d,
+        ]),
+});

package/src/shade/renderer/global_illumination/probe_clipmap/probe/shader_probe_clipmap_due.d.ts

@@ -8,10 +8,9 @@ export const PROBE_DUE_SETTINGS: WebGPUStruct;
  * when a want waits on it:
  * - it is NEW, in the first pass, which lists them first: it has had no update;
  * - in the second pass, it is ALIVE or DEAD, a pixel or a hit wanted it since its last update, its
- *   wanted time past its traced time, and `(frame + h(slot)) mod T` is 0. A DEAD probe's update casts
- *   the fewest rays (`PROBE_RAYS_PER_TEXEL_MIN`), every period rather than every eighth at R, so that a
- *   probe inside a solid notices when the scene changes sooner, for fewer rays (Enshrouded's dead probes
- *   trace 16 a frame).
+ *   wanted time past its traced time, and `(frame + h(slot)) mod T` is 0. A DEAD probe is due every
+ *   period like an ALIVE one, its update casting `PROBE_DEAD_RAYS`, so that a probe inside a solid
+ *   notices when the scene changes (Enshrouded's dead probes trace 16 a frame).
  *
  * Wanted since its last update, not this frame: a hit wants a probe the frame after its own probe's
  * update, so a probe that only hits keep is wanted on few of its turns. Measured on Sponza with the

package/src/shade/renderer/global_illumination/probe_clipmap/probe/shader_probe_clipmap_due.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"shader_probe_clipmap_due.d.ts","sourceRoot":"","sources":["../../../../../../../src/shade/renderer/global_illumination/probe_clipmap/probe/shader_probe_clipmap_due.js"],"names":[],"mappings":"AAkBA;;GAEG;AACH,iCAFU,YAAY,CAWC;AAavB;;;;;;;;;;;;;;;;;;;;;;GAsBG;AACH,uCAFU,aAAa,CA4CpB;6BArG0B,sCAAsC;8BAHrC,kCAAkC"}
+{"version":3,"file":"shader_probe_clipmap_due.d.ts","sourceRoot":"","sources":["../../../../../../../src/shade/renderer/global_illumination/probe_clipmap/probe/shader_probe_clipmap_due.js"],"names":[],"mappings":"AAkBA;;GAEG;AACH,iCAFU,YAAY,CAWC;AAavB;;;;;;;;;;;;;;;;;;;;;GAqBG;AACH,uCAFU,aAAa,CA4CpB;6BApG0B,sCAAsC;8BAHrC,kCAAkC"}

package/src/shade/renderer/global_illumination/probe_clipmap/probe/shader_probe_clipmap_due.js

@@ -47,10 +47,9 @@ resources.createGroup()
  * when a want waits on it:
  * - it is NEW, in the first pass, which lists them first: it has had no update;
  * - in the second pass, it is ALIVE or DEAD, a pixel or a hit wanted it since its last update, its
- *   wanted time past its traced time, and `(frame + h(slot)) mod T` is 0. A DEAD probe's update casts
- *   the fewest rays (`PROBE_RAYS_PER_TEXEL_MIN`), every period rather than every eighth at R, so that a
- *   probe inside a solid notices when the scene changes sooner, for fewer rays (Enshrouded's dead probes
- *   trace 16 a frame).
+ *   wanted time past its traced time, and `(frame + h(slot)) mod T` is 0. A DEAD probe is due every
+ *   period like an ALIVE one, its update casting `PROBE_DEAD_RAYS`, so that a probe inside a solid
+ *   notices when the scene changes (Enshrouded's dead probes trace 16 a frame).
  *
  * Wanted since its last update, not this frame: a hit wants a probe the frame after its own probe's
  * update, so a probe that only hits keep is wanted on few of its turns. Measured on Sponza with the

package/src/shade/renderer/global_illumination/probe_clipmap/probe/shader_probe_clipmap_guide.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"shader_probe_clipmap_guide.d.ts","sourceRoot":"","sources":["../../../../../../../src/shade/renderer/global_illumination/probe_clipmap/probe/shader_probe_clipmap_guide.js"],"names":[],"mappings":"AAmBA;;GAEG;AACH,mCAFU,YAAY,CAWG;AAkEzB;;;;;;;;;GASG;AACH,8CAFU,aAAa,CAgCpB;AAEH;;;;;;GAMG;AACH,iDAFU,aAAa,CA4CpB;AAEH;;;;;;;;GAQG;AACH,gDAFU,aAAa,CA2DpB;6BA1P0B,sCAAsC;8BAHrC,kCAAkC"}
+{"version":3,"file":"shader_probe_clipmap_guide.d.ts","sourceRoot":"","sources":["../../../../../../../src/shade/renderer/global_illumination/probe_clipmap/probe/shader_probe_clipmap_guide.js"],"names":[],"mappings":"AAmBA;;GAEG;AACH,mCAFU,YAAY,CAaG;AAkEzB;;;;;;;;;GASG;AACH,8CAFU,aAAa,CAgCpB;AAEH;;;;;;GAMG;AACH,iDAFU,aAAa,CA4CpB;AAEH;;;;;;;;GAQG;AACH,gDAFU,aAAa,CA2DpB;6BA5P0B,sCAAsC;8BAHrC,kCAAkC"}

package/src/shade/renderer/global_illumination/probe_clipmap/probe/shader_probe_clipmap_guide.js

@@ -29,6 +29,8 @@ export const PROBE_GUIDE_SETTINGS = WebGPUStruct.from({
     radiance_resolution: u32,
     /** tiles a row of the radiance atlas */
     radiance_tiles_per_row: u32,
+    /** texels of skirt around a radiance tile's map on each side: 1, or 0 for a clipmap whose radiance is never sampled */
+    radiance_skirt: u32,
 }, "ProbeGuideSettings");
 
 const resources = new ShaderResourceSetDescriptor();
@@ -78,7 +80,7 @@ fn probe_guide_thread(workgroup_id: vec3<u32>, lane: u32) -> ProbeGuideThread {
     out.slot = probe_trace.elements[out.k];
     out.updates = probe_state_updates(probe_states[out.slot].x);
     out.base = out.k * probe_clipmap_guide_words(n);
-    out.tile = index_to_grid2d(out.slot, settings.radiance_tiles_per_row) * (n + 2u) + 1u;
+    out.tile = index_to_grid2d(out.slot, settings.radiance_tiles_per_row) * (n + 2u * settings.radiance_skirt) + settings.radiance_skirt;
 
     return out;
 }

package/src/shade/renderer/global_illumination/probe_clipmap/probe/shader_probe_clipmap_light.d.ts

@@ -1,8 +1,8 @@
 /**
- * The light a front-face hit takes from beyond the trace (PROBE_CLIPMAP_PROPOSAL_2026_10_27.md §8.7): a
+ * The light a front-face hit takes from the local lights (PROBE_CLIPMAP_PROPOSAL_2026_10_27.md §8.7): a
  * thread a ray, after shade through the same launch, `PROBE_DISPATCH_RAYS`, its probe the one trace wrote
- * into its flags. It adds ρ_d·(E_loc + E_ind)/π to the radiance shade left, ρ_d being the albedo shade
- * left in the ray's \`row\`.
+ * into its flags. It adds ρ_d·E_loc/π to the radiance shade left, ρ_d being the albedo shade left in the
+ * ray's \`row\`; the next bounce, E_ind, is the bounce pass's, after it (`shader_probe_clipmap_bounce`).
  *
  * - **E_loc, the local lights**: one of the point and spot lights of the hit's cell of the world light
  *   clusters, built over the bricks' cascades so that every hit has one, at most
@@ -19,16 +19,10 @@
  *     a voxel, whichever is more, for the expand at that end. It sees the light if it misses; a hit, or a
  *     march that spends its steps, is no light. A light that casts no shadow traces none.
  *   - The pick and the point are drawn from the ray's slot and direction, fresh every update.
- * - **E_ind, the next bounce**: this mode's own diffuse at the hit, `probe_clipmap_sample_sh` from the
- *   hit along its normal, the view back along the ray, with the ray's own jitter as the pick's noise.
- *   The projection writes the records later in the frame, so they hold last frame's SH: each frame takes
- *   one more bounce.
- * - Where no probe weighs anything the bounce is **zero**, not the environment: a hit behind the camera
- *   in a cave must not bring daylight in. The next frame's hits' wants ask for the probes it read
- *   (`shader_probe_clipmap_want_hits`), so the bounce has them a frame or two later.
- * - LPV's 0.97 a bounce is dropped: an albedo under one bounds the series already.
  *
- * Its own pass because shade binds nine of a stage's ten storage buffers, and the pick takes two more.
+ * Its own pass because shade binds nine of a stage's ten storage buffers; apart from the bounce because the
+ * two together would bind twelve storage buffers, and a shadow march is another cost than probe taps
+ * (WORLD_PROBE_CACHE_SCOPE_2026_11_01.md §1.5).
  *
  * @type {ComputeShader}
  */

package/src/shade/renderer/global_illumination/probe_clipmap/probe/shader_probe_clipmap_light.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"shader_probe_clipmap_light.d.ts","sourceRoot":"","sources":["../../../../../../../src/shade/renderer/global_illumination/probe_clipmap/probe/shader_probe_clipmap_light.js"],"names":[],"mappings":"AA8FA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAiCG;AACH,yCAFU,aAAa,CA6LpB;8BApS2B,kCAAkC"}
+{"version":3,"file":"shader_probe_clipmap_light.d.ts","sourceRoot":"","sources":["../../../../../../../src/shade/renderer/global_illumination/probe_clipmap/probe/shader_probe_clipmap_light.js"],"names":[],"mappings":"AAqEA;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2BG;AACH,yCAFU,aAAa,CA0KpB;8BAnP2B,kCAAkC"}

package/src/shade/renderer/global_illumination/probe_clipmap/probe/shader_probe_clipmap_light.js

@@ -11,20 +11,20 @@ import {
 import { chunk_rgb_to_luminance } from "../../../shader/chunk/color/chunk_rgb_to_luminance.js";
 import { chunk_rgbe9995_decode } from "../../../shader/chunk/color/rgbe9995/chunk_rgbe9995_decode.js";
 import { chunk_rgbe9995_encode } from "../../../shader/chunk/color/rgbe9995/chunk_rgbe9995_encode.js";
-import { chunk_uv_octahedral_unit_decode } from "../../../shader/chunk/geometry/octahedron/chunk_uv_octahedral_unit_decode.js";
+import {
+    chunk_uv_octahedral_unit_decode
+} from "../../../shader/chunk/geometry/octahedron/chunk_uv_octahedral_unit_decode.js";
 import { chunk_sphere_sample_volume } from "../../../shader/chunk/geometry/sphere/chunk_sphere_sample_volume.js";
 import { chunk_folded_workgroup_index } from "../../../shader/chunk/grid/chunk_folded_workgroup_index.js";
 import { RECIPROCAL_PI_DECLARATION } from "../../../shader/chunk/math/RECIPROCAL_PI_DECLARATION.js";
 import { chunk_hash_to_float01 } from "../../../shader/chunk/random/chunk_hash_to_float01.js";
 import { chunk_pcg4d } from "../../../shader/chunk/random/pcg/chunk_pcg4d.js";
-import {
-    chunk_resolve_irradiance_sh_to_diffuse
-} from "../../../shader/chunk/spherical_harmonics/l1i/chunk_resolve_irradiance_sh_to_diffuse.js";
 import { CodeChunk } from "../../../shader/compiler/CodeChunk.js";
 import { ComputeShader } from "../../../shader/ComputeShader.js";
 import { ShaderResourceSetDescriptor } from "../../../shader/resource/ShaderResourceSetDescriptor.js";
-import { STBN_VEC2_RESOURCE } from "../../../STATIC_GRAPHICS_ENGINE_ASSET_RESOURCES.js";
-import { chunk_irradiance_clipmap_local_light } from "../../../volumetrics/irradiance_clipmap/chunk_irradiance_clipmap_local_light.js";
+import {
+    chunk_irradiance_clipmap_local_light
+} from "../../../volumetrics/irradiance_clipmap/chunk_irradiance_clipmap_local_light.js";
 import { IRRADIANCE_CLIPMAP_LIGHT_BUDGET } from "../../../volumetrics/irradiance_clipmap/IRRADIANCE_CLIPMAP.js";
 import { BRICK_TRACE_HIT } from "../brick/BRICK_CLIPMAP.js";
 import {
@@ -37,25 +37,11 @@ import {
 } from "../brick/chunk_brick_clipmap_trace.js";
 import {
     chunk_probe_clipmap,
-    chunk_probe_clipmap_ray_jitter,
-    chunk_probe_clipmap_ray_layout,
     chunk_probe_clipmap_ray_origin,
-    chunk_probe_clipmap_ray_texel,
-    PROBE_DEPTH_HISTORY_RESOURCE,
-    PROBE_LEVELS_RESOURCE,
     PROBE_ORIGINS_READ_RESOURCE,
-    PROBE_RAY_SUMS_READ_RESOURCE,
     PROBE_RAYS_WRITE_RESOURCE,
-    PROBE_RECORDS_READ_RESOURCE,
-    PROBE_STATES_READ_RESOURCE,
     PROBE_TRACE_READ_RESOURCE
 } from "./chunk_probe_clipmap.js";
-import {
-    chunk_probe_clipmap_pick,
-    PROBE_DEPTH_SAMPLER_RESOURCE,
-    PROBE_INDIRECTION_READ_RESOURCE,
-    PROBE_SAMPLING_RESOURCE
-} from "./chunk_probe_clipmap_pick.js";
 import { PROBE_THREAD_WORKGROUP_SIZE } from "./PROBE_CLIPMAP.js";
 import { PROBE_TRACE_SETTINGS } from "./shader_probe_clipmap_trace.js";
 
@@ -69,18 +55,7 @@ resources.setImmediate("settings", PROBE_TRACE_SETTINGS);
 resources.createGroup()
     .add(PROBE_TRACE_READ_RESOURCE)
     .add(PROBE_ORIGINS_READ_RESOURCE)
-    .add(PROBE_RAYS_WRITE_RESOURCE)
-    .add(PROBE_RAY_SUMS_READ_RESOURCE)
-    .add(PROBE_STATES_READ_RESOURCE)
-    .add(STBN_VEC2_RESOURCE);
-
-resources.createGroup()
-    .add(PROBE_LEVELS_RESOURCE)
-    .add(PROBE_SAMPLING_RESOURCE)
-    .add(PROBE_INDIRECTION_READ_RESOURCE)
-    .add(PROBE_RECORDS_READ_RESOURCE)
-    .add(PROBE_DEPTH_HISTORY_RESOURCE)
-    .add(PROBE_DEPTH_SAMPLER_RESOURCE);
+    .add(PROBE_RAYS_WRITE_RESOURCE);
 
 resources.createGroup()
     .add(BRICK_LEVELS_RESOURCE)
@@ -93,10 +68,10 @@ resources.createGroup()
     .add(WORLD_CLUSTER_DATA_RESOURCE);
 
 /**
- * The light a front-face hit takes from beyond the trace (PROBE_CLIPMAP_PROPOSAL_2026_10_27.md §8.7): a
+ * The light a front-face hit takes from the local lights (PROBE_CLIPMAP_PROPOSAL_2026_10_27.md §8.7): a
  * thread a ray, after shade through the same launch, `PROBE_DISPATCH_RAYS`, its probe the one trace wrote
- * into its flags. It adds ρ_d·(E_loc + E_ind)/π to the radiance shade left, ρ_d being the albedo shade
- * left in the ray's \`row\`.
+ * into its flags. It adds ρ_d·E_loc/π to the radiance shade left, ρ_d being the albedo shade left in the
+ * ray's \`row\`; the next bounce, E_ind, is the bounce pass's, after it (`shader_probe_clipmap_bounce`).
  *
  * - **E_loc, the local lights**: one of the point and spot lights of the hit's cell of the world light
  *   clusters, built over the bricks' cascades so that every hit has one, at most
@@ -113,16 +88,10 @@ resources.createGroup()
  *     a voxel, whichever is more, for the expand at that end. It sees the light if it misses; a hit, or a
  *     march that spends its steps, is no light. A light that casts no shadow traces none.
  *   - The pick and the point are drawn from the ray's slot and direction, fresh every update.
- * - **E_ind, the next bounce**: this mode's own diffuse at the hit, `probe_clipmap_sample_sh` from the
- *   hit along its normal, the view back along the ray, with the ray's own jitter as the pick's noise.
- *   The projection writes the records later in the frame, so they hold last frame's SH: each frame takes
- *   one more bounce.
- * - Where no probe weighs anything the bounce is **zero**, not the environment: a hit behind the camera
- *   in a cave must not bring daylight in. The next frame's hits' wants ask for the probes it read
- *   (`shader_probe_clipmap_want_hits`), so the bounce has them a frame or two later.
- * - LPV's 0.97 a bounce is dropped: an albedo under one bounds the series already.
  *
- * Its own pass because shade binds nine of a stage's ten storage buffers, and the pick takes two more.
+ * Its own pass because shade binds nine of a stage's ten storage buffers; apart from the bounce because the
+ * two together would bind twelve storage buffers, and a shadow march is another cost than probe taps
+ * (WORLD_PROBE_CACHE_SCOPE_2026_11_01.md §1.5).
  *
  * @type {ComputeShader}
  */
@@ -255,16 +224,8 @@ fn main(
         return;
     }
 
-    // the probe's update's rays, and this one's place among them
     let k = record.flags >> PROBE_RAY_PROBE_SHIFT;
-    let span = probe_clipmap_probe_rays(k);
-    let rays = span.y;
-    let i = ray - span.x;
-
     let slot = probe_trace.elements[k];
-    let n = settings.radiance_resolution;
-    let updates = probe_state_updates(probe_states[slot].x);
-    let texel = probe_clipmap_ray_texel(i, updates, rays, n * n);
 
     let direction = uv_octahedral_unit_decode(unpack2x16unorm(record.direction));
     let position = probe_clipmap_ray_origin(probe_origins[k], slot, record.direction) + record.t * direction;
@@ -274,14 +235,8 @@ fn main(
     let hash = pcg4d(vec4<u32>(slot, record.direction, 0xA54FF53Au, 0u));
     let random = vec4<f32>(hash_to_float01(hash.x), hash_to_float01(hash.y), hash_to_float01(hash.z), hash_to_float01(hash.w));
 
-    // E/π: the local lights', then the next bounce's, which the resolve gives as E/π
-    var e = probe_clipmap_local_irradiance((record.flags >> PROBE_RAY_CASCADE_SHIFT) & PROBE_RAY_CASCADE_MASK, position, normal, random) * RECIPROCAL_PI;
-
-    let probes = probe_clipmap_sample_sh(position, normal, -direction, probe_clipmap_ray_jitter(slot, texel, i, updates, rays, n));
-
-    if (probes.found) {
-        e += resolve_irradiance_sh_to_diffuse(probes.sh.Y, probes.sh.CoCg, normal);
-    }
+    // E/π of the local lights
+    let e = probe_clipmap_local_irradiance((record.flags >> PROBE_RAY_CASCADE_SHIFT) & PROBE_RAY_CASCADE_MASK, position, normal, random) * RECIPROCAL_PI;
 
     if (all(e == vec3<f32>(0.0))) {
         return;
@@ -291,14 +246,9 @@ fn main(
 }
 `, [
             chunk_probe_clipmap,
-            chunk_probe_clipmap_ray_layout,
-            chunk_probe_clipmap_ray_texel,
-            chunk_probe_clipmap_ray_jitter,
             chunk_probe_clipmap_ray_origin,
             chunk_folded_workgroup_index,
             chunk_uv_octahedral_unit_decode,
-            chunk_probe_clipmap_pick,
-            chunk_resolve_irradiance_sh_to_diffuse,
             RECIPROCAL_PI_DECLARATION,
             chunk_world_light_cluster_lookup_at,
             chunk_light_cluster_counts,

package/src/shade/renderer/global_illumination/probe_clipmap/probe/shader_probe_clipmap_order.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"shader_probe_clipmap_order.d.ts","sourceRoot":"","sources":["../../../../../../../src/shade/renderer/global_illumination/probe_clipmap/probe/shader_probe_clipmap_order.js"],"names":[],"mappings":"AAeA;;GAEG;AACH,mCAFU,YAAY,CASG;AAWzB;;;;;;;;;;;;;;GAcG;AACH,yCAFU,aAAa,CA4DpB;6BArG0B,sCAAsC;8BAHrC,kCAAkC"}
+{"version":3,"file":"shader_probe_clipmap_order.d.ts","sourceRoot":"","sources":["../../../../../../../src/shade/renderer/global_illumination/probe_clipmap/probe/shader_probe_clipmap_order.js"],"names":[],"mappings":"AAoBA;;GAEG;AACH,mCAFU,YAAY,CASG;AAWzB;;;;;;;;;;;;;;GAcG;AACH,yCAFU,aAAa,CA4DpB;6BAzG0B,sCAAsC;8BAHrC,kCAAkC"}

package/src/shade/renderer/global_illumination/probe_clipmap/probe/shader_probe_clipmap_order.js

@@ -1,3 +1,4 @@
+import { assert } from "../../../../../core/assert.js";
 import { chunk_sort_bitonic_workgroup } from "../../../gpu_primitive/sort/chunk_sort_bitonic_workgroup.js";
 import { SORT_KEYS_PER_THREAD, SORT_TILE_SIZE, SORT_WORKGROUP_SIZE } from "../../../gpu_primitive/sort/defs.js";
 import { chunk_v3_morton_encode } from "../../../shader/chunk/bvh/morton/chunk_v3_morton_encode.js";
@@ -7,8 +8,12 @@ import { ComputeShader } from "../../../shader/ComputeShader.js";
 import { ShaderResourceSetDescriptor } from "../../../shader/resource/ShaderResourceSetDescriptor.js";
 import { u32 } from "../../../shader/type/WEBGPU_WGSL_PRIMITIVE_TYPES.js";
 import { WebGPUStruct } from "../../../shader/type/WebGPUStruct.js";
-import { assert } from "../../../../../core/assert.js";
-import { chunk_probe_clipmap, PROBE_LEVELS_RESOURCE, PROBE_RECORDS_READ_RESOURCE, PROBE_TRACE_ORDER_RESOURCE } from "./chunk_probe_clipmap.js";
+import {
+    chunk_probe_clipmap,
+    PROBE_LEVELS_RESOURCE,
+    PROBE_RECORDS_READ_RESOURCE,
+    PROBE_TRACE_ORDER_RESOURCE
+} from "./chunk_probe_clipmap.js";
 import { PROBE_ORDER_RUN } from "./PROBE_CLIPMAP.js";
 
 assert.equal(PROBE_ORDER_RUN, SORT_TILE_SIZE, 'PROBE_ORDER_RUN is a tile of the bitonic sort');

package/src/shade/renderer/global_illumination/probe_clipmap/probe/shader_probe_clipmap_project.d.ts

@@ -16,7 +16,7 @@ export const shader_probe_clipmap_project_rows: ComputeShader;
 /**
  * Projection, probes (PROBE_CLIPMAP_PROPOSAL_2026_10_27.md §8.4, §8.8): a thread a listed probe,
  * dispatched through `PROBE_DISPATCH_TRACED`. It sums its rows into its record's SH, and classifies it
- * by the update's resolved rays: dead past a quarter of back faces, else alive, its update counted and
+ * by the update's resolved rays: dead when every one hit a back face, else alive, its update counted and
  * its time the frame's. An update with no resolved ray keeps the probe's kind.
  *
  * Only uniform rays classify. Those are a uniform update's, and a guided update's whose guide weighs
@@ -32,9 +32,9 @@ export const shader_probe_clipmap_project_rows: ComputeShader;
  *   texel's own noise (measured: the estimator's inconsistency barely moves on a doubling); a sum of the
  *   falls unbounded is one bright sample's.
  * - The score is held to the probe's own: moved means past `PROBE_CHANGE_SIGNIFICANCE` of its running
- *   deviation, at least one, from its running mean, both over the estimator's variance window (2τ). A
- *   probe whose means sit off its samples (the estimator's own bias on texels lit by few rays) scores
- *   steadily off zero.
+ *   deviation, at least one, from its running mean, both over the estimator's variance window,
+ *   `PROBE_VARIANCE_BLEND` an update however long since the last. A probe whose means sit off its samples
+ *   (the estimator's own bias on texels lit by few rays) scores steadily off zero.
  * - Measured, Sponza on the 4090, the camera and the light still, 3,600 frames settled: of the probes
  *   past 64 updates, 4.2% asked for the most against a sum of the raw falls held to zero, 3.2% with each
  *   texel's fall bounded, and 1.1–1.3% held to their own statistics.

package/src/shade/renderer/global_illumination/probe_clipmap/probe/shader_probe_clipmap_project.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"shader_probe_clipmap_project.d.ts","sourceRoot":"","sources":["../../../../../../../src/shade/renderer/global_illumination/probe_clipmap/probe/shader_probe_clipmap_project.js"],"names":[],"mappings":"AAyBA;;GAEG;AACH,qCAFU,YAAY,CAqBK;AAW3B;;;;;;;;;GASG;AACH,gDAFU,aAAa,CAuDpB;AAcH;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA4BG;AACH,2CAFU,aAAa,CA8FpB;6BAxP0B,sCAAsC;8BAHrC,kCAAkC"}
+{"version":3,"file":"shader_probe_clipmap_project.d.ts","sourceRoot":"","sources":["../../../../../../../src/shade/renderer/global_illumination/probe_clipmap/probe/shader_probe_clipmap_project.js"],"names":[],"mappings":"AAoCA;;GAEG;AACH,qCAFU,YAAY,CAmBK;AAW3B;;;;;;;;;GASG;AACH,gDAFU,aAAa,CAuDpB;AAcH;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA4BG;AACH,2CAFU,aAAa,CA4FpB;6BAzP0B,sCAAsC;8BAHrC,kCAAkC"}

package/src/shade/renderer/global_illumination/probe_clipmap/probe/shader_probe_clipmap_project.js

@@ -1,11 +1,17 @@
-import { chunk_octahedral_solid_angle } from "../../../shader/chunk/geometry/octahedron/chunk_octahedral_solid_angle.js";
-import { chunk_uv_octahedral_unit_decode } from "../../../shader/chunk/geometry/octahedron/chunk_uv_octahedral_unit_decode.js";
+import {
+    chunk_octahedral_solid_angle
+} from "../../../shader/chunk/geometry/octahedron/chunk_octahedral_solid_angle.js";
+import {
+    chunk_uv_octahedral_unit_decode
+} from "../../../shader/chunk/geometry/octahedron/chunk_uv_octahedral_unit_decode.js";
 import { chunk_folded_workgroup_index } from "../../../shader/chunk/grid/chunk_folded_workgroup_index.js";
-import { chunk_convert_to_irradiance_sh } from "../../../shader/chunk/spherical_harmonics/l1i/chunk_convert_to_irradiance_sh.js";
+import {
+    chunk_convert_to_irradiance_sh
+} from "../../../shader/chunk/spherical_harmonics/l1i/chunk_convert_to_irradiance_sh.js";
 import { CodeChunk } from "../../../shader/compiler/CodeChunk.js";
 import { ComputeShader } from "../../../shader/ComputeShader.js";
 import { ShaderResourceSetDescriptor } from "../../../shader/resource/ShaderResourceSetDescriptor.js";
-import { f32, u32 } from "../../../shader/type/WEBGPU_WGSL_PRIMITIVE_TYPES.js";
+import { u32 } from "../../../shader/type/WEBGPU_WGSL_PRIMITIVE_TYPES.js";
 import { WebGPUStruct } from "../../../shader/type/WebGPUStruct.js";
 import {
     chunk_probe_clipmap,
@@ -21,7 +27,12 @@ import {
     PROBE_STATES_STORE_RESOURCE,
     PROBE_TRACE_READ_RESOURCE
 } from "./chunk_probe_clipmap.js";
-import { PROBE_CHANGE_SIGNIFICANCE, PROBE_DEAD_BACK_FACE_SHARE, PROBE_RADIANCE_SAMPLES_LIMIT, PROBE_THREAD_WORKGROUP_SIZE } from "./PROBE_CLIPMAP.js";
+import {
+    PROBE_CHANGE_SIGNIFICANCE,
+    PROBE_RADIANCE_SAMPLES_LIMIT,
+    PROBE_THREAD_WORKGROUP_SIZE,
+    PROBE_VARIANCE_BLEND
+} from "./PROBE_CLIPMAP.js";
 
 /**
  * @type {WebGPUStruct}
@@ -39,12 +50,10 @@ export const PROBE_PROJECT_SETTINGS = WebGPUStruct.from({
     frame: u32,
     /** updates between a probe's uniform ones, `PROBE_UNIFORM_PERIOD` */
     uniform_period: u32,
-    /** the fewest rays an update casts, `PROBE_RAYS_PER_TEXEL_MIN` of the texels */
+    /** the fewest rays a guided update casts, `PROBE_RAYS_PER_TEXEL_MIN` of the texels */
     rays_min: u32,
     /** the most rays an update casts, `PROBE_RAYS_PER_TEXEL_MAX` of the texels */
     rays_max: u32,
-    /** the radiance's short mean's response, τ, in frames: the change score's statistics follow it */
-    response_frames: f32,
 }, "ProbeProjectSettings");
 
 const row_resources = new ShaderResourceSetDescriptor();
@@ -136,7 +145,7 @@ probe_resources.createGroup()
 /**
  * Projection, probes (PROBE_CLIPMAP_PROPOSAL_2026_10_27.md §8.4, §8.8): a thread a listed probe,
  * dispatched through `PROBE_DISPATCH_TRACED`. It sums its rows into its record's SH, and classifies it
- * by the update's resolved rays: dead past a quarter of back faces, else alive, its update counted and
+ * by the update's resolved rays: dead when every one hit a back face, else alive, its update counted and
  * its time the frame's. An update with no resolved ray keeps the probe's kind.
  *
  * Only uniform rays classify. Those are a uniform update's, and a guided update's whose guide weighs
@@ -152,9 +161,9 @@ probe_resources.createGroup()
  *   texel's own noise (measured: the estimator's inconsistency barely moves on a doubling); a sum of the
  *   falls unbounded is one bright sample's.
  * - The score is held to the probe's own: moved means past `PROBE_CHANGE_SIGNIFICANCE` of its running
- *   deviation, at least one, from its running mean, both over the estimator's variance window (2τ). A
- *   probe whose means sit off its samples (the estimator's own bias on texels lit by few rays) scores
- *   steadily off zero.
+ *   deviation, at least one, from its running mean, both over the estimator's variance window,
+ *   `PROBE_VARIANCE_BLEND` an update however long since the last. A probe whose means sit off its samples
+ *   (the estimator's own bias on texels lit by few rays) scores steadily off zero.
  * - Measured, Sponza on the 4090, the camera and the light still, 3,600 frames settled: of the probes
  *   past 64 updates, 4.2% asked for the most against a sum of the raw falls held to zero, 3.2% with each
  *   texel's fall bounded, and 1.1–1.3% held to their own statistics.
@@ -208,13 +217,11 @@ fn main(
     if (sum.resolved > 0u && uniform) {
         let share = f32(sum.back_faces) / f32(sum.resolved);
 
-        kind = select(PROBE_STATE_ALIVE, PROBE_STATE_DEAD, share > ${PROBE_DEAD_BACK_FACE_SHARE});
+        kind = select(PROBE_STATE_ALIVE, PROBE_STATE_DEAD, sum.back_faces == sum.resolved);
 
-        probe_records[slot].flags = (probe_records[slot].flags & 0xFFFF0000u) | probe_record_flags(share, false, 0u);
+        probe_records[slot].flags = (probe_records[slot].flags & 0xFFFF0000u) | probe_record_flags(share, 0u);
     }
 
-    let elapsed = f32(settings.frame - probe_records[slot].traced_frame);
-
     probe_states[slot].x = probe_state(kind, updates + 1u);
     probe_records[slot].sh = probe_record_sh_encode(sum.sh);
     probe_records[slot].traced_frame = settings.frame;
@@ -234,7 +241,7 @@ fn main(
         // window; a score past their reach counts at it, so a change in the light does not become the probe's
         // own spread, while a lasting shift of its own still does within a few windows
         let held = clamp(score, request.change_mean - reach, request.change_mean + reach);
-        let blend = max(1.0 / f32(request.changes + 1u), 1.0 - exp(-0.5 * elapsed / settings.response_frames));
+        let blend = max(1.0 / f32(request.changes + 1u), ${PROBE_VARIANCE_BLEND});
         let mean = mix(request.change_mean, held, blend);
 
         request.change_variance = mix(request.change_variance, (held - request.change_mean) * (held - mean), blend);

package/src/shade/renderer/global_illumination/probe_clipmap/probe/shader_probe_clipmap_publish.d.ts

@@ -4,11 +4,13 @@
 export const PROBE_PUBLISH_SETTINGS: WebGPUStruct;
 /**
  * Publish (PROBE_CLIPMAP_PROPOSAL_2026_10_27.md §8.8): a thread a texel of each listed probe's two
- * tiles, the radiance tile's (n_r + 2)² then the depth tile's (n_d + 2)², dispatched through
- * `PROBE_DISPATCH_PUBLISH`. A tile is its map with a one-texel skirt, each skirt texel the interior texel
- * the octahedral fold puts next to it, so a reader's bilinear tap across the edge reads what a wrap would
- * (`texture_octahedral_skirt_uv`). Every texel is written from the probe's maps, which accumulation
- * wrote whole: the atlases are only ever stored into here.
+ * tiles, the radiance tile's (n_r + 2s)² then the depth tile's (n_d + 2)², dispatched through
+ * `PROBE_DISPATCH_PUBLISH`. A tile is its map with a skirt of s texels, one for the depth and
+ * `radiance_skirt` for the radiance, each skirt texel the interior texel the octahedral fold puts next to it,
+ * so a reader's bilinear tap across the edge reads what a wrap would (`texture_octahedral_skirt_uv`). A
+ * clipmap whose radiance is never sampled, only loaded texel by texel, has none there
+ * (WORLD_PROBE_CACHE_SCOPE_2026_11_01.md §1.8). Every texel is written from the probe's maps, which
+ * accumulation wrote whole: the atlases are only ever stored into here.
  *
  * @type {ComputeShader}
  */

package/src/shade/renderer/global_illumination/probe_clipmap/probe/shader_probe_clipmap_publish.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"shader_probe_clipmap_publish.d.ts","sourceRoot":"","sources":["../../../../../../../src/shade/renderer/global_illumination/probe_clipmap/probe/shader_probe_clipmap_publish.js"],"names":[],"mappings":"AAiBA;;GAEG;AACH,qCAFU,YAAY,CAaK;AAY3B;;;;;;;;;GASG;AACH,2CAFU,aAAa,CAqDpB;6BAjG0B,sCAAsC;8BAHrC,kCAAkC"}
+{"version":3,"file":"shader_probe_clipmap_publish.d.ts","sourceRoot":"","sources":["../../../../../../../src/shade/renderer/global_illumination/probe_clipmap/probe/shader_probe_clipmap_publish.js"],"names":[],"mappings":"AAmBA;;GAEG;AACH,qCAFU,YAAY,CAeK;AAY3B;;;;;;;;;;;GAWG;AACH,2CAFU,aAAa,CAuDpB;6BAvG0B,sCAAsC;8BAHrC,kCAAkC"}