@woosh/meep-engine 3.58.0 → 3.60.0

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

@@ -2,7 +2,13 @@ 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 {
+    PREFIX_SCAN_CSDLDF_PARTITION_SIZE,
+    shader_prefix_scan_csdldf,
+    shader_prefix_scan_csdldf_prepare
+} from "../../../gpu_primitive/prefix_sum/v1/shader_prefix_scan_csdldf.js";
 import { shader_slot_stack_fill, SLOT_STACK_FILL_WORKGROUP_SIZE } from "../../../gpu_primitive/slot_stack/shader_slot_stack_fill.js";
 import {
     shader_slot_stack_push_range,
@@ -17,7 +23,8 @@ import {
     PROBE_CLIPMAP_OCTAHEDRAL_RESOLUTION_MAX,
     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_EVICTION_STRUCT, PROBE_PROJECTION_ROW_STRUCT, PROBE_RAY_STRUCT, PROBE_RECORD_STRUCT, PROBE_REQUEST_STRUCT } from "./chunk_probe_clipmap.js";
+import { PROBE_SAMPLING_STRUCT } from "./chunk_probe_clipmap_pick.js";
 import {
     PROBE_COUNTER_FREE,
     PROBE_COUNTER_STARVED,
@@ -28,25 +35,45 @@ import {
     PROBE_DISPATCH_RAYS,
     PROBE_DISPATCH_ROWS,
     PROBE_DISPATCH_TEXELS,
+    PROBE_DISPATCH_ORDER,
     PROBE_DISPATCH_TRACED,
     PROBE_DISPATCH_WORDS,
+    PROBE_FREE_SLACK,
+    PROBE_RAYS_PER_TEXEL_MAX,
+    PROBE_RAYS_PER_TEXEL_MIN,
+    PROBE_THREAD_WORKGROUP_SIZE,
     PROBE_WANT_TILE,
     PROBE_WANT_WORKGROUP_TILES,
+    PROBE_UNIFORM_PERIOD,
+    probe_clipmap_guide_words,
     probe_clipmap_maps_words
 } from "./PROBE_CLIPMAP.js";
 import { shader_probe_clipmap_accumulate } from "./shader_probe_clipmap_accumulate.js";
 import { shader_probe_clipmap_admit, shader_probe_clipmap_admit_command } from "./shader_probe_clipmap_admit.js";
 import { shader_probe_clipmap_due } from "./shader_probe_clipmap_due.js";
 import { shader_probe_clipmap_fill } from "./shader_probe_clipmap_fill.js";
+import {
+    shader_probe_clipmap_guide_rows,
+    shader_probe_clipmap_guide_starts,
+    shader_probe_clipmap_guide_weights
+} from "./shader_probe_clipmap_guide.js";
 import { shader_probe_clipmap_project, shader_probe_clipmap_project_rows } from "./shader_probe_clipmap_project.js";
 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_ray_command,
+    shader_probe_clipmap_ray_counts,
+    shader_probe_clipmap_ray_layout
+} from "./shader_probe_clipmap_ray_layout.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_order } from "./shader_probe_clipmap_order.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,18 +105,25 @@ 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 gets a probe when a pixel wants it, or
+ * a hit of a probe a pixel wants, and keeps it until its window leaves it or the slots are wanted for
+ * others, 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
  *   stacked along z: the slot of the point's probe, or none. Allocated whole, since the lattice follows
  *   from the structure alone.
  * - a slot each: a state of two words, the kind and updates and then where relocation moved it
- *   (`PROBE_CLIPMAP.js`), a 64-byte record (`PROBE_RECORD_STRUCT`), an octahedral radiance tile of
+ *   (`PROBE_CLIPMAP.js`), a 48-byte record (`PROBE_RECORD_STRUCT`), an octahedral radiance tile of
  *   {@link radiance_resolution}² texels and a depth-moment tile of {@link depth_resolution}², each with
  *   a one-texel skirt, in two 2-D tile atlases. The slots are handed out by a free list on the device.
  * - the active lists, double-buffered: each frame's retire reads the last frame's and writes the
@@ -98,12 +132,22 @@ 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 and those the last frame's schedule evicted, 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 probes waiting
+ * for an update and the next frame's eviction from the pressure on the slots (`PROBE_FREE_SLACK`), 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.
+ * **The frame's rays** (§8.6): the lifetime's last passes lay them out. Each listed probe's rays this update
+ * are a count the budget does not scale (a uniform update's R, a DEAD probe's fewest) and a request it
+ * does (a guided update's, `probe_requests`, which projection sets after each update). Both are scanned
+ * (`graph_prefix_scan_csdldf`'s shaders), the requests are scaled into what the budget leaves, and the
+ * sums of the two are `probe_ray_sums`: a probe's rays follow one another in the trace list's order, and
+ * the last sum is the frame's count, which the rays' command dispatches.
+ *
+ * **The frame's update** (§8.4, §8.6), once the brick clipmap is built: relocate; then the guide, the
+ * CDF over each listed probe's history that its guided updates' rays follow (`PROBE_UNIFORM_PERIOD`);
+ * then trace, a ray a thread, each with its hit and the suns' shadow rays from there.
  *
  * Retire, admit, due and the update run through commands written on the device, want over the screen's
  * tiles: nothing is sized by the capacity.
@@ -178,6 +222,9 @@ export class GPUProbeClipmap {
     /** What the one-thread passes write for the passes after them to dispatch through. @type {GPUBuffer} */
     #dispatch;
 
+    /** What the next frame's retire evicts, `PROBE_EVICTION_STRUCT`, as schedule writes it. @type {GPUBuffer} */
+    #eviction;
+
     /** The two active lists; the frame reads `#active[#parity]` and writes the other. @type {GPUBuffer[]} */
     #active = [];
 
@@ -201,18 +248,46 @@ export class GPUProbeClipmap {
     /** The listed probes' maps, as accumulation writes them, as many as the trace list holds. @type {GPUBuffer|null} */
     #maps = null;
 
+    /** The listed probes' guides, as the guide passes write them, as many as the trace list holds. @type {GPUBuffer|null} */
+    #guide = null;
+
     /** The listed probes' projected rows, n_r a probe, as many as the trace list holds. @type {GPUBuffer|null} */
     #projection = null;
 
-    /** The frame's rays, R a listed probe. @type {GPUBuffer|null} */
+    /** The frame's rays, laid out by listed probe (`#ray_sums`). @type {GPUBuffer|null} */
     #rays = null;
 
-    /** Rays the rays buffer holds: U·R as it last grew. */
+    /** Rays the rays buffer holds: U·R, to the next whole workgroup, as it last grew. */
     #ray_capacity = 0;
 
+    /** Each listed probe's rays this update that the budget does not scale, `{count, elements}`, as many as the trace list holds. @type {GPUBuffer|null} */
+    #ray_counts = null;
+
+    /** Each listed probe's rays this update that the budget scales: a guided update's request. @type {GPUBuffer|null} */
+    #ray_requests = null;
+
+    /** The scans' outputs, the inclusive sums of the counts and of the requests. @type {GPUBuffer|null} */
+    #ray_count_sums = null;
+    /** @type {GPUBuffer|null} */
+    #ray_request_sums = null;
+
+    /** The rays' layout, inclusive sums of each listed probe's rays. @type {GPUBuffer|null} */
+    #ray_sums = null;
+
+    /** The ray counts' scan's spine, cleared before each scan, and its command. @type {GPUBuffer|null} */
+    #ray_scan_spine = null;
+    /** @type {GPUBuffer|null} */
+    #ray_scan_command = null;
+
     /** @type {GPUTileAtlas2D} */
     #radiance;
 
+    /** Each slot's radiance estimators, `vec4<u32>` a texel, n_r² a slot: the atlas's mean's multi-scale state. @type {GPUBuffer} */
+    #estimators;
+
+    /** Each slot's ray request, `PROBE_REQUEST_STRUCT`: the rays its next guided update asks for. @type {GPUBuffer} */
+    #requests;
+
     /** @type {GPUTileAtlas2D} */
     #depth;
 
@@ -232,36 +307,53 @@ export class GPUProbeClipmap {
     #starved = 0;
     #grow_pending = false;
 
-    /** Frames recorded, and the caller's time at the first: the clock the records keep. */
+    /** Frames recorded: the clock the records keep. */
     #frame = 0;
-    #time_origin = 0;
 
     #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 };
+    #retire_settings = { capacity: 0, resolution: 0, frame: 0 };
     #want_settings = { cascade_count: 0, resolution: 0, frame: 0, key_count: 0 };
+    #want_hits_settings = { cascade_count: 0, resolution: 0, key_count: 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 };
-    #due_settings = { capacity: 0, resolution: 0, trace_capacity: 0, frame: 0, new_only: 0 };
-    #trace_command_settings = { trace_capacity: 0, rays_per_probe: 0 };
+    #admit_settings = { capacity: 0, resolution: 0, key_count: 0, frame: 0 };
+    #schedule_settings = { capacity: 0, key_count: 0, trace_capacity: 0, slack: 0 };
+    #due_settings = { capacity: 0, trace_capacity: 0, frame: 0, new_only: 0 };
+    #trace_command_settings = { trace_capacity: 0, radiance_resolution: 0, depth_resolution: 0 };
+    #order_settings = { trace_capacity: 0, resolution: 0, axis_bits: 0 };
+    #ray_counts_settings = { trace_capacity: 0, rays_per_probe: 0, rays_min: 0, radiance_resolution: 0, uniform_period: PROBE_UNIFORM_PERIOD };
+    #ray_layout_settings = { trace_capacity: 0, ray_budget: 0 };
     #relocate_settings = { trace_capacity: 0, brick_cascade_count: 0 };
-    #trace_settings = { trace_capacity: 0, rays_per_probe: 0, radiance_resolution: 0, brick_cascade_count: 0, t_max: 0 };
-    #shade_settings = { trace_capacity: 0, rays_per_probe: 0 };
-    #accumulate_settings = { trace_capacity: 0, rays_per_probe: 0, radiance_resolution: 0, depth_resolution: 0, radiance_tiles_per_row: 0, depth_tiles_per_row: 0, time: 0, response_time: 0 };
-    #project_settings = { trace_capacity: 0, radiance_resolution: 0, depth_resolution: 0, time: 0 };
+    #guide_settings = { trace_capacity: 0, rays_per_probe: 0, radiance_resolution: 0, radiance_tiles_per_row: 0 };
+    #trace_settings = { trace_capacity: 0, rays_per_probe: 0, radiance_resolution: 0, brick_cascade_count: 0, t_max: 0, uniform_period: PROBE_UNIFORM_PERIOD };
+    #accumulate_settings = { trace_capacity: 0, rays_per_probe: 0, radiance_resolution: 0, depth_resolution: 0, radiance_tiles_per_row: 0, depth_tiles_per_row: 0, frame: 0, response_frames: 0, uniform_period: PROBE_UNIFORM_PERIOD };
+    #project_settings = { trace_capacity: 0, rays_per_probe: 0, radiance_resolution: 0, depth_resolution: 0, frame: 0, uniform_period: PROBE_UNIFORM_PERIOD, rays_min: 0, rays_max: 0, response_frames: 0 };
     #publish_settings = { trace_capacity: 0, radiance_resolution: 0, depth_resolution: 0, radiance_tiles_per_row: 0, depth_tiles_per_row: 0 };
     #push_settings = { first: 0, count: 0, counter: PROBE_COUNTER_FREE };
 
     #bindings = {};
 
+    /** The ray counts' scan's, which names its buffers its own way. */
+    #ray_scan_bindings = { scan_in: null, scan_out: null, spine: null, command: null };
+
     #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 };
+
+    /** 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;
@@ -357,6 +449,8 @@ export class GPUProbeClipmap {
 
         // two words a slot: the state, then the relocation offset
         this.#states = this.#create_buffer('probe states', 8 * capacity, GPUBufferUsage.COPY_SRC);
+        this.#estimators = this.#create_buffer('probe estimators', 16 * radiance_resolution * radiance_resolution * capacity, GPUBufferUsage.COPY_SRC);
+        this.#requests = this.#create_buffer('probe requests', PROBE_REQUEST_STRUCT.size * capacity, GPUBufferUsage.COPY_SRC);
         this.#records = this.#create_buffer('probe records', PROBE_RECORD_STRUCT.size * capacity, GPUBufferUsage.COPY_SRC);
         this.#free = this.#create_buffer('probe free list', 4 * capacity, GPUBufferUsage.COPY_SRC);
         this.#active.push(
@@ -368,6 +462,8 @@ export class GPUProbeClipmap {
         this.#counters = this.#create_buffer('probe counters', 4 * PROBE_COUNTER_WORDS, GPUBufferUsage.COPY_SRC | GPUBufferUsage.COPY_DST);
         // zero: the first frame's retire dispatches nothing
         this.#dispatch = this.#create_buffer('probe dispatch', 4 * PROBE_DISPATCH_WORDS, GPUBufferUsage.INDIRECT);
+        // zero: the first frame's retire evicts nothing
+        this.#eviction = this.#create_buffer('probe eviction', PROBE_EVICTION_STRUCT.size, GPUBufferUsage.COPY_SRC);
 
         // every slot free, once the first frame has filled the list
         const counters = new Uint32Array(PROBE_COUNTER_WORDS);
@@ -381,6 +477,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;
     }
 
     /**
@@ -452,9 +575,7 @@ export class GPUProbeClipmap {
      * @param {GPUBuffer} options.camera the view's camera uniform
      * @param {*} options.stbn the 2-channel spatio-temporal blue noise, `STATIC_GRAPHICS_ENGINE_ASSETS.stbn_vec2`
      * @param {ArrayLike<number>} options.resolution the frame's pixels, x and y
-     * @param {number} options.time the caller's clock, seconds
-     * @param {number} options.retention_time seconds an unwanted probe keeps its slot
-     * @param {number} options.response_time seconds of the blend's response, τ (§8.8)
+     * @param {number} options.response_frames frames of the blend's response, τ (§8.8)
      * @param {number} options.ray_budget rays a frame
      * @param {number} options.rays_per_probe rays an update, R: the frame updates ⌊ray_budget / R⌋ probes at most
      * @param {import("../brick/GPUBrickClipmap.js").GPUBrickClipmap} options.brick_clipmap the world the
@@ -467,15 +588,12 @@ export class GPUProbeClipmap {
      *   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
      */
-    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, response_frames, ray_budget, rays_per_probe, brick_clipmap, bricks, scene, materials, card_rows }) {
         assert.defined(graph, 'graph');
         assert.defined(camera, 'camera');
         assert.defined(stbn, 'stbn');
-        assert.isFinite(time, 'time');
-        assert.isFinite(retention_time, 'retention_time');
-        assert.greaterThan(retention_time, 0, 'retention_time');
-        assert.isFinite(response_time, 'response_time');
-        assert.greaterThan(response_time, 0, 'response_time');
+        assert.isFinite(response_frames, 'response_frames');
+        assert.greaterThan(response_frames, 0, 'response_frames');
         assert.isPositiveInteger(rays_per_probe, 'rays_per_probe');
         assert.greaterThanOrEqual(ray_budget, rays_per_probe, 'ray_budget');
         assert.defined(brick_clipmap, 'brick_clipmap');
@@ -491,51 +609,98 @@ export class GPUProbeClipmap {
         }
 
         const trace_capacity = Math.floor(ray_budget / rays_per_probe);
+        const texels = this.radiance_resolution * this.radiance_resolution;
+        const rays_min = PROBE_RAYS_PER_TEXEL_MIN * texels;
+        const rays_max = PROBE_RAYS_PER_TEXEL_MAX * texels;
 
         this.#ensure_trace(trace_capacity);
-        this.#ensure_rays(trace_capacity * rays_per_probe);
-
-        if (this.#frame === 0) {
-            this.#time_origin = time;
-        }
+        // the requests share what the counts leave of the budget, so the frame's rays are at most it
+        this.#ensure_rays(ray_budget);
 
         this.#place(x, y, z);
 
         this.#device.queue.writeBuffer(this.#levels, 0, this.#levels_data);
 
-        const clock = time - this.#time_origin;
+        // 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);
 
         this.#retire_settings.capacity = this.#capacity;
         this.#retire_settings.resolution = this.resolution;
-        this.#retire_settings.time = clock;
-        this.#retire_settings.retention_time = retention_time;
+        this.#retire_settings.frame = this.#frame;
 
         this.#want_settings.cascade_count = this.cascade_count;
         this.#want_settings.resolution = this.resolution;
         this.#want_settings.frame = this.#frame;
         this.#want_settings.key_count = this.#key_count;
 
+        // the hits' wants read the last frame's rays, each naming its probe
+        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;
+
         this.#admit_command_settings.key_count = this.#key_count;
 
         this.#admit_settings.capacity = this.#capacity;
         this.#admit_settings.resolution = this.resolution;
         this.#admit_settings.key_count = this.#key_count;
-        this.#admit_settings.time = clock;
+        this.#admit_settings.frame = this.#frame;
 
         this.#schedule_settings.capacity = this.#capacity;
         this.#schedule_settings.key_count = this.#key_count;
         this.#schedule_settings.trace_capacity = trace_capacity;
+        this.#schedule_settings.slack = Math.ceil(this.#capacity * PROBE_FREE_SLACK);
 
         this.#due_settings.capacity = this.#capacity;
-        this.#due_settings.resolution = this.resolution;
         this.#due_settings.trace_capacity = trace_capacity;
         this.#due_settings.frame = this.#frame;
 
         this.#trace_command_settings.trace_capacity = trace_capacity;
-        this.#trace_command_settings.rays_per_probe = rays_per_probe;
         this.#trace_command_settings.radiance_resolution = this.radiance_resolution;
         this.#trace_command_settings.depth_resolution = this.depth_resolution;
 
+        const order = this.#order_settings;
+
+        order.trace_capacity = trace_capacity;
+        order.resolution = this.resolution;
+        order.axis_bits = Math.ceil(Math.log2(this.resolution));
+
+        // the order's key: the cascade above the Morton code of a lattice point in its window
+        assert.lessThanOrEqual(3 * order.axis_bits + Math.ceil(Math.log2(this.cascade_count)), 32, 'the order key fits a word');
+
+        this.#ray_counts_settings.trace_capacity = trace_capacity;
+        this.#ray_counts_settings.rays_per_probe = rays_per_probe;
+        this.#ray_counts_settings.rays_min = rays_min;
+        this.#ray_counts_settings.radiance_resolution = this.radiance_resolution;
+
+        this.#ray_layout_settings.trace_capacity = trace_capacity;
+        this.#ray_layout_settings.ray_budget = ray_budget;
+
+        const guide = this.#guide_settings;
+
+        guide.trace_capacity = trace_capacity;
+        guide.rays_per_probe = rays_per_probe;
+        guide.radiance_resolution = this.radiance_resolution;
+        guide.radiance_tiles_per_row = this.#radiance.tiles_per_row;
+
         // past the coarsest window's far corner every ray has left the clipmap
         const coarsest = brick_clipmap.cascade_count - 1;
 
@@ -548,9 +713,6 @@ export class GPUProbeClipmap {
         this.#relocate_settings.trace_capacity = trace_capacity;
         this.#relocate_settings.brick_cascade_count = brick_clipmap.cascade_count;
 
-        this.#shade_settings.trace_capacity = trace_capacity;
-        this.#shade_settings.rays_per_probe = rays_per_probe;
-
         const accumulate = this.#accumulate_settings;
 
         accumulate.trace_capacity = trace_capacity;
@@ -559,13 +721,17 @@ export class GPUProbeClipmap {
         accumulate.depth_resolution = this.depth_resolution;
         accumulate.radiance_tiles_per_row = this.#radiance.tiles_per_row;
         accumulate.depth_tiles_per_row = this.#depth.tiles_per_row;
-        accumulate.time = clock;
-        accumulate.response_time = response_time;
+        accumulate.frame = this.#frame;
+        accumulate.response_frames = response_frames;
 
         this.#project_settings.trace_capacity = trace_capacity;
+        this.#project_settings.rays_per_probe = rays_per_probe;
         this.#project_settings.radiance_resolution = this.radiance_resolution;
         this.#project_settings.depth_resolution = this.depth_resolution;
-        this.#project_settings.time = clock;
+        this.#project_settings.frame = this.#frame;
+        this.#project_settings.rays_min = rays_min;
+        this.#project_settings.rays_max = rays_max;
+        this.#project_settings.response_frames = response_frames;
 
         const publish = this.#publish_settings;
 
@@ -598,12 +764,34 @@ 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.make_side_effect();
 
@@ -620,6 +808,9 @@ export class GPUProbeClipmap {
                 } finally {
                     reference.release();
                 }
+            })
+            .catch(() => {
+                // a reading lost to a timeout or a lost device: the count runs on, and a later reading carries it
             });
 
         this.#frame++;
@@ -667,6 +858,8 @@ export class GPUProbeClipmap {
         this.#depth.ensure_capacity(capacity);
 
         this.#states = this.#regrow(this.#states, 'probe states', 8 * capacity);
+        this.#estimators = this.#regrow(this.#estimators, 'probe estimators', 16 * this.radiance_resolution * this.radiance_resolution * capacity);
+        this.#requests = this.#regrow(this.#requests, 'probe requests', PROBE_REQUEST_STRUCT.size * capacity);
         this.#records = this.#regrow(this.#records, 'probe records', PROBE_RECORD_STRUCT.size * capacity);
         this.#free = this.#regrow(this.#free, 'probe free list', 4 * capacity);
         this.#active[0] = this.#regrow(this.#active[0], 'probe active 0', LIST_HEADER_BYTES + 4 * capacity);
@@ -688,25 +881,46 @@ export class GPUProbeClipmap {
         this.#trace?.destroy();
         this.#origins?.destroy();
         this.#maps?.destroy();
+        this.#guide?.destroy();
         this.#projection?.destroy();
+        this.#ray_counts?.destroy();
+        this.#ray_requests?.destroy();
+        this.#ray_count_sums?.destroy();
+        this.#ray_request_sums?.destroy();
+        this.#ray_sums?.destroy();
+        this.#ray_scan_spine?.destroy();
+        this.#ray_scan_command?.destroy();
         this.#trace_capacity = trace_capacity;
         this.#trace = this.#create_buffer('probe trace', LIST_HEADER_BYTES + 4 * trace_capacity, GPUBufferUsage.COPY_DST);
+        // the scan reads and writes whole blocks of four
+        const counts_size = LIST_HEADER_BYTES + 16 * Math.max(1, Math.ceil(trace_capacity / 4));
+        this.#ray_counts = this.#create_buffer('probe ray counts', counts_size, 0);
+        this.#ray_requests = this.#create_buffer('probe ray requests', counts_size, 0);
+        this.#ray_count_sums = this.#create_buffer('probe ray count sums', counts_size, 0);
+        this.#ray_request_sums = this.#create_buffer('probe ray request sums', counts_size, 0);
+        this.#ray_sums = this.#create_buffer('probe ray sums', counts_size, 0);
+        this.#ray_scan_spine = this.#create_buffer('probe ray scan spine', 8 * Math.ceil(trace_capacity / PREFIX_SCAN_CSDLDF_PARTITION_SIZE), GPUBufferUsage.COPY_DST);
+        this.#ray_scan_command = this.#create_buffer('probe ray scan command', 12, GPUBufferUsage.INDIRECT);
         this.#origins = this.#create_buffer('probe origins', 16 * trace_capacity, 0);
         this.#maps = this.#create_buffer('probe maps', 4 * probe_clipmap_maps_words(this.radiance_resolution, this.depth_resolution) * trace_capacity, 0);
+        this.#guide = this.#create_buffer('probe guide', 4 * probe_clipmap_guide_words(this.radiance_resolution) * trace_capacity, 0);
         this.#projection = this.#create_buffer('probe projection', PROBE_PROJECTION_ROW_STRUCT.size * this.radiance_resolution * trace_capacity, 0);
     }
 
     /**
-     * Room for `ray_count` rays, U·R: the update's rays, which the ray settings size.
+     * Room for `ray_count` rays, U·R, which the ray settings size, to the next whole workgroup: the last
+     * workgroup's threads past the frame's last ray write a record of no ray.
      */
     #ensure_rays(ray_count) {
-        if (this.#rays !== null && this.#ray_capacity >= ray_count) {
+        const room = Math.ceil(ray_count / PROBE_THREAD_WORKGROUP_SIZE) * PROBE_THREAD_WORKGROUP_SIZE;
+
+        if (this.#rays !== null && this.#ray_capacity >= room) {
             return;
         }
 
         this.#rays?.destroy();
-        this.#ray_capacity = ray_count;
-        this.#rays = this.#create_buffer('probe rays', PROBE_RAY_STRUCT.size * ray_count, 0);
+        this.#ray_capacity = room;
+        this.#rays = this.#create_buffer('probe rays', PROBE_RAY_STRUCT.size * room, 0);
     }
 
     #execute_lifetime = (data, resources, context) => {
@@ -753,10 +967,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;
@@ -771,6 +985,7 @@ export class GPUProbeClipmap {
         b.probe_wanted_bits = this.#wanted_bits;
         b.probe_trace = this.#trace;
         b.probe_dispatch = this.#dispatch;
+        b.probe_eviction = this.#eviction;
 
         b.settings = this.#retire_settings;
 
@@ -794,6 +1009,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 });
@@ -827,11 +1057,74 @@ export class GPUProbeClipmap {
             });
         }
 
+        b.probe_ray_counts = this.#ray_counts;
+        b.probe_ray_requests = this.#ray_requests;
+        b.probe_ray_sums = this.#ray_sums;
         b.settings = this.#trace_command_settings;
 
         shader_probe_clipmap_trace_command.dispatch({ encoder, bindings: b });
+
+        // the list in its probes' order, before anything reads a probe's place in it
+        b.settings = this.#order_settings;
+
+        shader_probe_clipmap_order.dispatchIndirect({
+            encoder,
+            bindings: b,
+            command: this.#dispatch,
+            command_offset: 4 * PROBE_DISPATCH_ORDER,
+        });
+
+        // the frame's rays: each listed probe's count and request, their scans, the layout that scales the
+        // requests into the budget, and the command over its last sum
+        b.probe_requests = this.#requests;
+        b.settings = this.#ray_counts_settings;
+
+        shader_probe_clipmap_ray_counts.dispatchIndirect({
+            encoder,
+            bindings: b,
+            command: this.#dispatch,
+            command_offset: 4 * PROBE_DISPATCH_TRACED,
+        });
+
+        this.#scan(encoder, this.#ray_counts, this.#ray_count_sums);
+        this.#scan(encoder, this.#ray_requests, this.#ray_request_sums);
+
+        b.probe_ray_count_sums = this.#ray_count_sums;
+        b.probe_ray_request_sums = this.#ray_request_sums;
+        b.settings = this.#ray_layout_settings;
+
+        shader_probe_clipmap_ray_layout.dispatchIndirect({
+            encoder,
+            bindings: b,
+            command: this.#dispatch,
+            command_offset: 4 * PROBE_DISPATCH_TRACED,
+        });
+
+        shader_probe_clipmap_ray_command.dispatch({ encoder, bindings: b });
     };
 
+    /**
+     * Inclusive sums of a listed probe's counts, `{count, elements}`, into `output`: the CSDLDF scan's
+     * shaders, its spine cleared first, since its flags are read across workgroups.
+     *
+     * @param {GPUCommandEncoder} encoder
+     * @param {GPUBuffer} input
+     * @param {GPUBuffer} output
+     */
+    #scan(encoder, input, output) {
+        const scan = this.#ray_scan_bindings;
+
+        scan.scan_in = input;
+        scan.scan_out = output;
+        scan.spine = this.#ray_scan_spine;
+        scan.command = this.#ray_scan_command;
+
+        encoder.clearBuffer(this.#ray_scan_spine);
+
+        shader_prefix_scan_csdldf_prepare.dispatch({ encoder, bindings: scan });
+        shader_prefix_scan_csdldf.dispatchIndirect({ encoder, bindings: scan, command: this.#ray_scan_command });
+    }
+
     #execute_update = (data, resources, context) => {
         const encoder = context.encoder;
         const b = this.#bindings;
@@ -840,6 +1133,7 @@ export class GPUProbeClipmap {
 
         b.probe_counters = resources.get(data.counters);
         b.probe_origins = this.#origins;
+        b.probe_ray_sums = this.#ray_sums;
         b.settings = this.#relocate_settings;
 
         shader_probe_clipmap_relocate.dispatchIndirect({
@@ -849,6 +1143,20 @@ export class GPUProbeClipmap {
             command_offset: 4 * PROBE_DISPATCH_TRACED,
         });
 
+        // the guide each probe's rays follow, from its history as the atlas holds it
+        b.probe_radiance = this.#radiance.texture_at(0).obtainView();
+        b.probe_guide = this.#guide;
+        b.settings = this.#guide_settings;
+
+        for (const shader of [shader_probe_clipmap_guide_rows, shader_probe_clipmap_guide_weights, shader_probe_clipmap_guide_starts]) {
+            shader.dispatchIndirect({
+                encoder,
+                bindings: b,
+                command: this.#dispatch,
+                command_offset: 4 * PROBE_DISPATCH_ROWS,
+            });
+        }
+
         const scene = this.#scene;
         const lights = scene.lights;
 
@@ -877,7 +1185,6 @@ export class GPUProbeClipmap {
         b.materials = this.#materials.buffer_materials;
         b.texture_means = this.#materials.buffer_texture_means;
         b.tEnvironment = lights.environment.obtainView();
-        b.settings = this.#shade_settings;
 
         shader_probe_clipmap_shade.dispatchIndirect({
             encoder,
@@ -886,12 +1193,28 @@ export class GPUProbeClipmap {
             command_offset: 4 * PROBE_DISPATCH_RAYS,
         });
 
+        // the light each hit takes from beyond the trace: one of its cell's local lights through the bricks, 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.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;
         b.probe_projection = this.#projection;
+        b.probe_requests = this.#requests;
         b.probe_radiance = this.#radiance.texture_at(0).obtainView();
         b.probe_depth = this.#depth.texture_at(0).obtainView();
+        b.probe_estimators = this.#estimators;
         b.settings = this.#accumulate_settings;
 
         shader_probe_clipmap_accumulate.dispatchIndirect({
@@ -975,7 +1298,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.#estimators, this.#records, this.#free, this.#counters, this.#dispatch, this.#eviction, ...this.#active, this.#wanted, this.#wanted_bits, this.#trace, this.#origins, this.#maps, this.#guide, this.#projection, this.#requests, this.#ray_counts, this.#ray_requests, this.#ray_count_sums, this.#ray_request_sums, this.#ray_sums, this.#ray_scan_spine, this.#ray_scan_command, this.#rays, this.#sampling]) {
             buffer?.destroy();
         }
     }