@woosh/meep-engine 3.60.6 → 3.60.8

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

@@ -1,6 +1,6 @@
 /**
  * A probe's record (PROBE_CLIPMAP_PROPOSAL_2026_10_27.md §8.2), 48 bytes a slot: where it is, when it
- * was wanted and traced, its last update's back faces, whose want it was, and its irradiance. Where
+ * was wanted and traced, its last update's back faces, and its irradiance. Where
  * relocation moved it is the state's second word, which readers weighing it load with the state.
  *
  * @type {WebGPUStruct}
@@ -155,7 +155,7 @@ export const PROBE_RAYS_WRITE_RESOURCE: ShaderResourceDescriptor;
 export const PROBE_RAYS_READ_RESOURCE: ShaderResourceDescriptor;
 /**
  * Each listed probe's rays this update that the budget does not scale, `{count, elements}` by its place in
- * the trace list: a uniform update's R and a DEAD probe's fewest, zero for a guided update. The trace
+ * the trace list: a uniform update's R and a DEAD probe's `PROBE_DEAD_RAYS`, zero for a guided update. The trace
  * command writes the count, the ray counts pass the elements.
  * @type {ShaderResourceDescriptor}
  */
@@ -241,6 +241,38 @@ export const PROBE_RESAMPLES_WRITE_RESOURCE: ShaderResourceDescriptor;
  * @type {ShaderResourceDescriptor}
  */
 export const PROBE_RESAMPLES_READ_RESOURCE: ShaderResourceDescriptor;
+/**
+ * The listed probes' re-samples, as the ray re-sample pass adds to them: each texel's four floats as the bits of
+ * four words, `atomic_add_f32_storage`, since the rays of a neighbour land in any of a probe's texels.
+ * @type {ShaderResourceDescriptor}
+ */
+export const PROBE_RESAMPLES_ADD_RESOURCE: ShaderResourceDescriptor;
+/**
+ * A word a slot: its place in the frame's trace list, as relocation writes it for each listed probe. Only the
+ * list confirms an entry (`probe_clipmap_listed`), so a slot not listed this frame keeps a stale one.
+ * @type {ShaderResourceDescriptor}
+ */
+export const PROBE_LISTED_WRITE_RESOURCE: ShaderResourceDescriptor;
+/**
+ * A word a slot: its place in the frame's trace list, as the candidate pass reads it.
+ * @type {ShaderResourceDescriptor}
+ */
+export const PROBE_LISTED_READ_RESOURCE: ShaderResourceDescriptor;
+/**
+ * A listed probe's candidate: the neighbour whose rays it re-samples this frame, and what they weigh.
+ * @type {WebGPUStruct}
+ */
+export const PROBE_CANDIDATE_STRUCT: WebGPUStruct;
+/**
+ * A candidate a listed probe, in list order, as the candidate pass writes it.
+ * @type {ShaderResourceDescriptor}
+ */
+export const PROBE_CANDIDATES_WRITE_RESOURCE: ShaderResourceDescriptor;
+/**
+ * A candidate a listed probe, as the ray re-sample pass reads it.
+ * @type {ShaderResourceDescriptor}
+ */
+export const PROBE_CANDIDATES_READ_RESOURCE: ShaderResourceDescriptor;
 /**
  * A row of a listed probe's radiance map, projected: its irradiance SH, and its rays this update.
  * @type {WebGPUStruct}
@@ -292,7 +324,7 @@ export const PROBE_DEPTH_STORE_RESOURCE: ShaderResourceDescriptor;
  * fn probe_state_updates(state: u32) -> u32
  * fn probe_state(kind: u32, updates: u32) -> u32
  * fn probe_clipmap_age_bucket(age: u32) -> u32 // the bucket of frames unwanted that eviction orders by
- * fn probe_record_flags(back_face: f32, screen: bool, cascade: u32) -> u32
+ * fn probe_record_flags(back_face: f32, cascade: u32) -> u32
  * fn probe_record_cascade(flags: u32) -> u32
  * fn probe_record_sh_encode(sh: MetroL1) -> vec3<u32> // held to the half float's largest, ±65,504
  * fn probe_record_sh_decode(sh: vec3<u32>) -> MetroL1
@@ -409,12 +441,34 @@ export const PROBE_GUIDE_READ_RESOURCE: ShaderResourceDescriptor;
  * fn probe_clipmap_guide_weight(luminance: f32, total: f32, rays: u32, texels: u32) -> u32
  * fn probe_clipmap_guide_phase(slot: u32, updates: u32) -> f32
  * fn probe_clipmap_guide_start(before: u32, total: u32, rays: u32, phase: f32) -> u32 // before: the weight walked before
- * fn probe_clipmap_guide_rate(expected: f32, rays: u32, texels: u32, period: u32) -> f32 // the share of updates a texel takes rays in
  * ```
  *
  * @type {CodeChunk}
  */
 export const chunk_probe_clipmap_guide: CodeChunk;
