@woosh/meep-engine 3.58.0 → 3.59.0

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

@@ -0,0 +1,188 @@
+import { chunk_roughness_to_mip_ratio } from "../../../light/environment/chunk_roughness_to_mip_ratio.js";
+import { chunk_uv_octahedral_unit_encode } from "../../../shader/chunk/geometry/octahedron/chunk_uv_octahedral_unit_encode.js";
+import { chunk_index_to_grid2d_reciprocal } from "../../../shader/chunk/grid/chunk_index_to_grid2d_reciprocal.js";
+import { chunk_probe_visibility_weight } from "../../../shader/chunk/light/probe/chunk_probe_visibility_weight.js";
+import { METRO_L1_IRRADIANCE_STRUCT } from "../../../shader/chunk/spherical_harmonics/l1i/chunk_convert_to_irradiance_sh.js";
+import {
+    chunk_resolve_irradiance_sh_to_specular
+} from "../../../shader/chunk/spherical_harmonics/l1i/chunk_resolve_irradiance_sh_to_specular.js";
+import { chunk_texture_octahedral_skirt_uv } from "../../../shader/chunk/texture/octahedral/chunk_texture_octahedral_skirt_uv.js";
+import { CodeChunk } from "../../../shader/compiler/CodeChunk.js";
+import {
+    PROBE_LEVELS_RESOURCE,
+    PROBE_RADIANCE_HISTORY_RESOURCE,
+    PROBE_RECORDS_READ_RESOURCE,
+    PROBE_STATES_READ_RESOURCE
+} from "./chunk_probe_clipmap.js";
+import { chunk_probe_clipmap_cage } from "./chunk_probe_clipmap_cage.js";
+import {
+    chunk_probe_clipmap_pick,
+    PROBE_DEPTH_SAMPLER_RESOURCE,
+    PROBE_SAMPLING_RESOURCE
+} from "./chunk_probe_clipmap_pick.js";
+import { PROBE_RECEIVER_BIAS_VIEW } from "./PROBE_CLIPMAP.js";
+
+/**
+ * A point's specular radiance from its probes (PROBE_CLIPMAP_PROPOSAL_2026_10_27.md §9.3), before Fresnel:
+ *
+ * ```wgsl
+ * fn probe_clipmap_radiance_of(pick: ProbeClipmapPick, position: vec3<f32>, normal: vec3<f32>, view_direction: vec3<f32>, roughness: f32) -> ProbeClipmapRadiance
+ * fn probe_clipmap_sample_radiance(position: vec3<f32>, normal: vec3<f32>, view_direction: vec3<f32>, roughness: f32, noise: vec2<f32>) -> ProbeClipmapRadiance
+ * ```
+ *
+ * - **The pick is the diffuse's** (`probe_clipmap_pick`), by the normal and the view, so a pass that does
+ *   both picks once: `probe_clipmap_radiance_of` takes a pick already made, with the point, normal and view it
+ *   was made by. Its shares are re-weighted for the lobe, as Brick4's fused pass re-weights its pair:
+ *   each probe's weight taken again with the sample vector in place of the normal, over the weight it was
+ *   picked by, at the visibility it was picked at. The trilinear part cancels.
+ * - **The sample vector** is Lagarde's dominant direction, `normalize(mix(r, n, α))` with r the
+ *   reflection of the view and α the roughness squared.
+ * - **A radiance tap** a probe, along the sample vector after a one-step sphere parallax: the reflected ray
+ *   is met with a sphere about the probe whose radius is its mean depth along the vector. The depth is held
+ *   at the cage's diagonal (§8.2), past which no parallax is taken. One bilinear tap of the tile, through
+ *   its skirt and the depth's sampler.
+ * - **The rough end** is the probes' SH, mixed by the same shares and resolved for the GGX lobe
+ *   (`resolve_irradiance_sh_to_specular`). The two are blended by `roughness_to_mip_ratio`: SH alone from
+ *   roughness 0.7.
+ * - Where no probe weighs anything, nothing is found and the fallback is the caller's.
+ *
+ * @type {CodeChunk}
+ */
+export const chunk_probe_clipmap_sample_radiance = CodeChunk.from(
+    //language=WGSL
+    `
+struct ProbeClipmapRadiance {
+    radiance: vec3<f32>,
+    found: bool,
+}
+
+struct ProbeClipmapLobe {
+    // the probe's share for the lobe, before the shares are renormalised
+    weight: f32,
+    radiance: vec3<f32>,
+    sh: ${METRO_L1_IRRADIANCE_STRUCT.wgsl_ref},
+}
+
+// a slot's radiance toward a direction: one bilinear tap of its tile, through its skirt
+fn probe_clipmap_radiance(slot: u32, direction: vec3<f32>) -> vec3<f32> {
+    let side = probe_sampling.radiance_resolution + 2u;
+    let place = index_to_grid2d_reciprocal(slot, probe_sampling.radiance_tiles_per_row, probe_sampling.radiance_tiles_per_row_reciprocal);
+    let tile = vec2<f32>(place * side);
+    let in_tile = texture_octahedral_skirt_uv(uv_octahedral_unit_encode(direction), f32(side)) * f32(side);
+
+    return textureSampleLevel(probe_radiance, probe_depth_sampler, (tile + in_tile) * probe_sampling.radiance_texel, 0.0).rgb;
+}
+
+// a picked probe's share for the lobe, its radiance along it and its SH
+fn probe_clipmap_lobe(slot: u32, share: f32, position: vec3<f32>, normal: vec3<f32>, bias_direction: vec3<f32>, lobe: vec3<f32>) -> ProbeClipmapLobe {
+    let record = probe_records[slot];
+    let spacing = probe_levels[record.cascade].cell_size;
+    let probe = vec3<f32>(record.cell) * spacing + probe_clipmap_offset_decode(probe_states[slot].y, spacing);
+
+    // the visibility it was picked at: Chebyshev's from its depth toward the biased point
+    let biased = probe_clipmap_biased(record.cascade, position, bias_direction);
+    let to_point = biased - probe;
+    let distance = length(to_point);
+    let visibility = probe_visibility_chebyshev(probe_clipmap_depth_moments(slot, to_point / max(distance, 1e-6)), distance / spacing);
+
+    let toward = normalize(probe - position);
+
+    var out: ProbeClipmapLobe;
+    out.weight = share * probe_visibility_weight(toward, lobe, visibility) / probe_visibility_weight(toward, normal, visibility);
+    out.sh = record.sh;
+
+    // the reflected ray met with a sphere about the probe, its radius the probe's mean depth along the lobe
+    let radius = probe_clipmap_depth_moments(slot, lobe).x * spacing;
+    let origin = position - probe;
+    let b = dot(lobe, origin);
+    let discriminant = b * b - (dot(origin, origin) - radius * radius);
+
+    var direction = lobe;
+
+    if (discriminant >= 0.0) {
+        let t = sqrt(discriminant) - b;
+
+        if (t > 0.0) {
+            direction = normalize(origin + t * lobe);
+        }
+    }
+
+    out.radiance = probe_clipmap_radiance(slot, direction);
+
+    return out;
+}
+
+fn probe_clipmap_radiance_of(pick: ProbeClipmapPick, position: vec3<f32>, normal: vec3<f32>, view_direction: vec3<f32>, roughness: f32) -> ProbeClipmapRadiance {
+    var out: ProbeClipmapRadiance;
+
+    out.found = dot(pick.weights, vec4<f32>(1.0)) > 0.0;
+
+    if (!out.found) {
+        return out;
+    }
+
+    let alpha = roughness * roughness;
+    let lobe = normalize(mix(reflect(-view_direction, normal), normal, alpha));
+    let bias_direction = mix(normal, view_direction, ${PROBE_RECEIVER_BIAS_VIEW});
+
+    var weight = 0.0;
+    var radiance = vec3<f32>(0.0);
+    var sh: ${METRO_L1_IRRADIANCE_STRUCT.wgsl_ref};
+
+    // each by name, the slots of a share of zero not read
+    if (pick.weights.x > 0.0) {
+        let probe = probe_clipmap_lobe(pick.slots.x, pick.weights.x, position, normal, bias_direction, lobe);
+        weight += probe.weight;
+        radiance += probe.weight * probe.radiance;
+        sh.Y += probe.weight * probe.sh.Y;
+        sh.CoCg += probe.weight * probe.sh.CoCg;
+    }
+    if (pick.weights.y > 0.0) {
+        let probe = probe_clipmap_lobe(pick.slots.y, pick.weights.y, position, normal, bias_direction, lobe);
+        weight += probe.weight;
+        radiance += probe.weight * probe.radiance;
+        sh.Y += probe.weight * probe.sh.Y;
+        sh.CoCg += probe.weight * probe.sh.CoCg;
+    }
+    if (pick.weights.z > 0.0) {
+        let probe = probe_clipmap_lobe(pick.slots.z, pick.weights.z, position, normal, bias_direction, lobe);
+        weight += probe.weight;
+        radiance += probe.weight * probe.radiance;
+        sh.Y += probe.weight * probe.sh.Y;
+        sh.CoCg += probe.weight * probe.sh.CoCg;
+    }
+    if (pick.weights.w > 0.0) {
+        let probe = probe_clipmap_lobe(pick.slots.w, pick.weights.w, position, normal, bias_direction, lobe);
+        weight += probe.weight;
+        radiance += probe.weight * probe.radiance;
+        sh.Y += probe.weight * probe.sh.Y;
+        sh.CoCg += probe.weight * probe.sh.CoCg;
+    }
+
+    let rough = resolve_irradiance_sh_to_specular(sh.Y / weight, sh.CoCg / weight, lobe, alpha);
+
+    out.radiance = mix(radiance / weight, rough, roughness_to_mip_ratio(roughness));
+
+    return out;
+}
+
+fn probe_clipmap_sample_radiance(position: vec3<f32>, normal: vec3<f32>, view_direction: vec3<f32>, roughness: f32, noise: vec2<f32>) -> ProbeClipmapRadiance {
+    return probe_clipmap_radiance_of(probe_clipmap_pick(position, normal, view_direction, noise), position, normal, view_direction, roughness);
+}
+`, [
+        chunk_probe_clipmap_pick,
+        chunk_probe_clipmap_cage,
+        chunk_probe_visibility_weight,
+        chunk_index_to_grid2d_reciprocal,
+        chunk_texture_octahedral_skirt_uv,
+        chunk_uv_octahedral_unit_encode,
+        chunk_resolve_irradiance_sh_to_specular,
+        chunk_roughness_to_mip_ratio,
+    ]);
+
+chunk_probe_clipmap_sample_radiance.requireResource(PROBE_LEVELS_RESOURCE);
+chunk_probe_clipmap_sample_radiance.requireResource(PROBE_SAMPLING_RESOURCE);
+chunk_probe_clipmap_sample_radiance.requireResource(PROBE_STATES_READ_RESOURCE);
+chunk_probe_clipmap_sample_radiance.requireResource(PROBE_RECORDS_READ_RESOURCE);
+chunk_probe_clipmap_sample_radiance.requireResource(PROBE_DEPTH_SAMPLER_RESOURCE);
+chunk_probe_clipmap_sample_radiance.requireResource(PROBE_RADIANCE_HISTORY_RESOURCE);

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

