@woosh/meep-engine 3.57.0 → 3.58.0

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

@@ -0,0 +1,232 @@
+/**
+ * A probe's record (PROBE_CLIPMAP_PROPOSAL_2026_10_27.md §8.2), 64 bytes a slot: where it is, when it
+ * 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}
+ */
+export const PROBE_RECORD_STRUCT: WebGPUStruct;
+/**
+ * A ray of a probe's update (PROBE_CLIPMAP_PROPOSAL_2026_10_27.md §8.6), 28 bytes, as trace writes it for
+ * the passes after it.
+ *
+ * @type {WebGPUStruct}
+ */
+export const PROBE_RAY_STRUCT: WebGPUStruct;
+/**
+ * The cascades' cage windows, a {@link CLIPMAP_LEVEL_ARRAY} as a uniform, finest first: a cell of
+ * cascade `c` is the cage of the eight lattice points at its corners, so its window is one short of the
+ * lattice's on each axis, and `clipmap_select_finest` over it answers the finest cascade whose whole
+ * cage holds a point (§8.1).
+ * @type {ShaderResourceDescriptor}
+ */
+export const PROBE_LEVELS_RESOURCE: ShaderResourceDescriptor;
+/**
+ * The indirection as the lifetime passes keep it: `r32uint`, a texel a lattice point in storage that
+ * wraps, the cascades stacked along z, a slot or {@link PROBE_CLIPMAP_NONE}.
+ * @type {ShaderResourceDescriptor}
+ */
+export const PROBE_INDIRECTION_STORE_RESOURCE: ShaderResourceDescriptor;
+/**
+ * The slots' states, two words each: kind and update count, then the relocation offset
+ * (`PROBE_CLIPMAP.js`).
+ * @type {ShaderResourceDescriptor}
+ */
+export const PROBE_STATES_STORE_RESOURCE: ShaderResourceDescriptor;
+/**
+ * The slots' states, as a pass that only reads them binds them.
+ * @type {ShaderResourceDescriptor}
+ */
+export const PROBE_STATES_READ_RESOURCE: ShaderResourceDescriptor;
+/**
+ * The slots' {@link PROBE_RECORD_STRUCT}s.
+ * @type {ShaderResourceDescriptor}
+ */
+export const PROBE_RECORDS_STORE_RESOURCE: ShaderResourceDescriptor;
+/**
+ * The slots' records, as a pass that only reads them binds them.
+ * @type {ShaderResourceDescriptor}
+ */
+export const PROBE_RECORDS_READ_RESOURCE: ShaderResourceDescriptor;
+/**
+ * The counters, every word an atomic (`PROBE_CLIPMAP.js`).
+ * @type {ShaderResourceDescriptor}
+ */
+export const PROBE_COUNTERS_RESOURCE: ShaderResourceDescriptor;
+/**
+ * The counters read plainly, by a pass after the one that wrote them: a word read as an atomic is a
+ * read-modify-write on D3D12.
+ * @type {ShaderResourceDescriptor}
+ */
+export const PROBE_COUNTERS_READ_RESOURCE: ShaderResourceDescriptor;
+/**
+ * The free slots, as a slot stack whose count is `probe_counters[PROBE_COUNTER_FREE]`.
+ * @type {ShaderResourceDescriptor}
+ */
+export const PROBE_FREE_RESOURCE: ShaderResourceDescriptor;
+/**
+ * The live probes' slots as retire reads them: the list the frame before wrote.
+ * @type {ShaderResourceDescriptor}
+ */
+export const PROBE_ACTIVE_READ_RESOURCE: ShaderResourceDescriptor;
+/**
+ * The live probes' slots as the frame lists them: retire's survivors, then admit's new probes.
+ * @type {ShaderResourceDescriptor}
+ */
+export const PROBE_ACTIVE_WRITE_RESOURCE: ShaderResourceDescriptor;
+/**
+ * The frame's live probes once its appends are done, read plainly by the passes after them.
+ * @type {ShaderResourceDescriptor}
+ */
+export const PROBE_ACTIVE_WRITTEN_RESOURCE: ShaderResourceDescriptor;
+/**
+ * A bit a key, set when a pixel of the frame wants the lattice point: cleared every frame.
+ * @type {ShaderResourceDescriptor}
+ */
+export const PROBE_WANTED_BITS_RESOURCE: ShaderResourceDescriptor;
+/**
+ * The wanted bits, read plainly once want has set them.
+ * @type {ShaderResourceDescriptor}
+ */
+export const PROBE_WANTED_BITS_READ_RESOURCE: ShaderResourceDescriptor;
+/**
+ * The probes the frame updates, as the due passes list them, at most U (§8.5).
+ * @type {ShaderResourceDescriptor}
+ */
+export const PROBE_TRACE_WRITE_RESOURCE: ShaderResourceDescriptor;
+/**
+ * The probes the frame updates, as the update's passes read them: a reader clamps the count to U.
+ * @type {ShaderResourceDescriptor}
+ */
+export const PROBE_TRACE_READ_RESOURCE: ShaderResourceDescriptor;
+/**
+ * The keys wanted this frame, each once, as want lists them.
+ * @type {ShaderResourceDescriptor}
+ */
+export const PROBE_WANTED_WRITE_RESOURCE: ShaderResourceDescriptor;
+/**
+ * The keys wanted this frame, as admit reads them.
+ * @type {ShaderResourceDescriptor}
+ */
+export const PROBE_WANTED_READ_RESOURCE: ShaderResourceDescriptor;
+/**
+ * The indirect commands, as the one-thread passes write them.
+ * @type {ShaderResourceDescriptor}
+ */
+export const PROBE_DISPATCH_RESOURCE: ShaderResourceDescriptor;
+/**
+ * The origins of the probes the frame updates, by their place in the trace list: the probe where
+ * relocation left it, and its spacing, `vec4<f32>(origin, spacing)`.
+ * @type {ShaderResourceDescriptor}
+ */
+export const PROBE_ORIGINS_WRITE_RESOURCE: ShaderResourceDescriptor;
+/**
+ * The origins, as the passes after relocation read them.
+ * @type {ShaderResourceDescriptor}
+ */
+export const PROBE_ORIGINS_READ_RESOURCE: ShaderResourceDescriptor;
+/**
+ * The frame's rays, R a listed probe, as trace writes them and shade rewrites their light.
+ * @type {ShaderResourceDescriptor}
+ */
+export const PROBE_RAYS_WRITE_RESOURCE: ShaderResourceDescriptor;
+/**
+ * The frame's rays, as the passes after trace read them.
+ * @type {ShaderResourceDescriptor}
+ */
+export const PROBE_RAYS_READ_RESOURCE: ShaderResourceDescriptor;
+/**
+ * The listed probes' maps, as accumulation writes them for projection and publish, in list order,
+ * `probe_clipmap_maps_words` a probe.
+ * @type {ShaderResourceDescriptor}
+ */
+export const PROBE_MAPS_WRITE_RESOURCE: ShaderResourceDescriptor;
+/**
+ * The listed probes' maps, as projection and publish read them.
+ * @type {ShaderResourceDescriptor}
+ */
+export const PROBE_MAPS_READ_RESOURCE: ShaderResourceDescriptor;
+/**
+ * A row of a listed probe's radiance map, projected: its irradiance SH, and its rays this update.
+ * @type {WebGPUStruct}
+ */
+export const PROBE_PROJECTION_ROW_STRUCT: WebGPUStruct;
+/**
+ * The listed probes' rows, n_r a probe, as the projection's rows write them.
+ * @type {ShaderResourceDescriptor}
+ */
+export const PROBE_PROJECTION_WRITE_RESOURCE: ShaderResourceDescriptor;
+/**
+ * The listed probes' rows, as the probes' projection sums them.
+ * @type {ShaderResourceDescriptor}
+ */
+export const PROBE_PROJECTION_READ_RESOURCE: ShaderResourceDescriptor;
+/**
+ * The radiance atlas, `rgba16float`, as its readers sample it: a tile a slot, a texel of skirt around
+ * each n_r² map, the texel's count of samples in alpha.
+ * @type {ShaderResourceDescriptor}
+ */
+export const PROBE_RADIANCE_HISTORY_RESOURCE: ShaderResourceDescriptor;
+/**
+ * The depth atlas, `rg16float`, as its readers sample it: a tile a slot, the moments of depth in
+ * spacings.
+ * @type {ShaderResourceDescriptor}
+ */
+export const PROBE_DEPTH_HISTORY_RESOURCE: ShaderResourceDescriptor;
+/**
+ * The radiance atlas, as publish stores into it.
+ * @type {ShaderResourceDescriptor}
+ */
+export const PROBE_RADIANCE_STORE_RESOURCE: ShaderResourceDescriptor;
+/**
+ * The depth atlas, as publish stores into it.
+ * @type {ShaderResourceDescriptor}
+ */
+export const PROBE_DEPTH_STORE_RESOURCE: ShaderResourceDescriptor;
+/**
+ * The probe clipmap's layout as WGSL constants, and what a key, a state word and a lattice point's
+ * place are.
+ *
+ * ```wgsl
+ * fn probe_clipmap_key(cascade: u32, storage: vec3<u32>, resolution: u32) -> u32
+ * fn probe_clipmap_key_cascade(key: u32, resolution: u32) -> u32
+ * fn probe_clipmap_key_storage(key: u32, resolution: u32) -> vec3<u32>
+ * fn probe_clipmap_indirection_texel(cascade: u32, storage: vec3<u32>, resolution: u32) -> vec3<u32>
+ * fn probe_clipmap_window_point(storage: vec3<u32>, corner: vec3<i32>, resolution: u32) -> vec3<i32> // the point a window holds there
+ * fn probe_state_kind(state: u32) -> u32 // of the state's first word
+ * fn probe_state_updates(state: u32) -> u32
+ * fn probe_state(kind: u32, updates: u32) -> u32
+ * fn probe_clipmap_offset_encode(offset: vec3<f32>, spacing: f32) -> u32 // the state's second word
+ * fn probe_clipmap_offset_decode(word: u32, spacing: f32) -> vec3<f32>
+ * fn probe_clipmap_maps_words(radiance_resolution: u32, depth_resolution: u32) -> u32 // a listed probe's, in probe_maps
+ * ```
+ *
+ * The offset's fields are of `PROBE_RELOCATION_LIMIT` of the spacing, 511 steps each way: under a
+ * thousandth of the spacing apart, and zero at the lattice point.
+ *
+ * @type {CodeChunk}
+ */
+export const chunk_probe_clipmap: CodeChunk;
+/**
+ * Which octahedral radiance texel a ray of an update is, and the way back (§8.6). An update casts R rays
+ * over the n_r² texels:
+ * - with R at least the texels, ray `i` is texel `i mod n_r²`, its `⌊i / n_r²⌋`-th ray;
+ * - below them, ray `i` of update `u` is texel `(u·R + i) mod n_r²` under the bit reversal of the
+ *   texels' indices, so that each run of n_r²/R updates covers every texel once, and each update's
+ *   texels spread over the sphere. The pattern repeats every n_r²/R updates, which keeps the product
+ *   in range.
+ *
+ * Both R and n_r² are powers of two.
+ *
+ * ```wgsl
+ * fn probe_clipmap_ray_texel(ray: u32, updates: u32, rays: u32, texels: u32) -> u32
+ * fn probe_clipmap_texel_ray(texel: u32, round: u32, updates: u32, rays: u32, texels: u32) -> u32 // its round-th ray, or PROBE_CLIPMAP_NONE
+ * ```
+ *
+ * @type {CodeChunk}
+ */
+export const chunk_probe_clipmap_ray_texel: CodeChunk;
+import { WebGPUStruct } from "../../../shader/type/WebGPUStruct.js";
+import { ShaderResourceDescriptor } from "../../../shader/resource/ShaderResourceDescriptor.js";
+import { CodeChunk } from "../../../shader/compiler/CodeChunk.js";
+//# sourceMappingURL=chunk_probe_clipmap.d.ts.map

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

