@woosh/meep-engine 3.58.0 → 3.59.0

package/src/shade/renderer/global_illumination/probe_clipmap/brick/vgeo/shader_vgeo_brick_wait.js

@@ -0,0 +1,135 @@
+import { chunk_vgeo_cut_arena } from "../../../../geometry/virtual/runtime/cut/chunk_vgeo_cut_arena.js";
+import { chunk_vgeo_cut_want } from "../../../../geometry/virtual/runtime/cut/chunk_vgeo_cut_want.js";
+import { VGEO_CUT_PARAMS_STRUCT } from "../../../../geometry/virtual/runtime/cut/VGEO_CUT_PARAMS_STRUCT.js";
+import { VGEO_PAGE_ROW_NONE } from "../../../../geometry/virtual/runtime/layout/VGEO_PAGE_ROW_NONE.js";
+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_folded_workgroup_index } from "../../../../shader/chunk/grid/chunk_folded_workgroup_index.js";
+import { CodeChunk } from "../../../../shader/compiler/CodeChunk.js";
+import { ComputeShader } from "../../../../shader/ComputeShader.js";
+import { ShaderResourceSetDescriptor } from "../../../../shader/resource/ShaderResourceSetDescriptor.js";
+import { atomic_u32, u32 } from "../../../../shader/type/WEBGPU_WGSL_PRIMITIVE_TYPES.js";
+import { WebGPUArray } from "../../../../shader/type/WebGPUArray.js";
+import {
+    BRICK_PENDING_RESOURCE,
+    BRICK_RING_RESOURCE,
+    BRICK_STATE_RESOURCE,
+    chunk_brick_clipmap,
+    chunk_brick_clipmap_enqueue
+} from "../chunk_brick_clipmap.js";
+import { VGEO_BRICK_SETTINGS, VGEO_BRICK_WAIT_OFFSET, VGEO_BRICK_WAIT_WORDS } from "./VGEO_BRICK.js";
+
+/**
+ * Lanes of the wait: a waiting cell each.
+ * @type {number}
+ */
+export const VGEO_BRICK_WAIT_WORKGROUP_SIZE = 64;
+
+const resources = new ShaderResourceSetDescriptor();
+
+resources.setImmediate("settings", VGEO_BRICK_SETTINGS);
+
+resources.createGroup()
+    .addUniform("params", VGEO_CUT_PARAMS_STRUCT)
+    .addStorageBuffer("vg_lookup", WebGPUArray.from(u32))
+    .addStorageBuffer("vg_arena", WebGPUArray.from(u32))
+    // the frame's feedback, where the provider's cut's slot takes the wants, and the frame's want stamps
+    .addStorageBuffer("feedback", WebGPUArray.from(atomic_u32), true)
+    .addStorageBuffer("vg_want_stamps", WebGPUArray.from(atomic_u32), true);
+
+resources.createGroup()
+    // the cells the last frame left waiting, and the list this frame's leaves
+    .addStorageBuffer("vgeo_brick_waiting_in", COLLECTION_U32_STRUCT_READ)
+    .addStorageBuffer("vgeo_brick_waiting", COLLECTION_U32_STRUCT_WRITE, true);
+
+resources.createGroup()
+    .add(BRICK_STATE_RESOURCE)
+    .add(BRICK_RING_RESOURCE)
+    .add(BRICK_PENDING_RESOURCE);
+
+const body = CodeChunk.from(
+    //language=WGSL
+    `
+const VG_PAGE_ROW_NONE = ${VGEO_PAGE_ROW_NONE}u;
+const VGEO_BRICK_WAIT_WORDS = ${VGEO_BRICK_WAIT_WORDS}u;
+
+@compute @workgroup_size(${VGEO_BRICK_WAIT_WORKGROUP_SIZE})
+fn main(
+    @builtin(workgroup_id) workgroup_id: vec3<u32>,
+    @builtin(local_invocation_index) lane: u32,
+) {
+    let i = folded_workgroup_index(workgroup_id) * ${VGEO_BRICK_WAIT_WORKGROUP_SIZE}u + lane;
+
+    // the list's count runs past what it holds
+    if (i >= min(vgeo_brick_waiting_in.count, settings.wait_capacity)) {
+        return;
+    }
+
+    let at = VGEO_BRICK_WAIT_WORDS * i;
+    let key = vgeo_brick_waiting_in.elements[at + ${VGEO_BRICK_WAIT_OFFSET.KEY}u];
+    let lookup = vgeo_brick_waiting_in.elements[at + ${VGEO_BRICK_WAIT_OFFSET.LOOKUP}u];
+    let page = vgeo_brick_waiting_in.elements[at + ${VGEO_BRICK_WAIT_OFFSET.PAGE}u];
+    let group = vgeo_brick_waiting_in.elements[at + ${VGEO_BRICK_WAIT_OFFSET.GROUP}u];
+
+    let row = vg_lookup[lookup + page];
+
+    // the page is resident and the group drawable: the cell is built again, whatever its storage cell holds then
+    if (row != VG_PAGE_ROW_NONE && vg_group_selectable(row, group)) {
+        brick_clipmap_enqueue(key, settings.ring_capacity);
+        return;
+    }
+
+    if (row == VG_PAGE_ROW_NONE) {
+        let source = vgeo_brick_waiting_in.elements[at + ${VGEO_BRICK_WAIT_OFFSET.SOURCE}u];
+
+        // the page it was found through has gone too: the cell is built again, and its cut finds the way down anew
+        if (vg_lookup[lookup + vgeo_brick_waiting_in.elements[at + ${VGEO_BRICK_WAIT_OFFSET.SOURCE_PAGE}u]] != source) {
+            brick_clipmap_enqueue(key, settings.ring_capacity);
+            return;
+        }
+
+        // a want lasts the reading it is in: the page is wanted again each frame the cell waits on it, as the camera
+        // cut wants its pages again each frame it draws a stand-in
+        vg_want(
+            source,
+            vgeo_brick_waiting_in.elements[at + ${VGEO_BRICK_WAIT_OFFSET.REF}u],
+            page,
+            lookup,
+            bitcast<f32>(vgeo_brick_waiting_in.elements[at + ${VGEO_BRICK_WAIT_OFFSET.ERROR}u])
+        );
+    }
+
+    // within the capacity: the list kept onto was cleared, and holds no more than the one it keeps from
+    let kept = atomicAdd(&vgeo_brick_waiting.count, 1u);
+
+    for (var w = 0u; w < VGEO_BRICK_WAIT_WORDS; w++) {
+        vgeo_brick_waiting.elements[VGEO_BRICK_WAIT_WORDS * kept + w] = vgeo_brick_waiting_in.elements[at + w];
+    }
+}
+`, [
+    chunk_brick_clipmap,
+    chunk_brick_clipmap_enqueue,
+    chunk_folded_workgroup_index,
+    chunk_vgeo_cut_arena,
+    chunk_vgeo_cut_want,
+]);
+
+/**
+ * The vgeo provider's wait (PROBE_CLIPMAP_PROPOSAL_2026_10_27.md §7.6 contract 6, §7.8): a thread a cell the last
+ * frame left waiting, built while a cluster of its cut stood in for a page not resident or a group not selectable.
+ * A cell whose page is resident and whose group is selectable now is queued again with `brick_clipmap_enqueue`, so
+ * exactly the cells that stood something in are built again, once what they waited on is there. The rest wait on,
+ * onto the list this frame's distance pass adds its own to (and counts those past its capacity).
+ *
+ * A want lasts the reading it is in (`VGeoResidency.apply` drops what its budgets defer), so a cell waiting on a page
+ * not resident wants it again, each frame, through the provider's cut's slot (`vg_want`): through the page its
+ * stand-in was found in, while that row still holds that page. Once it holds another, the cell is queued again
+ * instead, and its cut finds the way down anew. A group held back carries no want, as in the cut.
+ *
+ * @type {ComputeShader}
+ */
+export const shader_vgeo_brick_wait = ComputeShader.from({
+    label: "Brick Clipmap VGeo Wait",
+    resources,
+    body,
+});

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