@@ -0,0 +1,26 @@
+/**
+ * Wanting the probes a receiving point's pick reads (PROBE_CLIPMAP_PROPOSAL_2026_10_27.md §8.3, §9.1),
+ * for want's pixels and the hits' wants alike.
+ *
+ * ```wgsl
+ * fn probe_clipmap_want(wants: bool, position: vec3<f32>, bias_direction: vec3<f32>, cascade_count: u32, resolution: u32, key_count: u32, flag: u32)
+ * ```
+ *
+ * The cages are the pick's: the finest cascade whose cage window holds the point, the cage of the point
+ * biased along `bias_direction` by that cascade's spacing, and in the cascade's blend skirt the next
+ * cascade's cage too, biased by its own. A cage a bias moved out of its window is not wanted. Each cage
+ * point's bit is set, and a point whose bit was clear goes on the wanted list with `flag` over its key,
+ * so the list holds every point wanted this frame once, with its first wanter's flag.
+ *
+ * A workgroup's lanes want a few cages between them, so the first lane to want a cage claims it in the
+ * workgroup's table and sets its bits; the rest want it through that lane. Measured on the AMD iGPU at
+ * 1280×720 on Sponza before the claims, the bits' atomics were 140 of want's 345 µs and the appends 90.
+ *
+ * Every lane of the workgroup calls it once, wanting or not, from uniform control flow: the appends are
+ * the subgroup's.
+ *
+ * @type {CodeChunk}
+ */
+export const chunk_probe_clipmap_want: CodeChunk;
+import { CodeChunk } from "../../../shader/compiler/CodeChunk.js";
+//# sourceMappingURL=chunk_probe_clipmap_want.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"chunk_probe_clipmap_want.d.ts","sourceRoot":"","sources":["../../../../../../../src/shade/renderer/global_illumination/probe_clipmap/probe/chunk_probe_clipmap_want.js"],"names":[],"mappings":"AA0BA;;;;;;;;;;;;;;;;;;;;;;GAsBG;AACH,uCAFU,SAAS,CAgFZ;0BA7HmB,uCAAuC"}

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