+/**
+ * The rays a guided update gives a radiance texel, `R·(w + e)/W`, from the probe's guide (§8.6), whose words start
+ * at `base`; nothing for a guide the guide passes never wrote.
+ *
+ * ```wgsl
+ * fn probe_clipmap_guide_expected(base: u32, texel: u32, rays: u32, n: u32) -> f32 // rays: the update's, R
+ * ```
+ *
+ * @type {CodeChunk}
+ */
+export const chunk_probe_clipmap_guide_expected: CodeChunk;
+/**
+ * Where a slot is in the frame's trace list (§8.5), from `probe_listed`, which relocation writes for each listed
+ * probe: its place, or `PROBE_CLIPMAP_NONE` where the list does not hold the slot there, as for a slot not listed
+ * this frame, whose entry is a past frame's.
+ *
+ * ```wgsl
+ * fn probe_clipmap_listed(slot: u32, capacity: u32) -> u32 // capacity: the trace list's bound, U
+ * ```
+ *
+ * @type {CodeChunk}
+ */
+export const chunk_probe_clipmap_listed: CodeChunk;
 /**
  * The jitter of a guided update's ray in its texel. The first ray takes the texel's STBN jitter
  * (`probe_clipmap_ray_jitter` at round 0). The rest rotate it by the R2 sequence, so a texel's rays

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

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

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

@@ -1,26 +1,38 @@
 import { COLLECTION_U32_STRUCT_READ } from "../../../gpu_primitive/COLLECTION_U32_STRUCT_READ.js";
 import { COLLECTION_U32_STRUCT_WRITE } from "../../../gpu_primitive/COLLECTION_U32_STRUCT_WRITE.js";
+import { chunk_clipmap_key } from "../../../shader/chunk/clipmap/chunk_clipmap_key.js";
 import { CLIPMAP_LEVEL_ARRAY } from "../../../shader/chunk/clipmap/CLIPMAP_LEVEL_STRUCT.js";
+import { chunk_rgb_to_luminance } from "../../../shader/chunk/color/chunk_rgb_to_luminance.js";
 import { chunk_sphere_sample_volume } from "../../../shader/chunk/geometry/sphere/chunk_sphere_sample_volume.js";
 import { chunk_mod_v3i } from "../../../shader/chunk/geometry/vec3/chunk_mod_v3i.js";
-import { chunk_rgb_to_luminance } from "../../../shader/chunk/color/chunk_rgb_to_luminance.js";
 import { chunk_lower_bound_branchless } from "../../../shader/chunk/math/chunk_lower_bound_branchless.js";
 import { chunk_stbn_sample_vec2 } from "../../../shader/chunk/noise/chunk_stbn_sample_vec2.js";
 import { chunk_r2_canonical } from "../../../shader/chunk/noise/r/chunk_r2_canonical.js";
 import { chunk_hash_lowbias32 } from "../../../shader/chunk/random/chunk_hash_lowbias32.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 { METRO_L1_IRRADIANCE_STRUCT } from "../../../shader/chunk/spherical_harmonics/l1i/chunk_convert_to_irradiance_sh.js";
+import {
+    METRO_L1_IRRADIANCE_STRUCT
+} from "../../../shader/chunk/spherical_harmonics/l1i/chunk_convert_to_irradiance_sh.js";
 import { CodeChunk } from "../../../shader/compiler/CodeChunk.js";
 import { ShaderResourceDescriptor } from "../../../shader/resource/ShaderResourceDescriptor.js";
-import { atomic_u32, f32, u32, vec2u, vec3i, vec3u, vec4f, vec4u } from "../../../shader/type/WEBGPU_WGSL_PRIMITIVE_TYPES.js";
+import {
+    atomic_u32,
+    f32,
+    u32,
+    vec2u,
+    vec3i,
+    vec3u,
+    vec4f,
+    vec4u
+} from "../../../shader/type/WEBGPU_WGSL_PRIMITIVE_TYPES.js";
 import { WebGPUArray } from "../../../shader/type/WebGPUArray.js";
 import { WebGPUStruct } from "../../../shader/type/WebGPUStruct.js";
 import { STBN_VEC2_RESOURCE } from "../../../STATIC_GRAPHICS_ENGINE_ASSET_RESOURCES.js";
 import {
+    PROBE_AGE_BUCKETS,
     PROBE_BLEND_SKIRT,
     PROBE_CLIPMAP_NONE,
-    PROBE_AGE_BUCKETS,
     PROBE_COUNTER_AGES,
     PROBE_COUNTER_EVICTED,
     PROBE_COUNTER_FREE,
@@ -45,7 +57,6 @@ import {
     PROBE_RAY_ORIGIN_JITTER,
     PROBE_RAY_PROBE_SHIFT,
     PROBE_RECORD_CASCADE_SHIFT,
-    PROBE_RECORD_SCREEN,
     PROBE_RELOCATION_LIMIT,
     PROBE_STATE_ALIVE,
     PROBE_STATE_DEAD,
@@ -54,13 +65,12 @@ import {
     PROBE_STATE_NEW,
     PROBE_STATE_UPDATES_SHIFT,
     PROBE_TEXEL_RAYS,
-    PROBE_THREAD_WORKGROUP_SIZE,
-    PROBE_WANTED_SCREEN
+    PROBE_THREAD_WORKGROUP_SIZE
 } from "./PROBE_CLIPMAP.js";
 
 /**
  * A probe's record (PROBE_CLIPMAP_PROPOSAL_2026_10_27.md §8.2), 48 bytes a slot: where it is, when it
- * was wanted and traced, its last update's back faces, whose want it was, and its irradiance. Where
+ * was wanted and traced, its last update's back faces, and its irradiance. Where
  * relocation moved it is the state's second word, which readers weighing it load with the state.
  *
  * @type {WebGPUStruct}
@@ -69,9 +79,8 @@ export const PROBE_RECORD_STRUCT = WebGPUStruct.from({
     /** the lattice point, in its cascade's spacing: the probe stands at `cell · spacing` before relocation */
     cell: vec3i,
     /**
-     * The share of its last update's resolved rays that hit back faces (§8.4), unorm16 in the low half;
-     * whether a pixel wanted it, `PROBE_RECORD_SCREEN`; and its cascade, `probe_record_cascade`
-     * (`PROBE_CLIPMAP.js`).
+     * The share of its last update's resolved rays that hit back faces (§8.4), unorm16 in the low half,
+     * and its cascade, `probe_record_cascade` (`PROBE_CLIPMAP.js`).
      */
     flags: u32,
     /** the frame a pixel or a hit last wanted it, of the frames the clipmap has recorded */