@@ -0,0 +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":"AAoCA;;;;;;GAMG;AACH,kCAFU,YAAY,CAcJ;AAElB;;;;;GAKG;AACH,+BAFU,YAAY,CAqBP;AAEf;;;;;;GAMG;AACH,oCAFU,wBAAwB,CAEyE;AAE3G;;;;GAIG;AACH,+CAFU,wBAAwB,CAE0G;AAE5I;;;;GAIG;AACH,0CAFU,wBAAwB,CAE+F;AAEjI;;;GAGG;AACH,yCAFU,wBAAwB,CAEwF;AAE1H;;;GAGG;AACH,2CAFU,wBAAwB,CAE+G;AAEjJ;;;GAGG;AACH,0CAFU,wBAAwB,CAEwG;AAE1I;;;GAGG;AACH,sCAFU,wBAAwB,CAEkG;AAEpI;;;;GAIG;AACH,2CAFU,wBAAwB,CAEoF;AAEtH;;;GAGG;AACH,kCAFU,wBAAwB,CAE6E;AAE/G;;;GAGG;AACH,yCAFU,wBAAwB,CAEgG;AAElI;;;GAGG;AACH,0CAFU,wBAAwB,CAEyG;AAE3I;;;GAGG;AACH,4CAFU,wBAAwB,CAEoG;AAEtI;;;GAGG;AACH,yCAFU,wBAAwB,CAEwG;AAE1I;;;GAGG;AACH,8CAFU,wBAAwB,CAE0F;AAE5H;;;GAGG;AACH,yCAFU,wBAAwB,CAEiG;AAEnI;;;GAGG;AACH,wCAFU,wBAAwB,CAEyF;AAE3H;;;GAGG;AACH,0CAFU,wBAAwB,CAEmG;AAErI;;;GAGG;AACH,yCAFU,wBAAwB,CAE2F;AAE7H;;;GAGG;AACH,sCAFU,wBAAwB,CAEqF;AAEvH;;;;GAIG;AACH,2CAFU,wBAAwB,CAEiG;AAEnI;;;GAGG;AACH,0CAFU,wBAAwB,CAE0F;AAE5H;;;GAGG;AACH,wCAFU,wBAAwB,CAEsG;AAExI;;;GAGG;AACH,uCAFU,wBAAwB,CAE+F;AAEjI;;;;GAIG;AACH,wCAFU,wBAAwB,CAEmF;AAErH;;;GAGG;AACH,uCAFU,wBAAwB,CAE4E;AAE9G;;;GAGG;AACH,0CAFU,YAAY,CAQG;AAEzB;;;GAGG;AACH,8CAFU,wBAAwB,CAE6H;AAE/J;;;GAGG;AACH,6CAFU,wBAAwB,CAEsH;AAExJ;;;;GAIG;AACH,8CAFU,wBAAwB,CAE+E;AAEjH;;;;GAIG;AACH,2CAFU,wBAAwB,CAEyE;AAE3G;;;GAGG;AACH,4CAFU,wBAAwB,CAEwG;AAE1I;;;GAGG;AACH,yCAFU,wBAAwB,CAEgG;AAElI;;;;;;;;;;;;;;;;;;;;;;GAsBG;AACH,kCAFU,SAAS,CAqFhB;AAEH;;;;;;;;;;;;;;;;;GAiBG;AACH,4CAFU,SAAS,CA+BhB;6BAtb0B,sCAAsC;yCAH1B,sDAAsD;0BADrE,uCAAuC"}

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