@@ -0,0 +1,132 @@
+import { chunk_collection_u32_append } from "../../../gpu_primitive/chunk_collection_u32_append.js";
+import { chunk_clipmap_select_finest } from "../../../shader/chunk/clipmap/chunk_clipmap_select_finest.js";
+import { CodeChunk } from "../../../shader/compiler/CodeChunk.js";
+import {
+    chunk_probe_clipmap,
+    PROBE_LEVELS_RESOURCE,
+    PROBE_WANTED_BITS_RESOURCE,
+    PROBE_WANTED_WRITE_RESOURCE
+} from "./chunk_probe_clipmap.js";
+import { chunk_probe_clipmap_cage } from "./chunk_probe_clipmap_cage.js";
+import { PROBE_THREAD_WORKGROUP_SIZE } from "./PROBE_CLIPMAP.js";
+
+/**
+ * Slots of a workgroup's claim table: twice the claims its lanes make at most, a cage in each of two
+ * cascades a lane, so a probe finds a slot within a few. Sized for {@link PROBE_THREAD_WORKGROUP_SIZE}
+ * lanes: want's 8×8 tiles, and the hits' wants' 64.
+ * @type {number}
+ */
+const WANT_CLAIM_SLOTS = 2 * 2 * PROBE_THREAD_WORKGROUP_SIZE;
+
+/**
+ * Slots a claim tries before it wants its cage anyway: a bound, which a half-full table does not reach.
+ * @type {number}
+ */
+const WANT_CLAIM_PROBES = 16;
+
+/**
+ * Wanting the probes a receiving point's pick reads (PROBE_CLIPMAP_PROPOSAL_2026_10_27.md §8.3, §9.1),
+ * for want's pixels and the hits' wants alike.
+ *
+ * ```wgsl
+ * fn probe_clipmap_want(wants: bool, position: vec3<f32>, bias_direction: vec3<f32>, cascade_count: u32, resolution: u32, key_count: u32, flag: u32)
+ * ```
+ *
+ * The cages are the pick's: the finest cascade whose cage window holds the point, the cage of the point
+ * biased along `bias_direction` by that cascade's spacing, and in the cascade's blend skirt the next
+ * cascade's cage too, biased by its own. A cage a bias moved out of its window is not wanted. Each cage
+ * point's bit is set, and a point whose bit was clear goes on the wanted list with `flag` over its key,
+ * so the list holds every point wanted this frame once, with its first wanter's flag.
+ *
+ * A workgroup's lanes want a few cages between them, so the first lane to want a cage claims it in the
+ * workgroup's table and sets its bits; the rest want it through that lane. Measured on the AMD iGPU at
+ * 1280×720 on Sponza before the claims, the bits' atomics were 140 of want's 345 µs and the appends 90.
+ *
+ * Every lane of the workgroup calls it once, wanting or not, from uniform control flow: the appends are
+ * the subgroup's.
+ *
+ * @type {CodeChunk}
+ */
+export const chunk_probe_clipmap_want = CodeChunk.from(
+    //language=WGSL
+    `
+// the cages the workgroup's lanes have claimed, by their key plus one; zero at the workgroup's start
+var<workgroup> probe_want_claims: array<atomic<u32>, ${WANT_CLAIM_SLOTS}>;
+
+// whether this lane is the first of its workgroup to want the cage whose least point has \`key\`; a lane
+// that finds no room in its probes wants it as well, which the bits make harmless
+fn probe_want_claim(key: u32) -> bool {
+    let tag = key + 1u;
+
+    var at = (tag * 2654435761u) >> ${32 - Math.log2(WANT_CLAIM_SLOTS)}u;
+
+    for (var probe = 0u; probe < ${WANT_CLAIM_PROBES}u; probe++) {
+        let seen = atomicCompareExchangeWeak(&probe_want_claims[at], 0u, tag);
+
+        if (seen.exchanged) {
+            return true;
+        }
+
+        if (seen.old_value == tag) {
+            return false;
+        }
+
+        // another cage's slot: the next one; an empty slot that failed spuriously is tried again
+        if (seen.old_value != 0u) {
+            at = (at + 1u) & ${WANT_CLAIM_SLOTS - 1}u;
+        }
+    }
+
+    return true;
+}
+
+fn probe_clipmap_want(wants: bool, position: vec3<f32>, bias_direction: vec3<f32>, cascade_count: u32, resolution: u32, key_count: u32, flag: u32) {
+    let selection = clipmap_select_finest(&probe_levels, cascade_count, position, PROBE_BLEND_SKIRT);
+
+    let held = wants && selection.level != CLIPMAP_LEVEL_NONE;
+    let finest = select(0u, selection.level, held);
+    let next = min(finest + 1u, cascade_count - 1u);
+
+    var cage_finest: vec3<i32>;
+    var cage_next: vec3<i32>;
+
+    // storage wraps by the window's side, a power of two: the low bits of a point, negative ones too
+    let wrap = vec3<u32>(resolution - 1u);
+
+    let wants_finest = held && probe_clipmap_cage(finest, position, bias_direction, &cage_finest)
+        && probe_want_claim(probe_clipmap_key(finest, vec3<u32>(cage_finest) & wrap, resolution));
+    let wants_next = held && selection.edge_weight > 0.0 && finest + 1u < cascade_count
+        && probe_clipmap_cage(next, position, bias_direction, &cage_next)
+        && probe_want_claim(probe_clipmap_key(next, vec3<u32>(cage_next) & wrap, resolution));
+
+    // every lane through all sixteen corners, so that the appends stay in uniform control flow
+    for (var k = 0u; k < 16u; k++) {
+        let coarse = k >= 8u;
+        let cascade = select(finest, next, coarse);
+        let wanted = select(wants_finest, wants_next, coarse);
+        let corner = vec3<i32>(vec3<u32>(k & 1u, (k >> 1u) & 1u, (k >> 2u) & 1u));
+        let point = select(cage_finest, cage_next, coarse) + corner;
+
+        let storage = vec3<u32>(point) & wrap;
+        let key = probe_clipmap_key(cascade, storage, resolution);
+        let bit = 1u << (key & 31u);
+
+        var first = false;
+
+        if (wanted) {
+            first = (atomicOr(&probe_wanted_bits[key >> 5u], bit) & bit) == 0u;
+        }
+
+        collection_u32_append(&probe_wanted, first, key | flag, key_count);
+    }
+}
+`, [
+        chunk_probe_clipmap,
+        chunk_clipmap_select_finest,
+        chunk_probe_clipmap_cage,
+        chunk_collection_u32_append,
+    ]);
+
+chunk_probe_clipmap_want.requireResource(PROBE_LEVELS_RESOURCE);
+chunk_probe_clipmap_want.requireResource(PROBE_WANTED_BITS_RESOURCE);
+chunk_probe_clipmap_want.requireResource(PROBE_WANTED_WRITE_RESOURCE);

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