@@ -1,8 +1,8 @@
 /**
  * What shading samples (PROBE_CLIPMAP_PROPOSAL_2026_10_27.md §8): {@link cascade_count} cascades of
  * {@link resolution}³ lattice points around the view, {@link spacing} metres apart in the finest
- * cascade and twice as far apart in each one around it. A point holds a probe only while something on
- * screen wants it, so probes are a sparse cache over the lattice.
+ * cascade and twice as far apart in each one around it. A point holds a probe only while a pixel wants
+ * it, or a hit of a probe a pixel wants, so probes are a sparse cache over the lattice.
  *
  * **Storage** (§8.2):
  * - {@link indirection}, `r32uint`, a texel a lattice point in storage that wraps, the cascades
@@ -18,9 +18,10 @@
  *
  * **A frame's lifetime** ({@link graph_update}, §8.3, §8.5): the windows are placed around the anchor,
  * coarsest first, each a parent cell inside its parent. Retire frees the probes whose points left
- * their windows or that nobody wanted for `retention_time`, want marks the cages one pixel of each
- * screen tile reads, admit gives each wanted point without a probe a NEW one, schedule sets the period
- * T from the wanted count, and the due passes list the frame's updates, NEW probes first.
+ * their windows or that nothing wanted for `retention_time`, want marks the cages one pixel of each
+ * screen tile reads, the hits' wants the cages the last frame's hits read their bounce from, admit
+ * gives each wanted point without a probe a NEW one, schedule sets the period T from the wanted count,
+ * and the due passes list the frame's updates, NEW probes first.
  *
  * **The frame's update** (§8.4, §8.6), once the brick clipmap is built: relocate, then trace, a ray a
  * thread, R a probe, each with its hit and the suns' soft shadows there.
@@ -79,6 +80,16 @@ export class GPUProbeClipmap {
      * @readonly
      */
     readonly depth_resolution: number;
+    /**
+     * Put what the probes' readers bind into `bindings`, under the names `chunk_probe_clipmap_pick` reads
+     * them by: the levels and the sampling uniforms, the indirection, the states and records, the depth
+     * atlas. As the last {@link graph_update} left them; take them each frame, since a growth replaces
+     * the per-slot buffers.
+     *
+     * @param {Object} bindings
+     * @returns {Object} bindings
+     */
+    write_sampling_bindings(bindings: any): any;
     /**
      * @returns {GPUTexture}
      */