@@ -0,0 +1,448 @@
+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 { CLIPMAP_LEVEL_ARRAY } from "../../../shader/chunk/clipmap/CLIPMAP_LEVEL_STRUCT.js";
+import { chunk_mod_v3i } from "../../../shader/chunk/geometry/vec3/chunk_mod_v3i.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, vec4f } from "../../../shader/type/WEBGPU_WGSL_PRIMITIVE_TYPES.js";
+import { WebGPUArray } from "../../../shader/type/WebGPUArray.js";
+import { WebGPUStruct } from "../../../shader/type/WebGPUStruct.js";
+import {
+    PROBE_BLEND_SKIRT,
+    PROBE_CLIPMAP_NONE,
+    PROBE_COUNTER_FREE,
+    PROBE_COUNTER_PERIOD,
+    PROBE_COUNTER_STARVED,
+    PROBE_DISPATCH_ACTIVE,
+    PROBE_DISPATCH_ADMIT,
+    PROBE_DISPATCH_PUBLISH,
+    PROBE_DISPATCH_RAYS,
+    PROBE_DISPATCH_ROWS,
+    PROBE_DISPATCH_TEXELS,
+    PROBE_DISPATCH_TRACED,
+    PROBE_RAY_BACK_FACE,
+    PROBE_RAY_CASCADE_SHIFT,
+    PROBE_RAY_KIND_MASK,
+    PROBE_RELOCATION_LIMIT,
+    PROBE_STATE_ALIVE,
+    PROBE_STATE_DEAD,
+    PROBE_STATE_FREE,
+    PROBE_STATE_KIND_MASK,
+    PROBE_STATE_NEW,
+    PROBE_STATE_UPDATES_SHIFT,
+    PROBE_THREAD_WORKGROUP_SIZE
+} from "./PROBE_CLIPMAP.js";
+
+/**
+ * A probe's record (PROBE_CLIPMAP_PROPOSAL_2026_10_27.md §8.2), 64 bytes a slot: where it is, when it
+ * 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}
+ */
+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,
+    cascade: u32,
+    /** when a pixel last wanted it: seconds since the clipmap was made */
+    wanted_time: f32,
+    /** when it was last updated, on the same clock */
+    traced_time: f32,
+    /** the share of its last update's resolved rays that hit back faces (§8.4) */
+    back_face: f32,
+    /** the irradiance its rays saw, the Metro L1 encoding: luma as SH2, chroma constant */
+    sh: METRO_L1_IRRADIANCE_STRUCT,
+}, "ProbeRecord");
+
+/**
+ * A ray of a probe's update (PROBE_CLIPMAP_PROPOSAL_2026_10_27.md §8.6), 28 bytes, as trace writes it for
+ * the passes after it.
+ *
+ * @type {WebGPUStruct}
+ */
+export const PROBE_RAY_STRUCT = WebGPUStruct.from({
+    /** how far the ray went: to its hit, or where its march stopped */
+    t: f32,
+    /** its direction, octahedral, two unorm16 */
+    direction: u32,
+    /** the hit's normal, octahedral, two unorm16; zero but for a hit */
+    normal: u32,
+    /** the `meshes` row whose surface the hit is on, 0 for none */
+    row: u32,
+    /** its kind, the back face, and the hit's cascade (`PROBE_CLIPMAP.js`) */
+    flags: u32,
+    /**
+     * The light, three half floats, red and green here and blue in {@link light_b}'s low half. Trace
+     * writes the direct irradiance at a front-face hit, E_dir (§8.7), zero for any other ray; shade
+     * writes over it the radiance the ray brings back.
+     */
+    light_rg: u32,
+    /** the light's blue, a half float in the low half */
+    light_b: u32,
+}, "ProbeRay");
+
+/**
+ * The cascades' cage windows, a {@link CLIPMAP_LEVEL_ARRAY} as a uniform, finest first: a cell of
+ * cascade `c` is the cage of the eight lattice points at its corners, so its window is one short of the
+ * lattice's on each axis, and `clipmap_select_finest` over it answers the finest cascade whose whole
+ * cage holds a point (§8.1).
+ * @type {ShaderResourceDescriptor}
+ */
+export const PROBE_LEVELS_RESOURCE = ShaderResourceDescriptor.uniform("probe_levels", CLIPMAP_LEVEL_ARRAY);
+
+/**
+ * The indirection as the lifetime passes keep it: `r32uint`, a texel a lattice point in storage that
+ * wraps, the cascades stacked along z, a slot or {@link PROBE_CLIPMAP_NONE}.
+ * @type {ShaderResourceDescriptor}
+ */
+export const PROBE_INDIRECTION_STORE_RESOURCE = ShaderResourceDescriptor.storageTexture("probe_indirection", "r32uint", "3d", "read-write");
+
+/**
+ * The slots' states, two words each: kind and update count, then the relocation offset
+ * (`PROBE_CLIPMAP.js`).
+ * @type {ShaderResourceDescriptor}
+ */
+export const PROBE_STATES_STORE_RESOURCE = ShaderResourceDescriptor.storageBuffer("probe_states", WebGPUArray.from(vec2u), true);
+
+/**
+ * The slots' states, as a pass that only reads them binds them.
+ * @type {ShaderResourceDescriptor}
+ */
+export const PROBE_STATES_READ_RESOURCE = ShaderResourceDescriptor.storageBuffer("probe_states", WebGPUArray.from(vec2u));
+
+/**
+ * The slots' {@link PROBE_RECORD_STRUCT}s.
+ * @type {ShaderResourceDescriptor}
+ */
+export const PROBE_RECORDS_STORE_RESOURCE = ShaderResourceDescriptor.storageBuffer("probe_records", WebGPUArray.from(PROBE_RECORD_STRUCT), true);
+
+/**
+ * The slots' records, as a pass that only reads them binds them.
+ * @type {ShaderResourceDescriptor}
+ */
+export const PROBE_RECORDS_READ_RESOURCE = ShaderResourceDescriptor.storageBuffer("probe_records", WebGPUArray.from(PROBE_RECORD_STRUCT));
+
+/**
+ * The counters, every word an atomic (`PROBE_CLIPMAP.js`).
+ * @type {ShaderResourceDescriptor}
+ */
+export const PROBE_COUNTERS_RESOURCE = ShaderResourceDescriptor.storageBuffer("probe_counters", WebGPUArray.from(atomic_u32), true);
+
+/**
+ * The counters read plainly, by a pass after the one that wrote them: a word read as an atomic is a
+ * read-modify-write on D3D12.
+ * @type {ShaderResourceDescriptor}
+ */
+export const PROBE_COUNTERS_READ_RESOURCE = ShaderResourceDescriptor.storageBuffer("probe_counters", WebGPUArray.u32);
+
+/**
+ * The free slots, as a slot stack whose count is `probe_counters[PROBE_COUNTER_FREE]`.
+ * @type {ShaderResourceDescriptor}
+ */
+export const PROBE_FREE_RESOURCE = ShaderResourceDescriptor.storageBuffer("probe_free", WebGPUArray.u32, true);
+
+/**
+ * The live probes' slots as retire reads them: the list the frame before wrote.
+ * @type {ShaderResourceDescriptor}
+ */
+export const PROBE_ACTIVE_READ_RESOURCE = ShaderResourceDescriptor.storageBuffer("probe_active_read", COLLECTION_U32_STRUCT_READ);
+
+/**
+ * The live probes' slots as the frame lists them: retire's survivors, then admit's new probes.
+ * @type {ShaderResourceDescriptor}
+ */
+export const PROBE_ACTIVE_WRITE_RESOURCE = ShaderResourceDescriptor.storageBuffer("probe_active_write", COLLECTION_U32_STRUCT_WRITE, true);
+
+/**
+ * The frame's live probes once its appends are done, read plainly by the passes after them.
+ * @type {ShaderResourceDescriptor}
+ */
+export const PROBE_ACTIVE_WRITTEN_RESOURCE = ShaderResourceDescriptor.storageBuffer("probe_active_write", COLLECTION_U32_STRUCT_READ);
+
+/**
+ * A bit a key, set when a pixel of the frame wants the lattice point: cleared every frame.
+ * @type {ShaderResourceDescriptor}
+ */
+export const PROBE_WANTED_BITS_RESOURCE = ShaderResourceDescriptor.storageBuffer("probe_wanted_bits", WebGPUArray.from(atomic_u32), true);
+
+/**
+ * The wanted bits, read plainly once want has set them.
+ * @type {ShaderResourceDescriptor}
+ */
+export const PROBE_WANTED_BITS_READ_RESOURCE = ShaderResourceDescriptor.storageBuffer("probe_wanted_bits", WebGPUArray.u32);
+
+/**
+ * The probes the frame updates, as the due passes list them, at most U (§8.5).
+ * @type {ShaderResourceDescriptor}
+ */
+export const PROBE_TRACE_WRITE_RESOURCE = ShaderResourceDescriptor.storageBuffer("probe_trace", COLLECTION_U32_STRUCT_WRITE, true);
+
+/**
+ * The probes the frame updates, as the update's passes read them: a reader clamps the count to U.
+ * @type {ShaderResourceDescriptor}
+ */
+export const PROBE_TRACE_READ_RESOURCE = ShaderResourceDescriptor.storageBuffer("probe_trace", COLLECTION_U32_STRUCT_READ);
+
+/**
+ * The keys wanted this frame, each once, as want lists them.
+ * @type {ShaderResourceDescriptor}
+ */
+export const PROBE_WANTED_WRITE_RESOURCE = ShaderResourceDescriptor.storageBuffer("probe_wanted", COLLECTION_U32_STRUCT_WRITE, true);
+
+/**
+ * The keys wanted this frame, as admit reads them.
+ * @type {ShaderResourceDescriptor}
+ */
+export const PROBE_WANTED_READ_RESOURCE = ShaderResourceDescriptor.storageBuffer("probe_wanted", COLLECTION_U32_STRUCT_READ);
+
+/**
+ * The indirect commands, as the one-thread passes write them.
+ * @type {ShaderResourceDescriptor}
+ */
+export const PROBE_DISPATCH_RESOURCE = ShaderResourceDescriptor.storageBuffer("probe_dispatch", WebGPUArray.u32, true);
+
+/**
+ * The origins of the probes the frame updates, by their place in the trace list: the probe where
+ * relocation left it, and its spacing, `vec4<f32>(origin, spacing)`.
+ * @type {ShaderResourceDescriptor}
+ */
+export const PROBE_ORIGINS_WRITE_RESOURCE = ShaderResourceDescriptor.storageBuffer("probe_origins", WebGPUArray.from(vec4f), true);
+
+/**
+ * The origins, as the passes after relocation read them.
+ * @type {ShaderResourceDescriptor}
+ */
+export const PROBE_ORIGINS_READ_RESOURCE = ShaderResourceDescriptor.storageBuffer("probe_origins", WebGPUArray.from(vec4f));
+
+/**
+ * The frame's rays, R a listed probe, as trace writes them and shade rewrites their light.
+ * @type {ShaderResourceDescriptor}
+ */
+export const PROBE_RAYS_WRITE_RESOURCE = ShaderResourceDescriptor.storageBuffer("probe_rays", WebGPUArray.from(PROBE_RAY_STRUCT), true);
+
+/**
+ * The frame's rays, as the passes after trace read them.
+ * @type {ShaderResourceDescriptor}
+ */
+export const PROBE_RAYS_READ_RESOURCE = ShaderResourceDescriptor.storageBuffer("probe_rays", WebGPUArray.from(PROBE_RAY_STRUCT));
+
+/**
+ * The listed probes' maps, as accumulation writes them for projection and publish, in list order,
+ * `probe_clipmap_maps_words` a probe.
+ * @type {ShaderResourceDescriptor}
+ */
+export const PROBE_MAPS_WRITE_RESOURCE = ShaderResourceDescriptor.storageBuffer("probe_maps", WebGPUArray.u32, true);
+
+/**
+ * The listed probes' maps, as projection and publish read them.
+ * @type {ShaderResourceDescriptor}
+ */
+export const PROBE_MAPS_READ_RESOURCE = ShaderResourceDescriptor.storageBuffer("probe_maps", WebGPUArray.u32);
+
+/**
+ * A row of a listed probe's radiance map, projected: its irradiance SH, and its rays this update.
+ * @type {WebGPUStruct}
+ */
+export const PROBE_PROJECTION_ROW_STRUCT = WebGPUStruct.from({
+    sh: METRO_L1_IRRADIANCE_STRUCT,
+    /** the update's rays that resolved, a back face's among them */
+    resolved: u32,
+    /** of them, the back faces */
+    back_faces: u32,
+}, "ProbeProjectionRow");
+
+/**
+ * The listed probes' rows, n_r a probe, as the projection's rows write them.
+ * @type {ShaderResourceDescriptor}
+ */
+export const PROBE_PROJECTION_WRITE_RESOURCE = ShaderResourceDescriptor.storageBuffer("probe_projection", WebGPUArray.from(PROBE_PROJECTION_ROW_STRUCT), true);
+
+/**
+ * The listed probes' rows, as the probes' projection sums them.
+ * @type {ShaderResourceDescriptor}
+ */
+export const PROBE_PROJECTION_READ_RESOURCE = ShaderResourceDescriptor.storageBuffer("probe_projection", WebGPUArray.from(PROBE_PROJECTION_ROW_STRUCT));
+
+/**
+ * The radiance atlas, `rgba16float`, as its readers sample it: a tile a slot, a texel of skirt around
+ * each n_r² map, the texel's count of samples in alpha.
+ * @type {ShaderResourceDescriptor}
+ */
+export const PROBE_RADIANCE_HISTORY_RESOURCE = ShaderResourceDescriptor.texture("probe_radiance", "float", "2d");
+
+/**
+ * The depth atlas, `rg16float`, as its readers sample it: a tile a slot, the moments of depth in
+ * spacings.
+ * @type {ShaderResourceDescriptor}
+ */
+export const PROBE_DEPTH_HISTORY_RESOURCE = ShaderResourceDescriptor.texture("probe_depth", "float", "2d");
+
+/**
+ * The radiance atlas, as publish stores into it.
+ * @type {ShaderResourceDescriptor}
+ */
+export const PROBE_RADIANCE_STORE_RESOURCE = ShaderResourceDescriptor.storageTexture("probe_radiance", "rgba16float", "2d", "write-only");
+
+/**
+ * The depth atlas, as publish stores into it.
+ * @type {ShaderResourceDescriptor}
+ */
+export const PROBE_DEPTH_STORE_RESOURCE = ShaderResourceDescriptor.storageTexture("probe_depth", "rg16float", "2d", "write-only");
+
+/**
+ * The probe clipmap's layout as WGSL constants, and what a key, a state word and a lattice point's
+ * place are.
+ *
+ * ```wgsl
+ * fn probe_clipmap_key(cascade: u32, storage: vec3<u32>, resolution: u32) -> u32
+ * fn probe_clipmap_key_cascade(key: u32, resolution: u32) -> u32
+ * fn probe_clipmap_key_storage(key: u32, resolution: u32) -> vec3<u32>
+ * fn probe_clipmap_indirection_texel(cascade: u32, storage: vec3<u32>, resolution: u32) -> vec3<u32>
+ * fn probe_clipmap_window_point(storage: vec3<u32>, corner: vec3<i32>, resolution: u32) -> vec3<i32> // the point a window holds there
+ * fn probe_state_kind(state: u32) -> u32 // of the state's first word
+ * fn probe_state_updates(state: u32) -> u32
+ * fn probe_state(kind: u32, updates: u32) -> u32
+ * fn probe_clipmap_offset_encode(offset: vec3<f32>, spacing: f32) -> u32 // the state's second word
+ * fn probe_clipmap_offset_decode(word: u32, spacing: f32) -> vec3<f32>
+ * fn probe_clipmap_maps_words(radiance_resolution: u32, depth_resolution: u32) -> u32 // a listed probe's, in probe_maps
+ * ```
+ *
+ * The offset's fields are of `PROBE_RELOCATION_LIMIT` of the spacing, 511 steps each way: under a
+ * thousandth of the spacing apart, and zero at the lattice point.
+ *
+ * @type {CodeChunk}
+ */
+export const chunk_probe_clipmap = CodeChunk.from(
+    //language=WGSL
+    `
+const PROBE_CLIPMAP_NONE = ${PROBE_CLIPMAP_NONE}u;
+
+const PROBE_STATE_FREE = ${PROBE_STATE_FREE}u;
+const PROBE_STATE_NEW = ${PROBE_STATE_NEW}u;
+const PROBE_STATE_ALIVE = ${PROBE_STATE_ALIVE}u;
+const PROBE_STATE_DEAD = ${PROBE_STATE_DEAD}u;
+
+const PROBE_COUNTER_FREE = ${PROBE_COUNTER_FREE}u;
+const PROBE_COUNTER_STARVED = ${PROBE_COUNTER_STARVED}u;
+const PROBE_COUNTER_PERIOD = ${PROBE_COUNTER_PERIOD}u;
+
+const PROBE_DISPATCH_ACTIVE = ${PROBE_DISPATCH_ACTIVE}u;
+const PROBE_DISPATCH_ADMIT = ${PROBE_DISPATCH_ADMIT}u;
+const PROBE_DISPATCH_TRACED = ${PROBE_DISPATCH_TRACED}u;
+const PROBE_DISPATCH_RAYS = ${PROBE_DISPATCH_RAYS}u;
+const PROBE_DISPATCH_TEXELS = ${PROBE_DISPATCH_TEXELS}u;
+const PROBE_DISPATCH_ROWS = ${PROBE_DISPATCH_ROWS}u;
+const PROBE_DISPATCH_PUBLISH = ${PROBE_DISPATCH_PUBLISH}u;
+
+const PROBE_RAY_KIND_MASK = ${PROBE_RAY_KIND_MASK}u;
+const PROBE_RAY_BACK_FACE = ${PROBE_RAY_BACK_FACE}u;
+const PROBE_RAY_CASCADE_SHIFT = ${PROBE_RAY_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;
+}
+
+fn probe_clipmap_key_cascade(key: u32, resolution: u32) -> u32 {
+    return key / (resolution * resolution * resolution);
+}
+
+fn probe_clipmap_key_storage(key: u32, resolution: u32) -> vec3<u32> {
+    return vec3<u32>(key % resolution, (key / resolution) % resolution, (key / (resolution * resolution)) % 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);
+}
+
+fn probe_clipmap_window_point(storage: vec3<u32>, corner: vec3<i32>, resolution: u32) -> vec3<i32> {
+    let n = vec3<i32>(i32(resolution));
+
+    return corner + mod_v3i(vec3<i32>(storage) - corner, n);
+}
+
+fn probe_state_kind(state: u32) -> u32 {
+    return state & ${PROBE_STATE_KIND_MASK}u;
+}
+
+fn probe_state_updates(state: u32) -> u32 {
+    return state >> ${PROBE_STATE_UPDATES_SHIFT}u;
+}
+
+fn probe_state(kind: u32, updates: u32) -> u32 {
+    return kind | (updates << ${PROBE_STATE_UPDATES_SHIFT}u);
+}
+
+fn probe_clipmap_maps_words(radiance_resolution: u32, depth_resolution: u32) -> u32 {
+    return 3u * radiance_resolution * radiance_resolution + depth_resolution * depth_resolution;
+}
+
+fn probe_clipmap_offset_encode(offset: vec3<f32>, spacing: f32) -> u32 {
+    let steps = vec3<i32>(round(clamp(offset / (${PROBE_RELOCATION_LIMIT} * spacing), vec3<f32>(-1.0), vec3<f32>(1.0)) * 511.0));
+    let fields = vec3<u32>(steps) & vec3<u32>(1023u);
+
+    return fields.x | (fields.y << 10u) | (fields.z << 20u);
+}
+
+fn probe_clipmap_offset_decode(word: u32, spacing: f32) -> vec3<f32> {
+    let signed = i32(word);
+    let steps = vec3<i32>(extractBits(signed, 0u, 10u), extractBits(signed, 10u, 10u), extractBits(signed, 20u, 10u));
+
+    return vec3<f32>(steps) * (${PROBE_RELOCATION_LIMIT} * spacing / 511.0);
+}
+`, [
+    PROBE_RECORD_STRUCT.declaration_chunk,
+    chunk_mod_v3i,
+]);
+
+/**
+ * Which octahedral radiance texel a ray of an update is, and the way back (§8.6). An update casts R rays
+ * over the n_r² texels:
+ * - with R at least the texels, ray `i` is texel `i mod n_r²`, its `⌊i / n_r²⌋`-th ray;
+ * - below them, ray `i` of update `u` is texel `(u·R + i) mod n_r²` under the bit reversal of the
+ *   texels' indices, so that each run of n_r²/R updates covers every texel once, and each update's
+ *   texels spread over the sphere. The pattern repeats every n_r²/R updates, which keeps the product
+ *   in range.
+ *
+ * Both R and n_r² are powers of two.
+ *
+ * ```wgsl
+ * fn probe_clipmap_ray_texel(ray: u32, updates: u32, rays: u32, texels: u32) -> u32
+ * fn probe_clipmap_texel_ray(texel: u32, round: u32, updates: u32, rays: u32, texels: u32) -> u32 // its round-th ray, or PROBE_CLIPMAP_NONE
+ * ```
+ *
+ * @type {CodeChunk}
+ */
+export const chunk_probe_clipmap_ray_texel = CodeChunk.from(
+    //language=WGSL
+    `
+fn probe_clipmap_ray_reverse(index: u32, texels: u32) -> u32 {
+    return reverseBits(index) >> (32u - countTrailingZeros(texels));
+}
+
+fn probe_clipmap_ray_texel(ray: u32, updates: u32, rays: u32, texels: u32) -> u32 {
+    if (rays >= texels) {
+        return ray % texels;
+    }
+
+    let first = (updates % (texels / rays)) * rays;
+
+    return probe_clipmap_ray_reverse((first + ray) % texels, texels);
+}
+
+fn probe_clipmap_texel_ray(texel: u32, round: u32, updates: u32, rays: u32, texels: u32) -> u32 {
+    if (rays >= texels) {
+        return select(PROBE_CLIPMAP_NONE, round * texels + texel, round < rays / texels);
+    }
+
+    let first = (updates % (texels / rays)) * rays;
+    let ray = (probe_clipmap_ray_reverse(texel, texels) + texels - first) % texels;
+
+    return select(PROBE_CLIPMAP_NONE, ray, round == 0u && ray < rays);
+}
+`, [
+    chunk_probe_clipmap,
+]);