@@ -21,6 +21,10 @@ export const PROBE_ACCUMULATE_SETTINGS: WebGPUStruct;
  *   R to (R ≤ 64·n_d²).
  * - **A new probe's history is another probe's**, its slot's last owner: on its first update a texel
  *   no ray reached is cleared, radiance to nothing seen, depth to the moments of a miss.
+ * - **Stored rounded stochastically** onto halves (`f16_round_stochastic`), with noise fresh for each
+ *   texel and update. Rounded by the store, a blend whose step is under a ULP would stop short of its
+ *   target by up to a ULP/α, and below it, since both devices measured round toward zero: on a room
+ *   glowing evenly, 1.5% at 60 Hz and 5.9% at 240 Hz. Rounded stochastically it moves in expectation.
  *
  * @type {ComputeShader}
  */

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

@@ -1 +1 @@
-{"version":3,"file":"shader_probe_clipmap_accumulate.d.ts","sourceRoot":"","sources":["../../../../../../../src/shade/renderer/global_illumination/probe_clipmap/probe/shader_probe_clipmap_accumulate.js"],"names":[],"mappings":"AA4BA;;GAEG;AACH,wCAFU,YAAY,CAmBQ;AAgB9B;;;;;;;;;;;;;;;;;;;;;GAqBG;AACH,8CAFU,aAAa,CAgLpB;6BA9P0B,sCAAsC;8BAHrC,kCAAkC"}
+{"version":3,"file":"shader_probe_clipmap_accumulate.d.ts","sourceRoot":"","sources":["../../../../../../../src/shade/renderer/global_illumination/probe_clipmap/probe/shader_probe_clipmap_accumulate.js"],"names":[],"mappings":"AA+BA;;GAEG;AACH,wCAFU,YAAY,CAmBQ;AAgB9B;;;;;;;;;;;;;;;;;;;;;;;;;GAyBG;AACH,8CAFU,aAAa,CAgMpB;6BAlR0B,sCAAsC;8BAHrC,kCAAkC"}

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