@@ -285,7 +294,7 @@ export const PROBE_RAYS_READ_RESOURCE = ShaderResourceDescriptor.storageBuffer("
 
 /**
  * Each listed probe's rays this update that the budget does not scale, `{count, elements}` by its place in
- * the trace list: a uniform update's R and a DEAD probe's fewest, zero for a guided update. The trace
+ * the trace list: a uniform update's R and a DEAD probe's `PROBE_DEAD_RAYS`, zero for a guided update. The trace
  * command writes the count, the ray counts pass the elements.
  * @type {ShaderResourceDescriptor}
  */
@@ -395,6 +404,49 @@ export const PROBE_RESAMPLES_WRITE_RESOURCE = ShaderResourceDescriptor.storageBu
  */
 export const PROBE_RESAMPLES_READ_RESOURCE = ShaderResourceDescriptor.storageBuffer("probe_resamples", WebGPUArray.from(vec4f));
 
+/**
+ * The listed probes' re-samples, as the ray re-sample pass adds to them: each texel's four floats as the bits of
+ * four words, `atomic_add_f32_storage`, since the rays of a neighbour land in any of a probe's texels.
+ * @type {ShaderResourceDescriptor}
+ */
+export const PROBE_RESAMPLES_ADD_RESOURCE = ShaderResourceDescriptor.storageBuffer("probe_resamples", WebGPUArray.from(atomic_u32), true);
+
+/**
+ * A word a slot: its place in the frame's trace list, as relocation writes it for each listed probe. Only the
+ * list confirms an entry (`probe_clipmap_listed`), so a slot not listed this frame keeps a stale one.
+ * @type {ShaderResourceDescriptor}
+ */
+export const PROBE_LISTED_WRITE_RESOURCE = ShaderResourceDescriptor.storageBuffer("probe_listed", WebGPUArray.u32, true);
+
+/**
+ * A word a slot: its place in the frame's trace list, as the candidate pass reads it.
+ * @type {ShaderResourceDescriptor}
+ */
+export const PROBE_LISTED_READ_RESOURCE = ShaderResourceDescriptor.storageBuffer("probe_listed", WebGPUArray.u32);
+
+/**
+ * A listed probe's candidate: the neighbour whose rays it re-samples this frame, and what they weigh.
+ * @type {WebGPUStruct}
+ */
+export const PROBE_CANDIDATE_STRUCT = WebGPUStruct.from({
+    /** the neighbour's place in the trace list, or `PROBE_CLIPMAP_NONE` */
+    listed: u32,
+    /** the draw's density divided out: `(1 / M) / p`, M the neighbours it drew from, p the drawn one's chance */
+    weight: f32,
+}, "ProbeCandidate");
+
+/**
+ * A candidate a listed probe, in list order, as the candidate pass writes it.
+ * @type {ShaderResourceDescriptor}
+ */
+export const PROBE_CANDIDATES_WRITE_RESOURCE = ShaderResourceDescriptor.storageBuffer("probe_candidates", WebGPUArray.from(PROBE_CANDIDATE_STRUCT), true);
+
+/**
+ * A candidate a listed probe, as the ray re-sample pass reads it.
+ * @type {ShaderResourceDescriptor}
+ */
+export const PROBE_CANDIDATES_READ_RESOURCE = ShaderResourceDescriptor.storageBuffer("probe_candidates", WebGPUArray.from(PROBE_CANDIDATE_STRUCT));
+
 /**
  * A row of a listed probe's radiance map, projected: its irradiance SH, and its rays this update.
  * @type {WebGPUStruct}
@@ -463,7 +515,7 @@ export const PROBE_DEPTH_STORE_RESOURCE = ShaderResourceDescriptor.storageTextur
  * fn probe_state_updates(state: u32) -> u32
  * fn probe_state(kind: u32, updates: u32) -> u32
  * fn probe_clipmap_age_bucket(age: u32) -> u32 // the bucket of frames unwanted that eviction orders by
- * fn probe_record_flags(back_face: f32, screen: bool, cascade: u32) -> u32
+ * fn probe_record_flags(back_face: f32, cascade: u32) -> u32
  * fn probe_record_cascade(flags: u32) -> u32
  * fn probe_record_sh_encode(sh: MetroL1) -> vec3<u32> // held to the half float's largest, ±65,504
  * fn probe_record_sh_decode(sh: vec3<u32>) -> MetroL1
@@ -515,28 +567,25 @@ const PROBE_RAY_CASCADE_SHIFT = ${PROBE_RAY_CASCADE_SHIFT}u;
 const PROBE_RAY_CASCADE_MASK = ${PROBE_RAY_CASCADE_MASK}u;
 const PROBE_RAY_PROBE_SHIFT = ${PROBE_RAY_PROBE_SHIFT}u;
 
-const PROBE_WANTED_SCREEN = ${PROBE_WANTED_SCREEN}u;
-
-const PROBE_RECORD_SCREEN = ${PROBE_RECORD_SCREEN}u;
 const PROBE_RECORD_CASCADE_SHIFT = ${PROBE_RECORD_CASCADE_SHIFT}u;
 
 const PROBE_THREAD_WORKGROUP_SIZE = ${PROBE_THREAD_WORKGROUP_SIZE}u;
 const PROBE_BLEND_SKIRT = ${PROBE_BLEND_SKIRT}.0;
 
 fn probe_clipmap_key(cascade: u32, storage: vec3<u32>, resolution: u32) -> u32 {
-    return (cascade * resolution + storage.z) * resolution * resolution + storage.y * resolution + storage.x;
+    return clipmap_key(cascade, storage, resolution);
 }
 
 fn probe_clipmap_key_cascade(key: u32, resolution: u32) -> u32 {
-    return key / (resolution * resolution * resolution);
+    return clipmap_key_cascade(key, resolution);
 }
 
 fn probe_clipmap_key_storage(key: u32, resolution: u32) -> vec3<u32> {
-    return vec3<u32>(key % resolution, (key / resolution) % resolution, (key / (resolution * resolution)) % resolution);
+    return clipmap_key_storage(key, resolution);
 }
 
 fn probe_clipmap_indirection_texel(cascade: u32, storage: vec3<u32>, resolution: u32) -> vec3<u32> {
-    return vec3<u32>(storage.x, storage.y, storage.z + cascade * resolution);
+    return clipmap_stacked_texel(cascade, storage, resolution);
 }
 
 fn probe_clipmap_window_point(storage: vec3<u32>, corner: vec3<i32>, resolution: u32) -> vec3<i32> {
@@ -561,8 +610,8 @@ fn probe_clipmap_age_bucket(age: u32) -> u32 {
     return min(32u - countLeadingZeros(age), PROBE_AGE_BUCKETS - 1u);
 }
 
-fn probe_record_flags(back_face: f32, screen: bool, cascade: u32) -> u32 {
-    return (pack2x16unorm(vec2<f32>(back_face, 0.0)) & 0xFFFFu) | select(0u, PROBE_RECORD_SCREEN, screen) | (cascade << PROBE_RECORD_CASCADE_SHIFT);
+fn probe_record_flags(back_face: f32, cascade: u32) -> u32 {
+    return (pack2x16unorm(vec2<f32>(back_face, 0.0)) & 0xFFFFu) | (cascade << PROBE_RECORD_CASCADE_SHIFT);
 }
 
 fn probe_record_cascade(flags: u32) -> u32 {
@@ -605,6 +654,7 @@ fn probe_clipmap_offset_decode(word: u32, spacing: f32) -> vec3<f32> {
 `, [
     PROBE_RECORD_STRUCT.declaration_chunk,
     METRO_L1_IRRADIANCE_STRUCT.declaration_chunk,
+    chunk_clipmap_key,
     chunk_mod_v3i,
 ]);
 
@@ -803,7 +853,6 @@ export const PROBE_GUIDE_READ_RESOURCE = ShaderResourceDescriptor.storageBuffer(
  * fn probe_clipmap_guide_weight(luminance: f32, total: f32, rays: u32, texels: u32) -> u32
  * fn probe_clipmap_guide_phase(slot: u32, updates: u32) -> f32
  * fn probe_clipmap_guide_start(before: u32, total: u32, rays: u32, phase: f32) -> u32 // before: the weight walked before
- * fn probe_clipmap_guide_rate(expected: f32, rays: u32, texels: u32, period: u32) -> f32 // the share of updates a texel takes rays in
  * ```
  *
  * @type {CodeChunk}
@@ -857,13 +906,6 @@ fn probe_clipmap_guide_start(before: u32, total: u32, rays: u32, phase: f32) ->
 
     return u32(clamp(at, 0.0, f32(rays)));
 }
-
-fn probe_clipmap_guide_rate(expected: f32, rays: u32, texels: u32, period: u32) -> f32 {
-    let uniform = min(f32(rays) / f32(texels), 1.0);
-    let guided = min(expected, 1.0);
-
-    return (uniform + f32(period - 1u) * guided) / f32(period);
-}
 `, [
     chunk_probe_clipmap,
     chunk_rgb_to_luminance,
@@ -871,6 +913,61 @@ fn probe_clipmap_guide_rate(expected: f32, rays: u32, texels: u32, period: u32)
     chunk_pcg3d,
 ]);
 
+/**
+ * The rays a guided update gives a radiance texel, `R·(w + e)/W`, from the probe's guide (§8.6), whose words start
+ * at `base`; nothing for a guide the guide passes never wrote.
+ *
+ * ```wgsl
+ * fn probe_clipmap_guide_expected(base: u32, texel: u32, rays: u32, n: u32) -> f32 // rays: the update's, R
+ * ```
+ *
+ * @type {CodeChunk}
+ */
+export const chunk_probe_clipmap_guide_expected = CodeChunk.from(
+    //language=WGSL
+    `
+fn probe_clipmap_guide_expected(base: u32, texel: u32, rays: u32, n: u32) -> f32 {
+    let texels = n * n;
+    let total = probe_guide[base + 2u * texels + 2u * n];
+    let share = probe_guide[base + 2u * texels + 2u * n + 1u];
+
+    // the guide passes always leave a total; a guide they never wrote gives nothing
+    return select(0.0, f32(rays) * f32(probe_guide[base + texels + texel] + share) / f32(total), total > 0u);
+}
+`);
+
+chunk_probe_clipmap_guide_expected.requireResource(PROBE_GUIDE_READ_RESOURCE);
+
+/**
+ * Where a slot is in the frame's trace list (§8.5), from `probe_listed`, which relocation writes for each listed
+ * probe: its place, or `PROBE_CLIPMAP_NONE` where the list does not hold the slot there, as for a slot not listed
+ * this frame, whose entry is a past frame's.
+ *
+ * ```wgsl
+ * fn probe_clipmap_listed(slot: u32, capacity: u32) -> u32 // capacity: the trace list's bound, U
+ * ```
+ *
+ * @type {CodeChunk}
+ */
+export const chunk_probe_clipmap_listed = CodeChunk.from(
+    //language=WGSL
+    `
+fn probe_clipmap_listed(slot: u32, capacity: u32) -> u32 {
+    let k = probe_listed[slot];
+
+    if (k >= min(probe_trace.count, capacity)) {
+        return PROBE_CLIPMAP_NONE;
+    }
+
+    return select(PROBE_CLIPMAP_NONE, k, probe_trace.elements[k] == slot);
+}
+`, [
+    chunk_probe_clipmap,
+]);
+
+chunk_probe_clipmap_listed.requireResource(PROBE_LISTED_READ_RESOURCE);
+chunk_probe_clipmap_listed.requireResource(PROBE_TRACE_READ_RESOURCE);
+
 /**
  * The jitter of a guided update's ray in its texel. The first ray takes the texel's STBN jitter
  * (`probe_clipmap_ray_jitter` at round 0). The rest rotate it by the R2 sequence, so a texel's rays

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

@@ -1,16 +1,27 @@
 /**
- * The cage of a cascade around a receiving point (PROBE_CLIPMAP_PROPOSAL_2026_10_27.md §8.3, §9.1): the
- * lattice cell holding the point moved along `bias_direction` by {@link PROBE_RECEIVER_BIAS} of the
- * cascade's spacing, whose eight corners are the probes the point reads.
+ * The cage of a cascade around a receiving point (PROBE_CLIPMAP_PROPOSAL_2026_10_27.md §8.3, §9.1), in the
+ * clipmap whose levels `levels` points at: the lattice cell holding the point moved along `bias_direction` by
+ * {@link PROBE_RECEIVER_BIAS} of the cascade's spacing, whose eight corners are the probes the point reads.
  *
  * ```wgsl
- * fn probe_clipmap_cage(cascade: u32, position: vec3<f32>, bias_direction: vec3<f32>, cage: ptr<function, vec3<i32>>) -> bool
- * fn probe_clipmap_biased(cascade: u32, position: vec3<f32>, bias_direction: vec3<f32>) -> vec3<f32>
+ * fn probe_clipmap_cage_in(levels: ptr<uniform, ClipmapLevelArray>, cascade: u32, position: vec3<f32>, bias_direction: vec3<f32>, cage: ptr<function, vec3<i32>>) -> bool
+ * fn probe_clipmap_biased_in(levels: ptr<uniform, ClipmapLevelArray>, cascade: u32, position: vec3<f32>, bias_direction: vec3<f32>) -> vec3<f32>
  * ```
  *
- * `probe_clipmap_cage` writes the cell's least corner and says whether the cascade's cage window holds
+ * `probe_clipmap_cage_in` writes the cell's least corner and says whether the cascade's cage window holds
  * it. Want takes it to choose the probes a pixel wants, and the pick to read them, so that a pixel reads
- * the probes it wanted.
+ * the probes it wanted. It binds nothing: a shader that reads two clipmaps passes each one's levels.
+ *
+ * @type {CodeChunk}
+ */
+export const chunk_probe_clipmap_cage_in: CodeChunk;
+/**
+ * {@link chunk_probe_clipmap_cage_in} over the clipmap a shader binds as `probe_levels`:
+ *
+ * ```wgsl
+ * fn probe_clipmap_cage(cascade: u32, position: vec3<f32>, bias_direction: vec3<f32>, cage: ptr<function, vec3<i32>>) -> bool
+ * fn probe_clipmap_biased(cascade: u32, position: vec3<f32>, bias_direction: vec3<f32>) -> vec3<f32>
+ * ```
  *
  * @type {CodeChunk}
  */

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

@@ -1 +1 @@
-{"version":3,"file":"chunk_probe_clipmap_cage.d.ts","sourceRoot":"","sources":["../../../../../../../src/shade/renderer/global_illumination/probe_clipmap/probe/chunk_probe_clipmap_cage.js"],"names":[],"mappings":"AAKA;;;;;;;;;;;;;;;GAeG;AACH,uCAFU,SAAS,CAkBhB;0BApCuB,uCAAuC"}
+{"version":3,"file":"chunk_probe_clipmap_cage.d.ts","sourceRoot":"","sources":["../../../../../../../src/shade/renderer/global_illumination/probe_clipmap/probe/chunk_probe_clipmap_cage.js"],"names":[],"mappings":"AAMA;;;;;;;;;;;;;;;GAeG;AACH,0CAFU,SAAS,CAmBhB;AAEH;;;;;;;;;GASG;AACH,uCAFU,SAAS,CAchB;0BA7DuB,uCAAuC"}

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

@@ -1,40 +1,66 @@
 import { chunk_clipmap_contains } from "../../../shader/chunk/clipmap/chunk_clipmap_contains.js";
+import { CLIPMAP_LEVEL_ARRAY, CLIPMAP_LEVEL_STRUCT } from "../../../shader/chunk/clipmap/CLIPMAP_LEVEL_STRUCT.js";
 import { CodeChunk } from "../../../shader/compiler/CodeChunk.js";
 import { PROBE_LEVELS_RESOURCE } from "./chunk_probe_clipmap.js";
 import { PROBE_RECEIVER_BIAS } from "./PROBE_CLIPMAP.js";
 
 /**
- * The cage of a cascade around a receiving point (PROBE_CLIPMAP_PROPOSAL_2026_10_27.md §8.3, §9.1): the
- * lattice cell holding the point moved along `bias_direction` by {@link PROBE_RECEIVER_BIAS} of the
- * cascade's spacing, whose eight corners are the probes the point reads.
+ * The cage of a cascade around a receiving point (PROBE_CLIPMAP_PROPOSAL_2026_10_27.md §8.3, §9.1), in the
+ * clipmap whose levels `levels` points at: the lattice cell holding the point moved along `bias_direction` by
+ * {@link PROBE_RECEIVER_BIAS} of the cascade's spacing, whose eight corners are the probes the point reads.
  *
  * ```wgsl
- * fn probe_clipmap_cage(cascade: u32, position: vec3<f32>, bias_direction: vec3<f32>, cage: ptr<function, vec3<i32>>) -> bool
- * fn probe_clipmap_biased(cascade: u32, position: vec3<f32>, bias_direction: vec3<f32>) -> vec3<f32>
+ * fn probe_clipmap_cage_in(levels: ptr<uniform, ClipmapLevelArray>, cascade: u32, position: vec3<f32>, bias_direction: vec3<f32>, cage: ptr<function, vec3<i32>>) -> bool
+ * fn probe_clipmap_biased_in(levels: ptr<uniform, ClipmapLevelArray>, cascade: u32, position: vec3<f32>, bias_direction: vec3<f32>) -> vec3<f32>
  * ```
  *
- * `probe_clipmap_cage` writes the cell's least corner and says whether the cascade's cage window holds
+ * `probe_clipmap_cage_in` writes the cell's least corner and says whether the cascade's cage window holds
  * it. Want takes it to choose the probes a pixel wants, and the pick to read them, so that a pixel reads
- * the probes it wanted.
+ * the probes it wanted. It binds nothing: a shader that reads two clipmaps passes each one's levels.
  *
  * @type {CodeChunk}
  */
-export const chunk_probe_clipmap_cage = CodeChunk.from(
+export const chunk_probe_clipmap_cage_in = CodeChunk.from(
     //language=WGSL
     `
-fn probe_clipmap_biased(cascade: u32, position: vec3<f32>, bias_direction: vec3<f32>) -> vec3<f32> {
-    return position + bias_direction * (${PROBE_RECEIVER_BIAS} * probe_levels[cascade].cell_size);
+fn probe_clipmap_biased_in(levels: ptr<uniform, ${CLIPMAP_LEVEL_ARRAY.wgsl_ref}>, cascade: u32, position: vec3<f32>, bias_direction: vec3<f32>) -> vec3<f32> {
+    return position + bias_direction * (${PROBE_RECEIVER_BIAS} * (*levels)[cascade].cell_size);
 }
 
-fn probe_clipmap_cage(cascade: u32, position: vec3<f32>, bias_direction: vec3<f32>, cage: ptr<function, vec3<i32>>) -> bool {
-    let level = probe_levels[cascade];
+fn probe_clipmap_cage_in(levels: ptr<uniform, ${CLIPMAP_LEVEL_ARRAY.wgsl_ref}>, cascade: u32, position: vec3<f32>, bias_direction: vec3<f32>, cage: ptr<function, vec3<i32>>) -> bool {
+    let level = (*levels)[cascade];
 
-    *cage = vec3<i32>(floor(probe_clipmap_biased(cascade, position, bias_direction) / level.cell_size));
+    *cage = vec3<i32>(floor(probe_clipmap_biased_in(levels, cascade, position, bias_direction) / level.cell_size));
 
     return clipmap_contains(*cage, level.corner, level.size);
 }
 `, [
+    CLIPMAP_LEVEL_STRUCT.declaration_chunk,
     chunk_clipmap_contains,
 ]);
 
+/**
+ * {@link chunk_probe_clipmap_cage_in} over the clipmap a shader binds as `probe_levels`:
+ *
+ * ```wgsl
+ * fn probe_clipmap_cage(cascade: u32, position: vec3<f32>, bias_direction: vec3<f32>, cage: ptr<function, vec3<i32>>) -> bool
+ * fn probe_clipmap_biased(cascade: u32, position: vec3<f32>, bias_direction: vec3<f32>) -> vec3<f32>
+ * ```
+ *
+ * @type {CodeChunk}
+ */
+export const chunk_probe_clipmap_cage = CodeChunk.from(
+    //language=WGSL
+    `
+fn probe_clipmap_biased(cascade: u32, position: vec3<f32>, bias_direction: vec3<f32>) -> vec3<f32> {
+    return probe_clipmap_biased_in(&probe_levels, cascade, position, bias_direction);
+}
+
+fn probe_clipmap_cage(cascade: u32, position: vec3<f32>, bias_direction: vec3<f32>, cage: ptr<function, vec3<i32>>) -> bool {
+    return probe_clipmap_cage_in(&probe_levels, cascade, position, bias_direction, cage);
+}
+`, [
+    chunk_probe_clipmap_cage_in,
+]);
+
 chunk_probe_clipmap_cage.requireResource(PROBE_LEVELS_RESOURCE);

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

@@ -25,15 +25,19 @@ export const PROBE_DEPTH_SAMPLER_DESCRIPTOR: SamplerDescriptor;
  */
 export const PROBE_DEPTH_SAMPLER_RESOURCE: ShaderResourceDescriptor;
 /**
- * A point's picked probes (PROBE_CLIPMAP_PROPOSAL_2026_10_27.md §9.1), and their SH (§9.2):
+ * A point's picked probes in one clipmap (PROBE_CLIPMAP_PROPOSAL_2026_10_27.md §9.1), and their SH (§9.2),
+ * the clipmap passed whole: its levels, shape, indirection, states and depth atlas to the pick, its records to
+ * the SH. It binds nothing but the depth's sampler, so a shader can pick from two clipmaps, as the bounce pass
+ * does (`shader_probe_clipmap_bounce`).
  *
  * ```wgsl
- * fn probe_clipmap_pick(position: vec3<f32>, normal: vec3<f32>, view_direction: vec3<f32>, noise: vec2<f32>) -> ProbeClipmapPick
- * fn probe_clipmap_sh_of(pick: ProbeClipmapPick) -> ProbeClipmapSH
- * fn probe_clipmap_sample_sh(position: vec3<f32>, normal: vec3<f32>, view_direction: vec3<f32>, noise: vec2<f32>) -> ProbeClipmapSH
+ * fn probe_clipmap_pick_in(levels: ptr<uniform, ClipmapLevelArray>, sampling: ptr<uniform, ProbeSampling>, indirection: texture_3d<u32>, states: ptr<storage, array<vec2<u32>>, read>, depth: texture_2d<f32>, position: vec3<f32>, normal: vec3<f32>, view_direction: vec3<f32>, noise: vec2<f32>) -> ProbeClipmapPick
+ * fn probe_clipmap_sh_in(records: ptr<storage, array<ProbeRecord>, read>, pick: ProbeClipmapPick) -> ProbeClipmapSH
+ * fn probe_clipmap_corner_slot_in(sampling, indirection, cascade: u32, point: vec3<i32>) -> u32
+ * fn probe_clipmap_depth_moments_in(sampling, depth, slot: u32, direction: vec3<f32>) -> vec2<f32>
  * ```
  *
- * - **The cage**: `probe_clipmap_cage` along mix(n, v, 0.2), as want takes it, so a pixel reads the
+ * - **The cage**: `probe_clipmap_cage_in` along mix(n, v, 0.2), as want takes it, so a pixel reads the
  *   probes it wanted.
  * - **The weights**, visibility only, of the cage's eight corners: a corner without an ALIVE probe weighs
  *   nothing; one with weighs its trilinear weight × `probe_visibility_weight`: the wrap back-face term
@@ -44,9 +48,8 @@ export const PROBE_DEPTH_SAMPLER_RESOURCE: ShaderResourceDescriptor;
  *   whose corners weigh nothing gives way to the next coarser, without a skirt. With none left the
  *   weights are zero, and the fallback is the caller's (§9.1, step 6).
  * - **The SH**: the picked records' Metro L1 structs mixed by their weights; resolved with
- *   `resolve_irradiance_sh_to_diffuse` at the caller's normal, it gives E/π. `probe_clipmap_sh_of` takes a
- *   pick already made, so a pass that samples the specular too picks once; `probe_clipmap_sample_sh` picks
- *   and takes it.
+ *   `resolve_irradiance_sh_to_diffuse` at the caller's normal, it gives E/π. `found` says whether any probe
+ *   weighed anything.
  *
  * Per cascade read: 8 indirection loads, 8 state words and 8 depth taps, then 2 indirection loads for
  * the pair; then two records a cascade read for the SH. A depth tile's place takes no integer division
@@ -54,6 +57,24 @@ export const PROBE_DEPTH_SAMPLER_RESOURCE: ShaderResourceDescriptor;
  *
  * @type {CodeChunk}
  */
+export const chunk_probe_clipmap_pick_in: CodeChunk;
+/**
+ * {@link chunk_probe_clipmap_pick_in} over the clipmap a shader binds under the probes' names, as every reader
+ * of the screen's probes does (§9.5):
+ *
+ * ```wgsl
+ * fn probe_clipmap_pick(position: vec3<f32>, normal: vec3<f32>, view_direction: vec3<f32>, noise: vec2<f32>) -> ProbeClipmapPick
+ * fn probe_clipmap_sh_of(pick: ProbeClipmapPick) -> ProbeClipmapSH
+ * fn probe_clipmap_sample_sh(position: vec3<f32>, normal: vec3<f32>, view_direction: vec3<f32>, noise: vec2<f32>) -> ProbeClipmapSH
+ * fn probe_clipmap_corner_slot(cascade: u32, point: vec3<i32>) -> u32
+ * fn probe_clipmap_depth_moments(slot: u32, direction: vec3<f32>) -> vec2<f32>
+ * ```
+ *
+ * `probe_clipmap_sh_of` takes a pick already made, so a pass that samples the specular too picks once;
+ * `probe_clipmap_sample_sh` picks and takes it.
+ *
+ * @type {CodeChunk}
+ */
 export const chunk_probe_clipmap_pick: CodeChunk;
 /**
  * What {@link chunk_probe_clipmap_pick} reads, as a group a reader of the probes adds to its shader (§9.5).

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

@@ -1 +1 @@
-{"version":3,"file":"chunk_probe_clipmap_pick.d.ts","sourceRoot":"","sources":["../../../../../../../src/shade/renderer/global_illumination/probe_clipmap/probe/chunk_probe_clipmap_pick.js"],"names":[],"mappings":"AAwBA;;;;GAIG;AACH,oCAFU,YAAY,CAuBF;AAEpB;;;GAGG;AACH,sCAFU,wBAAwB,CAE+E;AAEjH;;;GAGG;AACH,8CAFU,wBAAwB,CAEiF;AAEnH;;;GAGG;AACH,6CAFU,iBAAiB,CAQvB;AAEJ;;;GAGG;AACH,2CAFU,wBAAwB,CAE+G;AAEjJ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA6BG;AACH,uCAFU,SAAS,CA6MhB;AAUH;;;;;;;GAOG;AACH,2CAFU,6BAA6B,CAWG;6BA1Ub,sCAAsC;yCAH1B,sDAAsD;kCAT7D,qDAAqD;0BAQ7D,uCAAuC;8CAEnB,2DAA2D"}
+{"version":3,"file":"chunk_probe_clipmap_pick.d.ts","sourceRoot":"","sources":["../../../../../../../src/shade/renderer/global_illumination/probe_clipmap/probe/chunk_probe_clipmap_pick.js"],"names":[],"mappings":"AAgCA;;;;GAIG;AACH,oCAFU,YAAY,CAuBF;AAEpB;;;GAGG;AACH,sCAFU,wBAAwB,CAE+E;AAEjH;;;GAGG;AACH,8CAFU,wBAAwB,CAEiF;AAEnH;;;GAGG;AACH,6CAFU,iBAAiB,CAQvB;AAEJ;;;GAGG;AACH,2CAFU,wBAAwB,CAE+G;AAOjJ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAgCG;AACH,0CAFU,SAAS,CAyMhB;AAIH;;;;;;;;;;;;;;;;GAgBG;AACH,uCAFU,SAAS,CA0BhB;AASH;;;;;;;GAOG;AACH,2CAFU,6BAA6B,CAWG;6BA3Xb,sCAAsC;yCAH1B,sDAAsD;kCAhB7D,qDAAqD;0BAe7D,uCAAuC;8CAEnB,2DAA2D"}