@@ -140,8 +151,10 @@ export class GPUProbeClipmap {
      * @param {import("../../../material/resident/GPUResidentMaterialContext.js").GPUResidentMaterialContext} options.materials
      *   the resident materials, updated this frame: what a hit no card sees takes
      * @param {GPUBuffer} options.card_rows the row → card set table, a word a `meshes` row
+     * @param {number} options.shadowmap_atlas graph handle of the frame's shadow map atlas, which the hits'
+     *   local lights are shadowed by
      */
-    graph_update({ graph, x, y, z, depth, normal, camera, stbn, resolution, time, retention_time, response_time, ray_budget, rays_per_probe, brick_clipmap, bricks, scene, materials, card_rows }: {
+    graph_update({ graph, x, y, z, depth, normal, camera, stbn, resolution, time, retention_time, response_time, ray_budget, rays_per_probe, brick_clipmap, bricks, scene, materials, card_rows, shadowmap_atlas }: {
         graph: FrameGraph;
         x: number;
         y: number;
@@ -161,6 +174,7 @@ export class GPUProbeClipmap {
         scene: import("../../../scene/GPUSceneContext.js").GPUSceneContext;
         materials: import("../../../material/resident/GPUResidentMaterialContext.js").GPUResidentMaterialContext;
         card_rows: GPUBuffer;
+        shadowmap_atlas: number;
     }): void;
     destroy(): void;
     #private;

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

@@ -1 +1 @@
-{"version":3,"file":"GPUProbeClipmap.d.ts","sourceRoot":"","sources":["../../../../../../../src/shade/renderer/global_illumination/probe_clipmap/probe/GPUProbeClipmap.js"],"names":[],"mappings":"AAgFA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAkCG;AACH;IA4KI;;;;;;;;OAQG;IACH;QAN2B,aAAa,EAA7B,MAAM;QACU,UAAU,EAA1B,MAAM;QACU,OAAO,EAAvB,MAAM;QACU,mBAAmB,EAAnC,MAAM;QACU,gBAAgB,EAAhC,MAAM;OAyFhB;IA3QD;;;OAGG;IACH,wBAHU,MAAM,CAGF;IAEd;;;;OAIG;IACH,qBAHU,MAAM,CAGL;IAEX;;;;OAIG;IACH,kBAHU,MAAM,CAGR;IAER;;;;OAIG;IACH,8BAHU,MAAM,CAGI;IAEpB;;;;OAIG;IACH,2BAHU,MAAM,CAGC;IA6OjB;;OAEG;IACH,8BAEC;IAED;;;;;OAKG;IACH,wBAEC;IAED;;;OAGG;IACH,uBAEC;IAED;;;;OAIG;IACH,gBAJW,MAAM,QACN,MAAM,GACJ,MAAM,CAIlB;IAED;;;OAGG;IACH,mBAHW,MAAM,GACJ,MAAM,CAIlB;IAED;;;OAGG;IACH,oBAHW,oBAAoB,GAClB,OAAO,CAQnB;IAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OA6BG;IACH;QAxB+B,KAAK,EAAzB,UAAU;QACM,CAAC,EAAjB,MAAM;QACU,CAAC,EAAjB,MAAM;QACU,CAAC,EAAjB,MAAM;QACU,KAAK,EAArB,MAAM;QACU,MAAM,EAAtB,MAAM;QACa,MAAM;QACd,IAAI;QACY,UAAU,EAArC,UAAU,MAAM,CAAC;QACD,IAAI,EAApB,MAAM;QACU,cAAc,EAA9B,MAAM;QACU,aAAa,EAA7B,MAAM;QACU,UAAU,EAA1B,MAAM;QACU,cAAc,EAA9B,MAAM;QACyD,aAAa,EAA5E,OAAO,6BAA6B,EAAE,eAAe;QAErC,MAAM,EAAtB,MAAM;QAE+D,KAAK,EAA1E,OAAO,mCAAmC,EAAE,eAAe;QAE4C,SAAS,EAAhH,OAAO,0DAA0D,EAAE,0BAA0B;QAE1E,SAAS;aA8JtC;IAqVD,gBAcC;;CACJ;mCAl6BY,OAAO,4BAA4B,EAAE,oBAAoB;yBACzD,OAAO,iEAAiE,EAAE,UAAU"}
+{"version":3,"file":"GPUProbeClipmap.d.ts","sourceRoot":"","sources":["../../../../../../../src/shade/renderer/global_illumination/probe_clipmap/probe/GPUProbeClipmap.js"],"names":[],"mappings":"AA0FA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAmCG;AACH;IA4LI;;;;;;;;OAQG;IACH;QAN2B,aAAa,EAA7B,MAAM;QACU,UAAU,EAA1B,MAAM;QACU,OAAO,EAAvB,MAAM;QACU,mBAAmB,EAAnC,MAAM;QACU,gBAAgB,EAAhC,MAAM;OA+FhB;IAjSD;;;OAGG;IACH,wBAHU,MAAM,CAGF;IAEd;;;;OAIG;IACH,qBAHU,MAAM,CAGL;IAEX;;;;OAIG;IACH,kBAHU,MAAM,CAGR;IAER;;;;OAIG;IACH,8BAHU,MAAM,CAGI;IAEpB;;;;OAIG;IACH,2BAHU,MAAM,CAGC;IAmQjB;;;;;;;;OAQG;IACH,4CAUC;IAED;;OAEG;IACH,8BAEC;IAED;;;;;OAKG;IACH,wBAEC;IAED;;;OAGG;IACH,uBAEC;IAED;;;;OAIG;IACH,gBAJW,MAAM,QACN,MAAM,GACJ,MAAM,CAIlB;IAED;;;OAGG;IACH,mBAHW,MAAM,GACJ,MAAM,CAIlB;IAED;;;OAGG;IACH,oBAHW,oBAAoB,GAClB,OAAO,CAQnB;IAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OA+BG;IACH;QA1B+B,KAAK,EAAzB,UAAU;QACM,CAAC,EAAjB,MAAM;QACU,CAAC,EAAjB,MAAM;QACU,CAAC,EAAjB,MAAM;QACU,KAAK,EAArB,MAAM;QACU,MAAM,EAAtB,MAAM;QACa,MAAM;QACd,IAAI;QACY,UAAU,EAArC,UAAU,MAAM,CAAC;QACD,IAAI,EAApB,MAAM;QACU,cAAc,EAA9B,MAAM;QACU,aAAa,EAA7B,MAAM;QACU,UAAU,EAA1B,MAAM;QACU,cAAc,EAA9B,MAAM;QACyD,aAAa,EAA5E,OAAO,6BAA6B,EAAE,eAAe;QAErC,MAAM,EAAtB,MAAM;QAE+D,KAAK,EAA1E,OAAO,mCAAmC,EAAE,eAAe;QAE4C,SAAS,EAAhH,OAAO,0DAA0D,EAAE,0BAA0B;QAE1E,SAAS;QACZ,eAAe,EAA/B,MAAM;aAuNhB;IAmXD,gBAcC;;CACJ;mCA5iCY,OAAO,4BAA4B,EAAE,oBAAoB;yBACzD,OAAO,iEAAiE,EAAE,UAAU"}

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

@@ -2,6 +2,7 @@ import { assert } from "../../../../../core/assert.js";
 import { ClipmapCascadePlacement } from "../../../../../core/geom/clipmap/ClipmapCascadePlacement.js";
 import { BufferDescriptor } from "../../../../descriptor/buffer/BufferDescriptor.js";
 import { graph_read_buffer } from "../../../buffer/graph_read_buffer.js";
+import { graph_build_world_light_clusters } from "../../../light/world_cluster/graph_build_world_light_clusters.js";
 import { WEBGPU_GUARANTEED_MAX_COMPUTE_WORKGROUPS_PER_DIMENSION } from "../../../gpu_primitive/indirect/WEBGPU_GUARANTEED_MAX_COMPUTE_WORKGROUPS_PER_DIMENSION.js";
 import { shader_slot_stack_fill, SLOT_STACK_FILL_WORKGROUP_SIZE } from "../../../gpu_primitive/slot_stack/shader_slot_stack_fill.js";
 import {
@@ -18,6 +19,7 @@ import {
     PROBE_CLIPMAP_OCTAHEDRAL_RESOLUTION_MIN
 } from "../ProbeClipmapSettings.js";
 import { PROBE_PROJECTION_ROW_STRUCT, PROBE_RAY_STRUCT, PROBE_RECORD_STRUCT } from "./chunk_probe_clipmap.js";
+import { PROBE_SAMPLING_STRUCT } from "./chunk_probe_clipmap_pick.js";
 import {
     PROBE_COUNTER_FREE,
     PROBE_COUNTER_STARVED,
@@ -43,10 +45,12 @@ import { shader_probe_clipmap_publish } from "./shader_probe_clipmap_publish.js"
 import { shader_probe_clipmap_relocate } from "./shader_probe_clipmap_relocate.js";
 import { shader_probe_clipmap_retire } from "./shader_probe_clipmap_retire.js";
 import { shader_probe_clipmap_schedule } from "./shader_probe_clipmap_schedule.js";
+import { shader_probe_clipmap_light } from "./shader_probe_clipmap_light.js";
 import { shader_probe_clipmap_shade } from "./shader_probe_clipmap_shade.js";
 import { shader_probe_clipmap_trace } from "./shader_probe_clipmap_trace.js";
 import { shader_probe_clipmap_trace_command } from "./shader_probe_clipmap_trace_command.js";
 import { shader_probe_clipmap_want } from "./shader_probe_clipmap_want.js";
+import { shader_probe_clipmap_want_hits } from "./shader_probe_clipmap_want_hits.js";
 
 /**
  * @typedef {import("../ProbeClipmapSettings.js").ProbeClipmapSettings} ProbeClipmapSettings
@@ -78,11 +82,17 @@ const PROBE_CASCADE_NEST_MARGIN = 1;
  */
 const LIST_HEADER_BYTES = 16;
 
+// word offsets of the radiance atlas's shape in PROBE_SAMPLING_STRUCT
+const SAMPLING_RADIANCE_RESOLUTION = PROBE_SAMPLING_STRUCT.get("radiance_resolution").offset >>> 2;
+const SAMPLING_RADIANCE_TILES_PER_ROW = PROBE_SAMPLING_STRUCT.get("radiance_tiles_per_row").offset >>> 2;
+const SAMPLING_RADIANCE_TEXEL = PROBE_SAMPLING_STRUCT.get("radiance_texel").offset >>> 2;
+const SAMPLING_RADIANCE_TILES_PER_ROW_RECIPROCAL = PROBE_SAMPLING_STRUCT.get("radiance_tiles_per_row_reciprocal").offset >>> 2;
+
 /**
  * What shading samples (PROBE_CLIPMAP_PROPOSAL_2026_10_27.md §8): {@link cascade_count} cascades of
  * {@link resolution}³ lattice points around the view, {@link spacing} metres apart in the finest
- * cascade and twice as far apart in each one around it. A point holds a probe only while something on
- * screen wants it, so probes are a sparse cache over the lattice.
+ * cascade and twice as far apart in each one around it. A point holds a probe only while a pixel wants
+ * it, or a hit of a probe a pixel wants, so probes are a sparse cache over the lattice.
  *
  * **Storage** (§8.2):
  * - {@link indirection}, `r32uint`, a texel a lattice point in storage that wraps, the cascades
@@ -98,9 +108,10 @@ const LIST_HEADER_BYTES = 16;
  *
  * **A frame's lifetime** ({@link graph_update}, §8.3, §8.5): the windows are placed around the anchor,
  * coarsest first, each a parent cell inside its parent. Retire frees the probes whose points left
- * their windows or that nobody wanted for `retention_time`, want marks the cages one pixel of each
- * screen tile reads, admit gives each wanted point without a probe a NEW one, schedule sets the period
- * T from the wanted count, and the due passes list the frame's updates, NEW probes first.
+ * their windows or that nothing wanted for `retention_time`, want marks the cages one pixel of each
+ * screen tile reads, the hits' wants the cages the last frame's hits read their bounce from, admit
+ * gives each wanted point without a probe a NEW one, schedule sets the period T from the wanted count,
+ * and the due passes list the frame's updates, NEW probes first.
  *
  * **The frame's update** (§8.4, §8.6), once the brick clipmap is built: relocate, then trace, a ray a
  * thread, R a probe, each with its hit and the suns' soft shadows there.
@@ -210,6 +221,10 @@ export class GPUProbeClipmap {
     /** Rays the rays buffer holds: U·R as it last grew. */
     #ray_capacity = 0;
 
+    /** U and R of the rays the last frame traced, which the hits' wants read. */
+    #rays_trace_capacity = 0;
+    #rays_per_probe = 0;
+
     /** @type {GPUTileAtlas2D} */
     #radiance;
 
@@ -238,12 +253,20 @@ export class GPUProbeClipmap {
 
     #destroyed = false;
 
+    /** The probes' shape for their readers, `PROBE_SAMPLING_STRUCT`. @type {GPUBuffer} */
+    #sampling;
+
+    #sampling_data = new ArrayBuffer(PROBE_SAMPLING_STRUCT.size);
+    #sampling_u32 = new Uint32Array(this.#sampling_data);
+    #sampling_f32 = new Float32Array(this.#sampling_data);
+
     #levels_data = new ArrayBuffer(CLIPMAP_LEVEL_ARRAY.size);
     #levels_i32 = new Int32Array(this.#levels_data);
     #levels_f32 = new Float32Array(this.#levels_data);
 
     #retire_settings = { capacity: 0, resolution: 0, time: 0, retention_time: 0 };
     #want_settings = { cascade_count: 0, resolution: 0, frame: 0, key_count: 0 };
+    #want_hits_settings = { cascade_count: 0, resolution: 0, key_count: 0, trace_capacity: 0, rays_per_probe: 0 };
     #admit_command_settings = { key_count: 0 };
     #admit_settings = { capacity: 0, resolution: 0, key_count: 0, time: 0 };
     #schedule_settings = { capacity: 0, key_count: 0, trace_capacity: 0 };
@@ -261,7 +284,11 @@ export class GPUProbeClipmap {
 
     #lifetime_data = { counters: -1, depth: -1, normal: -1, stbn: -1 };
 
-    #update_data = { counters: -1, bricks: -1 };
+    #update_data = { counters: -1, bricks: -1, world_cluster_lookup: -1, world_cluster_data: -1, shadowmap_atlas: -1 };
+
+    /** The coarsest brick window's box, metres, which the world light clusters cull lights against. */
+    #clusters_min = [0, 0, 0];
+    #clusters_max = [0, 0, 0];
 
     /** The frame's brick clipmap, which the update's rays read. @type {import("../brick/GPUBrickClipmap.js").GPUBrickClipmap|null} */
     #brick_clipmap = null;
@@ -381,6 +408,33 @@ export class GPUProbeClipmap {
             size: CLIPMAP_LEVEL_ARRAY.size,
             usage: GPUBufferUsage.UNIFORM | GPUBufferUsage.COPY_DST,
         }));
+
+        this.#sampling = device.createBuffer(BufferDescriptor.fromJSON({
+            label: 'Probe clipmap / probe sampling',
+            size: PROBE_SAMPLING_STRUCT.size,
+            usage: GPUBufferUsage.UNIFORM | GPUBufferUsage.COPY_DST,
+        }));
+    }
+
+    /**
+     * Put what the probes' readers bind into `bindings`, under the names `chunk_probe_clipmap_pick` reads
+     * them by: the levels and the sampling uniforms, the indirection, the states and records, the depth
+     * atlas. As the last {@link graph_update} left them; take them each frame, since a growth replaces
+     * the per-slot buffers.
+     *
+     * @param {Object} bindings
+     * @returns {Object} bindings
+     */
+    write_sampling_bindings(bindings) {
+        bindings.probe_levels = this.#levels;
+        bindings.probe_sampling = this.#sampling;
+        bindings.probe_indirection = this.#indirection_view;
+        bindings.probe_states = this.#states;
+        bindings.probe_records = this.#records;
+        bindings.probe_depth = this.#depth.texture_at(0).obtainView();
+        bindings.probe_radiance = this.#radiance.texture_at(0).obtainView();
+
+        return bindings;
     }
 
     /**
@@ -466,8 +520,10 @@ export class GPUProbeClipmap {
      * @param {import("../../../material/resident/GPUResidentMaterialContext.js").GPUResidentMaterialContext} options.materials
      *   the resident materials, updated this frame: what a hit no card sees takes
      * @param {GPUBuffer} options.card_rows the row → card set table, a word a `meshes` row
+     * @param {number} options.shadowmap_atlas graph handle of the frame's shadow map atlas, which the hits'
+     *   local lights are shadowed by
      */
-    graph_update({ graph, x, y, z, depth, normal, camera, stbn, resolution, time, retention_time, response_time, ray_budget, rays_per_probe, brick_clipmap, bricks, scene, materials, card_rows }) {
+    graph_update({ graph, x, y, z, depth, normal, camera, stbn, resolution, time, retention_time, response_time, ray_budget, rays_per_probe, brick_clipmap, bricks, scene, materials, card_rows, shadowmap_atlas }) {
         assert.defined(graph, 'graph');
         assert.defined(camera, 'camera');
         assert.defined(stbn, 'stbn');
@@ -483,6 +539,7 @@ export class GPUProbeClipmap {
         assert.defined(scene, 'scene');
         assert.defined(materials, 'materials');
         assert.defined(card_rows, 'card_rows');
+        assert.isNonNegativeInteger(shadowmap_atlas, 'shadowmap_atlas');
         assert.notOk(this.#destroyed, 'destroyed');
 
         if (this.#grow_pending) {
@@ -503,6 +560,26 @@ export class GPUProbeClipmap {
 
         this.#device.queue.writeBuffer(this.#levels, 0, this.#levels_data);
 
+        // the readers' view of the clipmap: its shape, and the depth and radiance atlases', which grow by rows
+        const depth_texture = this.#depth.texture_at(0);
+        const radiance_texture = this.#radiance.texture_at(0);
+
+        this.#sampling_u32[0] = this.cascade_count;
+        this.#sampling_u32[1] = this.resolution;
+        this.#sampling_u32[2] = this.depth_resolution;
+        this.#sampling_u32[3] = this.#depth.tiles_per_row;
+        this.#sampling_f32[4] = 1 / depth_texture.width;
+        this.#sampling_f32[5] = 1 / depth_texture.height;
+        // rounded to f32 as it is stored, which index_to_grid2d_reciprocal asks for
+        this.#sampling_f32[6] = 1 / this.#depth.tiles_per_row;
+        this.#sampling_u32[SAMPLING_RADIANCE_RESOLUTION] = this.radiance_resolution;
+        this.#sampling_u32[SAMPLING_RADIANCE_TILES_PER_ROW] = this.#radiance.tiles_per_row;
+        this.#sampling_f32[SAMPLING_RADIANCE_TEXEL] = 1 / radiance_texture.width;
+        this.#sampling_f32[SAMPLING_RADIANCE_TEXEL + 1] = 1 / radiance_texture.height;
+        this.#sampling_f32[SAMPLING_RADIANCE_TILES_PER_ROW_RECIPROCAL] = 1 / this.#radiance.tiles_per_row;
+
+        this.#device.queue.writeBuffer(this.#sampling, 0, this.#sampling_data);
+
         const clock = time - this.#time_origin;
 
         this.#retire_settings.capacity = this.#capacity;
@@ -515,6 +592,18 @@ export class GPUProbeClipmap {
         this.#want_settings.frame = this.#frame;
         this.#want_settings.key_count = this.#key_count;
 
+        // the hits' wants read the last frame's rays, as that frame laid them out
+        const want_hits = this.#want_hits_settings;
+
+        want_hits.cascade_count = this.cascade_count;
+        want_hits.resolution = this.resolution;
+        want_hits.key_count = this.#key_count;
+        want_hits.trace_capacity = this.#rays_trace_capacity;
+        want_hits.rays_per_probe = this.#rays_per_probe;
+
+        this.#rays_trace_capacity = trace_capacity;
+        this.#rays_per_probe = rays_per_probe;
+
         this.#admit_command_settings.key_count = this.#key_count;
 
         this.#admit_settings.capacity = this.#capacity;
@@ -598,12 +687,35 @@ export class GPUProbeClipmap {
 
         pass.make_side_effect();
 
+        // the local lights the rays' hits take, clustered over the bricks' cascades, where every hit is (§8.7)
+        const coarsest_cell = brick_clipmap.cell_size(coarsest);
+
+        for (let axis = 0; axis < 3; axis++) {
+            const corner = brick_clipmap.corner(coarsest, axis);
+
+            this.#clusters_min[axis] = corner * coarsest_cell;
+            this.#clusters_max[axis] = (corner + brick_clipmap.resolution) * coarsest_cell;
+        }
+
+        const clusters = graph_build_world_light_clusters({
+            graph,
+            lights: scene.lights,
+            levels: graph_import_buffer(graph, brick_clipmap.levels, "probe_brick_levels"),
+            cascade_count: brick_clipmap.cascade_count,
+            border: 0,
+            coarsest_min: this.#clusters_min,
+            coarsest_max: this.#clusters_max,
+        });
+
         // the frame's updates, once its bricks are built
         const update_data = this.#update_data;
         const update = graph.add("Probe Clipmap Update", update_data, this.#execute_update);
 
         update_data.counters = update.write(data.counters);
         update_data.bricks = update.read(bricks);
+        update_data.world_cluster_lookup = update.read(clusters.lookup);
+        update_data.world_cluster_data = update.read(clusters.data);
+        update_data.shadowmap_atlas = update.read(shadowmap_atlas);
 
         update.make_side_effect();
 
@@ -753,10 +865,10 @@ export class GPUProbeClipmap {
 
         this.#parity = 1 - this.#parity;
 
-        // the frame's lists start empty, and no point is wanted yet
+        // the frame's lists start empty, and no point is wanted yet; the trace list holds the last frame's
+        // updates until the hits' wants have read their rays
         encoder.clearBuffer(active_write, 0, 4);
         encoder.clearBuffer(this.#wanted, 0, 4);
-        encoder.clearBuffer(this.#trace, 0, 4);
         encoder.clearBuffer(this.#wanted_bits);
 
         b.probe_levels = this.#levels;
@@ -794,6 +906,21 @@ export class GPUProbeClipmap {
             bindings: b,
         });
 
+        // the last frame's hits want the probes their bounce reads, through the launch their rays had,
+        // before the frame's trace command writes it over
+        b.probe_origins = this.#origins;
+        b.probe_rays = this.#rays;
+        b.settings = this.#want_hits_settings;
+
+        shader_probe_clipmap_want_hits.dispatchIndirect({
+            encoder,
+            bindings: b,
+            command: this.#dispatch,
+            command_offset: 4 * PROBE_DISPATCH_RAYS,
+        });
+
+        encoder.clearBuffer(this.#trace, 0, 4);
+
         b.settings = this.#admit_command_settings;
 
         shader_probe_clipmap_admit_command.dispatch({ encoder, bindings: b });
@@ -886,6 +1013,21 @@ export class GPUProbeClipmap {
             command_offset: 4 * PROBE_DISPATCH_RAYS,
         });
 
+        // the light each hit takes from beyond the trace: its cell's local lights, and the next bounce from
+        // last frame's probes
+        this.write_sampling_bindings(b);
+        b.world_cluster_lookup = resources.get(data.world_cluster_lookup);
+        b.world_cluster_data = resources.get(data.world_cluster_data);
+        b.shadowmapAtlas = resources.get(data.shadowmap_atlas).obtainView();
+        b.settings = this.#trace_settings;
+
+        shader_probe_clipmap_light.dispatchIndirect({
+            encoder,
+            bindings: b,
+            command: this.#dispatch,
+            command_offset: 4 * PROBE_DISPATCH_RAYS,
+        });
+
         // the probes' maps from their rays, against the atlases as they were; their SH and kind from the
         // maps; then the atlases from the maps
         b.probe_maps = this.#maps;
@@ -975,7 +1117,7 @@ export class GPUProbeClipmap {
         this.#radiance.destroy();
         this.#depth.destroy();
 
-        for (const buffer of [this.#levels, this.#states, this.#records, this.#free, this.#counters, this.#dispatch, ...this.#active, this.#wanted, this.#wanted_bits, this.#trace, this.#origins, this.#maps, this.#projection, this.#rays]) {
+        for (const buffer of [this.#levels, this.#states, this.#records, this.#free, this.#counters, this.#dispatch, ...this.#active, this.#wanted, this.#wanted_bits, this.#trace, this.#origins, this.#maps, this.#projection, this.#rays, this.#sampling]) {
             buffer?.destroy();
         }
     }

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

@@ -191,6 +191,13 @@ export const PROBE_WANT_TILE: number;
  * @type {number}
  */
 export const PROBE_WANT_WORKGROUP_TILES: number;
+/**
+ * A wanted list entry's top bit: a pixel wanted the point, not only hits (§8.3). Admit marks the point's
+ * probe as the screen's on it, and only the screen's probes' hits want in turn. The key is the other
+ * bits.
+ * @type {number}
+ */
+export const PROBE_WANTED_SCREEN: number;
 /**
  * Lanes of the fill, a texel of the indirection each.
  * @type {number}

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

@@ -1 +1 @@
-{"version":3,"file":"PROBE_CLIPMAP.d.ts","sourceRoot":"","sources":["../../../../../../../src/shade/renderer/global_illumination/probe_clipmap/probe/PROBE_CLIPMAP.js"],"names":[],"mappings":"AAiNA;;;;;;;;GAQG;AACH,8DAJW,MAAM,oBACN,MAAM,GACJ,MAAM,CAIlB;AAjND;;;GAGG;AACH,iCAFU,MAAM,CAE6B;AAS7C;;;GAGG;AACH,+BAFU,MAAM,CAEkB;AAElC;;;GAGG;AACH,8BAFU,MAAM,CAEiB;AAEjC;;;GAGG;AACH,gCAFU,MAAM,CAEmB;AAEnC;;;;GAIG;AACH,+BAFU,MAAM,CAEkB;AAElC;;;GAGG;AACH,oCAFU,MAAM,CAEuB;AAEvC;;;GAGG;AACH,wCAFU,MAAM,CAE2B;AAM3C;;;GAGG;AACH,iCAFU,MAAM,CAEoB;AAEpC;;;;GAIG;AACH,oCAFU,MAAM,CAEuB;AAEvC;;;GAGG;AACH,mCAFU,MAAM,CAEsB;AAEtC;;;GAGG;AACH,kCAFU,MAAM,CAEqB;AAQrC;;;;GAIG;AACH,oCAFU,MAAM,CAEuB;AAEvC;;;GAGG;AACH,mCAFU,MAAM,CAEsB;AAEtC;;;GAGG;AACH,oCAFU,MAAM,CAEuB;AAEvC;;;GAGG;AACH,kCAFU,MAAM,CAEqB;AAErC;;;GAGG;AACH,oCAFU,MAAM,CAEwB;AAExC;;;GAGG;AACH,kCAFU,MAAM,CAEsB;AAEtC;;;GAGG;AACH,qCAFU,MAAM,CAEyB;AAEzC;;;GAGG;AACH,mCAFU,MAAM,CAEuB;AAEvC;;;GAGG;AACH,0CAFU,MAAM,CAE8B;AAE9C;;;GAGG;AACH,iCAFU,MAAM,CAEoB;AAEpC;;;;GAIG;AACH,yCAFU,MAAM,CAE+B;AAE/C;;;;GAIG;AACH,qCAFU,MAAM,CAE2B;AAE3C;;;GAGG;AACH,qCAFU,MAAM,CAEwB;AAExC;;;GAGG;AACH,gCAFU,MAAM,CAE8B;AAE9C;;;;GAIG;AACH,oCAFU,MAAM,CAEyB;AAEzC;;;;GAIG;AACH,2CAFU,MAAM,CAEgC;AAEhD;;;GAGG;AACH,yCAFU,MAAM,CAE+B;AAE/C;;;GAGG;AACH,qCAFU,MAAM,CAEyB;AAezC;;;;GAIG;AACH,kCAFU,MAAM,CAEqB;AAOrC;;;GAGG;AACH,kCAFU,MAAM,CAEqB;AAErC;;;GAGG;AACH,kCAFU,MAAM,CAEqB;AAErC;;;GAGG;AACH,sCAFU,MAAM,CAEyB;AAEzC;;;GAGG;AACH,8BAFU,MAAM,CAEiB;AAEjC;;;GAGG;AACH,yCAFU,MAAM,CAE4B;AAE5C;;;GAGG;AACH,wCAFU,MAAM,CAE4B;AAE5C;;;;GAIG;AACH,gCAFU,MAAM,CAEmB;AAEnC;;;GAGG;AACH,kCAFU,MAAM,CAEuB;AAEvC;;;;GAIG;AACH,uCAFU,MAAM,CAE4B"}
+{"version":3,"file":"PROBE_CLIPMAP.d.ts","sourceRoot":"","sources":["../../../../../../../src/shade/renderer/global_illumination/probe_clipmap/probe/PROBE_CLIPMAP.js"],"names":[],"mappings":"AAiNA;;;;;;;;GAQG;AACH,8DAJW,MAAM,oBACN,MAAM,GACJ,MAAM,CAIlB;AAjND;;;GAGG;AACH,iCAFU,MAAM,CAE6B;AAS7C;;;GAGG;AACH,+BAFU,MAAM,CAEkB;AAElC;;;GAGG;AACH,8BAFU,MAAM,CAEiB;AAEjC;;;GAGG;AACH,gCAFU,MAAM,CAEmB;AAEnC;;;;GAIG;AACH,+BAFU,MAAM,CAEkB;AAElC;;;GAGG;AACH,oCAFU,MAAM,CAEuB;AAEvC;;;GAGG;AACH,wCAFU,MAAM,CAE2B;AAM3C;;;GAGG;AACH,iCAFU,MAAM,CAEoB;AAEpC;;;;GAIG;AACH,oCAFU,MAAM,CAEuB;AAEvC;;;GAGG;AACH,mCAFU,MAAM,CAEsB;AAEtC;;;GAGG;AACH,kCAFU,MAAM,CAEqB;AAQrC;;;;GAIG;AACH,oCAFU,MAAM,CAEuB;AAEvC;;;GAGG;AACH,mCAFU,MAAM,CAEsB;AAEtC;;;GAGG;AACH,oCAFU,MAAM,CAEuB;AAEvC;;;GAGG;AACH,kCAFU,MAAM,CAEqB;AAErC;;;GAGG;AACH,oCAFU,MAAM,CAEwB;AAExC;;;GAGG;AACH,kCAFU,MAAM,CAEsB;AAEtC;;;GAGG;AACH,qCAFU,MAAM,CAEyB;AAEzC;;;GAGG;AACH,mCAFU,MAAM,CAEuB;AAEvC;;;GAGG;AACH,0CAFU,MAAM,CAE8B;AAE9C;;;GAGG;AACH,iCAFU,MAAM,CAEoB;AAEpC;;;;GAIG;AACH,yCAFU,MAAM,CAE+B;AAE/C;;;;GAIG;AACH,qCAFU,MAAM,CAE2B;AAE3C;;;GAGG;AACH,qCAFU,MAAM,CAEwB;AAExC;;;GAGG;AACH,gCAFU,MAAM,CAE8B;AAE9C;;;;GAIG;AACH,oCAFU,MAAM,CAEyB;AAEzC;;;;GAIG;AACH,2CAFU,MAAM,CAEgC;AAEhD;;;GAGG;AACH,yCAFU,MAAM,CAE+B;AAE/C;;;GAGG;AACH,qCAFU,MAAM,CAEyB;AAezC;;;;GAIG;AACH,kCAFU,MAAM,CAEqB;AAOrC;;;GAGG;AACH,kCAFU,MAAM,CAEqB;AAErC;;;GAGG;AACH,kCAFU,MAAM,CAEqB;AAErC;;;GAGG;AACH,sCAFU,MAAM,CAEyB;AAEzC;;;GAGG;AACH,8BAFU,MAAM,CAEiB;AAEjC;;;GAGG;AACH,yCAFU,MAAM,CAE4B;AAE5C;;;;;GAKG;AACH,kCAFU,MAAM,CAE8B;AAE9C;;;GAGG;AACH,wCAFU,MAAM,CAE4B;AAE5C;;;;GAIG;AACH,gCAFU,MAAM,CAEmB;AAEnC;;;GAGG;AACH,kCAFU,MAAM,CAEuB;AAEvC;;;;GAIG;AACH,uCAFU,MAAM,CAE4B"}

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

@@ -262,6 +262,14 @@ export const PROBE_WANT_TILE = 8;
  */
 export const PROBE_WANT_WORKGROUP_TILES = 8;
 
+/**
+ * A wanted list entry's top bit: a pixel wanted the point, not only hits (§8.3). Admit marks the point's
+ * probe as the screen's on it, and only the screen's probes' hits want in turn. The key is the other
+ * bits.
+ * @type {number}
+ */
+export const PROBE_WANTED_SCREEN = 0x80000000;
+
 /**
  * Lanes of the fill, a texel of the indirection each.
  * @type {number}

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

@@ -1,7 +1,7 @@
 /**
  * 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.
+ * was wanted and traced, its last update's back faces, whose want it was, and its irradiance. Where
+ * relocation moved it is the state's second word, which readers weighing it load with the state.
  *
  * @type {WebGPUStruct}
  */
@@ -226,6 +226,18 @@ export const chunk_probe_clipmap: CodeChunk;
  * @type {CodeChunk}
  */
 export const chunk_probe_clipmap_ray_texel: CodeChunk;
+/**
+ * The STBN jitter of a ray in its texel (§8.6): the noise moved by the slot's hash so that neighbouring
+ * probes do not jitter alike, and a fresh sample for each update and each round of a texel's rays. The
+ * trace aims its ray by it, and the light pass picks the probes at its hit with it (§8.7).
+ *
+ * ```wgsl
+ * fn probe_clipmap_ray_jitter(slot: u32, texel: u32, ray: u32, updates: u32, rays: u32, n: u32) -> vec2<f32> // ray: its index among the probe's R; n: n_r
+ * ```
+ *
+ * @type {CodeChunk}
+ */
+export const chunk_probe_clipmap_ray_jitter: CodeChunk;
 import { WebGPUStruct } from "../../../shader/type/WebGPUStruct.js";
 import { ShaderResourceDescriptor } from "../../../shader/resource/ShaderResourceDescriptor.js";
 import { CodeChunk } from "../../../shader/compiler/CodeChunk.js";

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":"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"}
+{"version":3,"file":"chunk_probe_clipmap.d.ts","sourceRoot":"","sources":["../../../../../../../src/shade/renderer/global_illumination/probe_clipmap/probe/chunk_probe_clipmap.js"],"names":[],"mappings":"AAwCA;;;;;;GAMG;AACH,kCAFU,YAAY,CAmBJ;AAElB;;;;;GAKG;AACH,+BAFU,YAAY,CAwBP;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,CAuFhB;AAEH;;;;;;;;;;;;;;;;;GAiBG;AACH,4CAFU,SAAS,CA+BhB;AAEH;;;;;;;;;;GAUG;AACH,6CAFU,SAAS,CAkBhB;6BA/d0B,sCAAsC;yCAH1B,sDAAsD;0BADrE,uCAAuC"}