@@ -1,5 +1,8 @@
 import { chunk_folded_workgroup_index } from "../../../shader/chunk/grid/chunk_folded_workgroup_index.js";
 import { chunk_index_to_grid2d } from "../../../shader/chunk/grid/chunk_index_to_grid2d.js";
+import { chunk_f16_round_stochastic } from "../../../shader/chunk/math/chunk_f16_round_stochastic.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";
@@ -81,6 +84,10 @@ resources.createGroup()
  *   R to (R ≤ 64·n_d²).
  * - **A new probe's history is another probe's**, its slot's last owner: on its first update a texel
  *   no ray reached is cleared, radiance to nothing seen, depth to the moments of a miss.
+ * - **Stored rounded stochastically** onto halves (`f16_round_stochastic`), with noise fresh for each
+ *   texel and update. Rounded by the store, a blend whose step is under a ULP would stop short of its
+ *   target by up to a ULP/α, and below it, since both devices measured round toward zero: on a room
+ *   glowing evenly, 1.5% at 60 Hz and 5.9% at 240 Hz. Rounded stochastically it moves in expectation.
  *
  * @type {ComputeShader}
  */
@@ -94,6 +101,13 @@ fn probe_accumulate_light(ray: ${PROBE_RAY_STRUCT.wgsl_ref}) -> vec3<f32> {
     return vec3<f32>(unpack2x16float(ray.light_rg), unpack2x16float(ray.light_b).x);
 }
 
+// uniform noise in [0, 1) for a texel's store, fresh each update
+fn probe_accumulate_store_noise(slot: u32, texel: u32, updates: u32) -> vec3<f32> {
+    let hash = pcg3d(vec3<u32>(slot, texel, updates));
+
+    return vec3<f32>(hash_to_float01(hash.x), hash_to_float01(hash.y), hash_to_float01(hash.z));
+}
+
 // a ray's depth sample, in spacings: past a miss's, as far as a sample goes
 fn probe_accumulate_depth(ray: ${PROBE_RAY_STRUCT.wgsl_ref}, spacing: f32) -> f32 {
     if ((ray.flags & PROBE_RAY_KIND_MASK) == ${BRICK_TRACE_MISS}u) {
@@ -168,8 +182,11 @@ fn main(
             texel = vec4<f32>(mix(history.rgb, sum / f32(count), alpha), min(history.a + 1.0, ${PROBE_RADIANCE_SAMPLES_LIMIT}.0));
         }
 
-        probe_maps[maps + 2u * i] = pack2x16float(texel.rg);
-        probe_maps[maps + 2u * i + 1u] = pack2x16float(texel.ba);
+        // the count is whole, which any noise keeps
+        let stored = f16_round_stochastic(texel, vec4<f32>(probe_accumulate_store_noise(slot, i, updates), 0.0));
+
+        probe_maps[maps + 2u * i] = pack2x16float(stored.rg);
+        probe_maps[maps + 2u * i + 1u] = pack2x16float(stored.ba);
         probe_maps[maps + 2u * texels + i] = count | (back_faces << 16u);
 
         return;
@@ -249,13 +266,19 @@ fn main(
         moments = vec2<f32>(${PROBE_DEPTH_LIMIT}, ${PROBE_DEPTH_LIMIT} * ${PROBE_DEPTH_LIMIT});
     }
 
-    probe_maps[maps + 3u * texels + j] = pack2x16float(moments);
+    let noise = probe_accumulate_store_noise(slot, texels + j, updates);
+    let stored = f16_round_stochastic(vec4<f32>(moments, 0.0, 0.0), vec4<f32>(noise.xy, 0.0, 0.0));
+
+    probe_maps[maps + 3u * texels + j] = pack2x16float(stored.xy);
 }
 `, [
             chunk_probe_clipmap,
             chunk_probe_clipmap_ray_texel,
             chunk_folded_workgroup_index,
             chunk_index_to_grid2d,
+            chunk_f16_round_stochastic,
+            chunk_pcg3d,
+            chunk_hash_to_float01,
             PROBE_RAY_STRUCT.declaration_chunk,
         ]),
 });

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

@@ -23,6 +23,9 @@ export const PROBE_ADMIT_SETTINGS: WebGPUStruct;
  * free list cannot serve is counted, and the host grows the capacity on it (§7.10's pattern); the
  * point is wanted again the next frame.
  *
+ * Either way the probe is marked the screen's when its entry carries `PROBE_WANTED_SCREEN`, and the
+ * hits' when it does not, which decides whether its hits want in turn.
+ *
  * Retire ran first, so an entry that names a slot names the probe of this very point: the window holds
  * one point a storage cell, and a probe whose point left was freed.
  *

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

@@ -1 +1 @@
-{"version":3,"file":"shader_probe_clipmap_admit.d.ts","sourceRoot":"","sources":["../../../../../../../src/shade/renderer/global_illumination/probe_clipmap/probe/shader_probe_clipmap_admit.js"],"names":[],"mappings":"AAuBA;;GAEG;AACH,2CAFU,YAAY,CAKU;AAUhC;;;;;GAKG;AACH,iDAFU,aAAa,CAqBpB;AAEH;;GAEG;AACH,mCAFU,YAAY,CAWG;AAgBzB;;;;;;;;;;;;;;GAcG;AACH,yCAFU,aAAa,CA6DpB;6BAhK0B,sCAAsC;8BAHrC,kCAAkC"}
+{"version":3,"file":"shader_probe_clipmap_admit.d.ts","sourceRoot":"","sources":["../../../../../../../src/shade/renderer/global_illumination/probe_clipmap/probe/shader_probe_clipmap_admit.js"],"names":[],"mappings":"AAuBA;;GAEG;AACH,2CAFU,YAAY,CAKU;AAUhC;;;;;GAKG;AACH,iDAFU,aAAa,CAqBpB;AAEH;;GAEG;AACH,mCAFU,YAAY,CAWG;AAgBzB;;;;;;;;;;;;;;;;;GAiBG;AACH,yCAFU,aAAa,CAiEpB;6BAvK0B,sCAAsC;8BAHrC,kCAAkC"}

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

@@ -102,6 +102,9 @@ resources.createGroup()
  * free list cannot serve is counted, and the host grows the capacity on it (§7.10's pattern); the
  * point is wanted again the next frame.
  *
+ * Either way the probe is marked the screen's when its entry carries `PROBE_WANTED_SCREEN`, and the
+ * hits' when it does not, which decides whether its hits want in turn.
+ *
  * Retire ran first, so an entry that names a slot names the probe of this very point: the window holds
  * one point a storage cell, and a probe whose point left was freed.
  *
@@ -125,7 +128,9 @@ fn main(
 
     if (index < min(probe_wanted.count, settings.key_count)) {
         let resolution = settings.resolution;
-        let key = probe_wanted.elements[index];
+        let wanted = probe_wanted.elements[index];
+        let key = wanted & ~PROBE_WANTED_SCREEN;
+        let screen = select(0u, 1u, (wanted & PROBE_WANTED_SCREEN) != 0u);
         let cascade = probe_clipmap_key_cascade(key, resolution);
         let storage = probe_clipmap_key_storage(key, resolution);
         let texel = probe_clipmap_indirection_texel(cascade, storage, resolution);
@@ -133,6 +138,7 @@ fn main(
 
         if (entry != PROBE_CLIPMAP_NONE) {
             probe_records[entry].wanted_time = settings.time;
+            probe_records[entry].screen = screen;
         } else {
             slot = slot_stack_pop(&probe_counters[PROBE_COUNTER_FREE], &probe_free, settings.capacity);
 
@@ -145,6 +151,7 @@ fn main(
                 probe_records[slot].wanted_time = settings.time;
                 probe_records[slot].traced_time = settings.time;
                 probe_records[slot].back_face = 0.0;
+                probe_records[slot].screen = screen;
                 probe_records[slot].sh.CoCg = vec2<f32>(0.0);
                 probe_records[slot].sh.Y = vec4<f32>(0.0);
 

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

@@ -0,0 +1,12 @@
+/**
+ * The probe clipmap's deferred diffuse (PROBE_CLIPMAP_PROPOSAL_2026_10_27.md §9.2, §9.6): each pixel's
+ * irradiance from the probes `probe_clipmap_sample_sh` picks around it, with the frame's STBN for the
+ * pick, resolved at its bent normal and multiplied by π, the resolve giving E/π. A pixel no probe weighs
+ * anything for takes the environment's irradiance, as the IBL pass would give it. AO multiplies it, as in
+ * the IBL pass.
+ *
+ * @type {ImageShader}
+ */
+export const shader_probe_clipmap_diffuse: ImageShader;
+import { ImageShader } from "../../../shader/ImageShader.js";
+//# sourceMappingURL=shader_probe_clipmap_diffuse.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"shader_probe_clipmap_diffuse.d.ts","sourceRoot":"","sources":["../../../../../../../src/shade/renderer/global_illumination/probe_clipmap/probe/shader_probe_clipmap_diffuse.js"],"names":[],"mappings":"AAgFA;;;;;;;;GAQG;AACH,2CAFU,WAAW,CAalB;4BAtFyB,gCAAgC"}

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

@@ -0,0 +1,101 @@
+import { CAMERA_UNIFORM_STRUCT } from "../../../camera/CAMERA_UNIFORM_STRUCT.js";
+import { chunk_get_ibl_irradiance } from "../../../deferred/indirect/chunk_get_ibl_irradiance.js";
+import { DEPTH_STENCIL_FOREGROUND_ONLY } from "../../../depth/DEPTH_STENCIL_FOREGROUND_ONLY.js";
+import { ENVIRONMENT_MAP_RESOURCE } from "../../../light/environment/ENVIRONMENT_MAP_RESOURCE.js";
+import { ENVIRONMENT_MAP_SAMPLER_RESOURCE } from "../../../light/environment/ENVIRONMENT_MAP_SAMPLER_RESOURCE.js";
+import { chunk_project_position_from_depth } from "../../../shader/chunk/camera/chunk_project_position_from_depth.js";
+import { chunk_mat4_extract_position } from "../../../shader/chunk/geometry/mat4/chunk_mat4_extract_position.js";
+import { chunk_decode_g_buffer_normal } from "../../../shader/chunk/geometry/normal/chunk_decode_g_buffer_normal.js";
+import { PI_DECLARATION } from "../../../shader/chunk/math/PI_DECLARATION.js";
+import { chunk_stbn_sample_vec2 } from "../../../shader/chunk/noise/chunk_stbn_sample_vec2.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 { ImageShader } from "../../../shader/ImageShader.js";
+import { ShaderResourceSetDescriptor } from "../../../shader/resource/ShaderResourceSetDescriptor.js";
+import { ShaderDescriptor } from "../../../shader/ShaderDescriptor.js";
+import { STBN_VEC2_RESOURCE } from "../../../STATIC_GRAPHICS_ENGINE_ASSET_RESOURCES.js";
+import { VIEW_UNIFORM_STRUCT } from "../../../view/VIEW_UNIFORM_STRUCT.js";
+import { chunk_probe_clipmap_pick, PROBE_CLIPMAP_SAMPLING_GROUP } from "./chunk_probe_clipmap_pick.js";
+
+const resources = new ShaderResourceSetDescriptor();
+
+resources.createGroup()
+    .addTexture("tDepth")
+    .addTexture("tNormals", "uint")
+    .addTexture("tBentNormals", "uint")
+    .addTexture("tGBufferAlbedo")
+    .add(STBN_VEC2_RESOURCE)
+    .addUniform("view", VIEW_UNIFORM_STRUCT)
+    .addUniform("camera", CAMERA_UNIFORM_STRUCT)
+    .add(ENVIRONMENT_MAP_RESOURCE)
+    .add(ENVIRONMENT_MAP_SAMPLER_RESOURCE);
+
+// the whole group the GI hands its readers: a graph pass must declare every input it is given
+resources.addGroup(PROBE_CLIPMAP_SAMPLING_GROUP);
+
+const body = CodeChunk.from(
+    //language=WGSL
+    `
+@fragment
+fn main(
+    @builtin(position) coord: vec4<f32>,
+    @location(0) uv: vec2<f32>,
+) -> @location(0) vec4<f32> {
+    let i_coord = vec2<u32>(coord.xy);
+
+    let depth = textureLoad(tDepth, i_coord, 0).r;
+    let position = project_position_from_depth(uv, depth, camera.view_projection_matrix_inverse);
+    let view_direction = normalize(mat4_extract_position(camera.transform) - position);
+
+    // the surface's own normal picks, as want chose by it; the bent normal resolves, as IBL's does
+    let normal = decode_g_buffer_normal(textureLoad(tNormals, i_coord, 0).xy);
+    let bent_normal = decode_g_buffer_normal(textureLoad(tBentNormals, i_coord, 0).xy);
+
+    let noise = stbn_sample_vec2(vec3<u32>(i_coord, view.frame_index));
+    let probes = probe_clipmap_sample_sh(position, normal, view_direction, noise);
+
+    var irradiance = get_ibl_irradiance(bent_normal);
+
+    if (probes.found) {
+        irradiance = PI * resolve_irradiance_sh_to_diffuse(probes.sh.Y, probes.sh.CoCg, bent_normal);
+    }
+
+    // AO baked in at the source, as the IBL pass does, so the resolve need not know which path ran
+    let occlusion = textureLoad(tGBufferAlbedo, i_coord, 0).a;
+
+    return vec4<f32>(irradiance * occlusion, 0.0);
+}
+`, [
+    chunk_project_position_from_depth,
+    chunk_mat4_extract_position,
+    chunk_decode_g_buffer_normal,
+    chunk_stbn_sample_vec2,
+    chunk_probe_clipmap_pick,
+    chunk_resolve_irradiance_sh_to_diffuse,
+    chunk_get_ibl_irradiance,
+    PI_DECLARATION,
+]);
+
+/**
+ * The probe clipmap's deferred diffuse (PROBE_CLIPMAP_PROPOSAL_2026_10_27.md §9.2, §9.6): each pixel's
+ * irradiance from the probes `probe_clipmap_sample_sh` picks around it, with the frame's STBN for the
+ * pick, resolved at its bent normal and multiplied by π, the resolve giving E/π. A pixel no probe weighs
+ * anything for takes the environment's irradiance, as the IBL pass would give it. AO multiplies it, as in
+ * the IBL pass.
+ *
+ * @type {ImageShader}
+ */
+export const shader_probe_clipmap_diffuse = ImageShader.from({
+    descriptor: ShaderDescriptor.from({
+        label: "Probe Clipmap / Indirect Diffuse",
+        resources,
+        body,
+    }),
+    depthStencil: DEPTH_STENCIL_FOREGROUND_ONLY,
+    targets: [{
+        label: "Diffuse Indirect lighting",
+        format: "rgba16float"
+    }]
+});

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

@@ -5,7 +5,7 @@ export const PROBE_DUE_SETTINGS: WebGPUStruct;
 /**
  * Due (PROBE_CLIPMAP_PROPOSAL_2026_10_27.md §8.5): a thread an entry of the frame's active list,
  * dispatched twice through `PROBE_DISPATCH_ACTIVE` after schedule has set the period T. A probe is due
- * when a pixel wanted it this frame, its point's bit set, and:
+ * when a pixel or a hit wanted it this frame, its point's bit set, and:
  * - it is NEW, in the first pass, which lists them first;
  * - in the second pass, it is ALIVE and `(frame + h(slot)) mod T` is 0, or DEAD and
  *   `(frame + h(slot)) mod 8T` is 0, so that a probe inside a solid notices when the scene changes.

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

@@ -48,7 +48,7 @@ resources.createGroup()
 /**
  * Due (PROBE_CLIPMAP_PROPOSAL_2026_10_27.md §8.5): a thread an entry of the frame's active list,
  * dispatched twice through `PROBE_DISPATCH_ACTIVE` after schedule has set the period T. A probe is due
- * when a pixel wanted it this frame, its point's bit set, and:
+ * when a pixel or a hit wanted it this frame, its point's bit set, and:
  * - it is NEW, in the first pass, which lists them first;
  * - in the second pass, it is ALIVE and `(frame + h(slot)) mod T` is 0, or DEAD and
  *   `(frame + h(slot)) mod 8T` is 0, so that a probe inside a solid notices when the scene changes.

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

@@ -0,0 +1,15 @@
+/**
+ * The probe clipmap's deferred indirect light in one pass (PROBE_CLIPMAP_PROPOSAL_2026_10_27.md §9.6), for SSR
+ * off: one pick a pixel, by its own normal and the view, with the frame's STBN, for both lobes.
+ * - The diffuse is `shader_probe_clipmap_diffuse`'s: the picked SH resolved at the bent normal, times π. Its
+ *   shares are the pick's, not re-weighted for the bent normal, so SSR on and off light the diffuse alike.
+ * - The specular is the pick's radiance (`probe_clipmap_radiance_of`), its shares re-weighted for the lobe.
+ * - A pixel no probe weighs anything for takes the environment's for both.
+ * - The two are resolved as `shader_resolve_indirect_lighting` resolves the IBL pair: AO multiplies the
+ *   diffuse, the specular is occluded along its lobe, and the result is added to the scene's colour.
+ *
+ * @type {ImageShader}
+ */
+export const shader_probe_clipmap_indirect_lighting: ImageShader;
+import { ImageShader } from "../../../shader/ImageShader.js";
+//# sourceMappingURL=shader_probe_clipmap_indirect_lighting.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"shader_probe_clipmap_indirect_lighting.d.ts","sourceRoot":"","sources":["../../../../../../../src/shade/renderer/global_illumination/probe_clipmap/probe/shader_probe_clipmap_indirect_lighting.js"],"names":[],"mappings":"AA0IA;;;;;;;;;;;GAWG;AACH,qDAFU,WAAW,CA0BlB;4BAxJyB,gCAAgC"}