@woosh/meep-engine 3.64.1 → 3.65.0

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

@@ -4,8 +4,13 @@
  *
  * ```wgsl
  * fn probe_clipmap_want(wants: bool, position: vec3<f32>, bias_direction: vec3<f32>, cascade_count: u32, resolution: u32, anchor: vec3<f32>, select_half: f32, wanted_capacity: u32)
+ * fn probe_clipmap_want_cage(wants: bool, cascade: u32, cage: vec3<i32>, resolution: u32, wanted_capacity: u32)
  * ```
  *
+ * `probe_clipmap_want_cage` wants one cage by name, the cage whose least point is `cage` in `cascade`, for a
+ * caller that knows its cages without a point to read them from; the cascade's cage window must hold it
+ * (`clipmap_contains`). `probe_clipmap_want` is the two it reads from a point.
+ *
  * The cages are the pick's: the cascade `probe_clipmap_select_in` answers for the point, by the windows'
  * `anchor` and `select_half` as the pick reads them, the cage of the point biased along `bias_direction` by
  * that cascade's spacing, and in the cascade's blend skirt the next cascade's cage too, biased by its own. A cage a bias moved out of its window is not wanted. Each cage
@@ -16,8 +21,8 @@
  * workgroup's table and sets its bits; the rest want it through that lane. Measured on the AMD iGPU at
  * 1280×720 on Sponza before the claims, the bits' atomics were 140 of want's 345 µs and the appends 90.
  *
- * Every lane of the workgroup calls it once, wanting or not, from uniform control flow: the appends are
- * the subgroup's.
+ * Every lane of the workgroup calls `probe_clipmap_want` once, or `probe_clipmap_want_cage` at most twice, which
+ * the claim table is sized for, wanting or not, from uniform control flow: the appends are the subgroup's.
  *
  * @type {CodeChunk}
  */

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

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

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

@@ -13,7 +13,7 @@ import { PROBE_THREAD_WORKGROUP_SIZE } from "./PROBE_CLIPMAP.js";
 /**
  * Slots of a workgroup's claim table: twice the claims its lanes make at most, a cage in each of two
  * cascades a lane, so a probe finds a slot within a few. Sized for {@link PROBE_THREAD_WORKGROUP_SIZE}
- * lanes: want's 8×8 tiles, and the hits' wants' 64.
+ * lanes: want's 8×8 tiles, and the hits' wants' 64; the meshlets' wants' lanes are twice as many, a cage each.
  * @type {number}
  */
 const WANT_CLAIM_SLOTS = 2 * 2 * PROBE_THREAD_WORKGROUP_SIZE;
@@ -30,8 +30,13 @@ const WANT_CLAIM_PROBES = 16;
  *
  * ```wgsl
  * fn probe_clipmap_want(wants: bool, position: vec3<f32>, bias_direction: vec3<f32>, cascade_count: u32, resolution: u32, anchor: vec3<f32>, select_half: f32, wanted_capacity: u32)
+ * fn probe_clipmap_want_cage(wants: bool, cascade: u32, cage: vec3<i32>, resolution: u32, wanted_capacity: u32)
  * ```
  *
+ * `probe_clipmap_want_cage` wants one cage by name, the cage whose least point is `cage` in `cascade`, for a
+ * caller that knows its cages without a point to read them from; the cascade's cage window must hold it
+ * (`clipmap_contains`). `probe_clipmap_want` is the two it reads from a point.
+ *
  * The cages are the pick's: the cascade `probe_clipmap_select_in` answers for the point, by the windows'
  * `anchor` and `select_half` as the pick reads them, the cage of the point biased along `bias_direction` by
  * that cascade's spacing, and in the cascade's blend skirt the next cascade's cage too, biased by its own. A cage a bias moved out of its window is not wanted. Each cage
@@ -42,8 +47,8 @@ const WANT_CLAIM_PROBES = 16;
  * workgroup's table and sets its bits; the rest want it through that lane. Measured on the AMD iGPU at
  * 1280×720 on Sponza before the claims, the bits' atomics were 140 of want's 345 µs and the appends 90.
  *
- * Every lane of the workgroup calls it once, wanting or not, from uniform control flow: the appends are
- * the subgroup's.
+ * Every lane of the workgroup calls `probe_clipmap_want` once, or `probe_clipmap_want_cage` at most twice, which
+ * the claim table is sized for, wanting or not, from uniform control flow: the appends are the subgroup's.
  *
  * @type {CodeChunk}
  */
@@ -80,46 +85,45 @@ fn probe_want_claim(key: u32) -> bool {
     return true;
 }
 
-fn probe_clipmap_want(wants: bool, position: vec3<f32>, bias_direction: vec3<f32>, cascade_count: u32, resolution: u32, anchor: vec3<f32>, select_half: f32, wanted_capacity: u32) {
-    let selection = probe_clipmap_select_in(&probe_levels, cascade_count, anchor, select_half, position);
-
-    let held = wants && selection.level != CLIPMAP_LEVEL_NONE;
-    let finest = select(0u, selection.level, held);
-    let next = min(finest + 1u, cascade_count - 1u);
-
-    var cage_finest: vec3<i32>;
-    var cage_next: vec3<i32>;
-
+fn probe_clipmap_want_cage(wants: bool, cascade: u32, cage: vec3<i32>, resolution: u32, wanted_capacity: u32) {
     // storage wraps by the window's side, a power of two: the low bits of a point, negative ones too
     let wrap = vec3<u32>(resolution - 1u);
 
-    let wants_finest = held && probe_clipmap_cage(finest, position, bias_direction, &cage_finest)
-        && probe_want_claim(probe_clipmap_key(finest, vec3<u32>(cage_finest) & wrap, resolution));
-    let wants_next = held && selection.edge_weight > 0.0 && finest + 1u < cascade_count
-        && probe_clipmap_cage(next, position, bias_direction, &cage_next)
-        && probe_want_claim(probe_clipmap_key(next, vec3<u32>(cage_next) & wrap, resolution));
-
-    // every lane through all sixteen corners, so that the appends stay in uniform control flow
-    for (var k = 0u; k < 16u; k++) {
-        let coarse = k >= 8u;
-        let cascade = select(finest, next, coarse);
-        let wanted = select(wants_finest, wants_next, coarse);
-        let corner = vec3<i32>(vec3<u32>(k & 1u, (k >> 1u) & 1u, (k >> 2u) & 1u));
-        let point = select(cage_finest, cage_next, coarse) + corner;
+    let claimed = wants && probe_want_claim(probe_clipmap_key(cascade, vec3<u32>(cage) & wrap, resolution));
 
-        let storage = vec3<u32>(point) & wrap;
-        let key = probe_clipmap_key(cascade, storage, resolution);
+    // every lane through all eight corners, so that the appends stay in uniform control flow
+    for (var k = 0u; k < 8u; k++) {
+        let corner = vec3<i32>(vec3<u32>(k & 1u, (k >> 1u) & 1u, (k >> 2u) & 1u));
+        let key = probe_clipmap_key(cascade, vec3<u32>(cage + corner) & wrap, resolution);
         let bit = 1u << (key & 31u);
 
         var first = false;
 
-        if (wanted) {
+        if (claimed) {
             first = (atomicOr(&probe_wanted_bits[key >> 5u], bit) & bit) == 0u;
         }
 
         collection_u32_append(&probe_wanted, first, key, wanted_capacity);
     }
 }
+
+fn probe_clipmap_want(wants: bool, position: vec3<f32>, bias_direction: vec3<f32>, cascade_count: u32, resolution: u32, anchor: vec3<f32>, select_half: f32, wanted_capacity: u32) {
+    let selection = probe_clipmap_select_in(&probe_levels, cascade_count, anchor, select_half, position);
+
+    let held = wants && selection.level != CLIPMAP_LEVEL_NONE;
+    let finest = select(0u, selection.level, held);
+    let next = min(finest + 1u, cascade_count - 1u);
+
+    var cage_finest: vec3<i32>;
+    var cage_next: vec3<i32>;
+
+    let wants_finest = held && probe_clipmap_cage(finest, position, bias_direction, &cage_finest);
+    let wants_next = held && selection.edge_weight > 0.0 && finest + 1u < cascade_count
+        && probe_clipmap_cage(next, position, bias_direction, &cage_next);
+
+    probe_clipmap_want_cage(wants_finest, finest, cage_finest, resolution, wanted_capacity);
+    probe_clipmap_want_cage(wants_next, next, cage_next, resolution, wanted_capacity);
+}
 `, [
         chunk_probe_clipmap,
         chunk_probe_clipmap_select_in,

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

@@ -0,0 +1,28 @@
+/**
+ * Record the wants of a list of meshlets whose fragments pick probes (PROBE_CLIPMAP_PROPOSAL_2026_10_27.md §8.3):
+ * the meshlets a forward pass draws, which no pixel of the G-buffer stands for. Each wants the cages a reader
+ * anywhere inside its world box can read, a thread a cage: its cages are counted
+ * (`shader_probe_clipmap_want_meshlet_count`), the counts summed (`graph_prefix_scan_csdldf`), and the sums
+ * launch the wants (`shader_probe_clipmap_want_meshlets`), as the meshes' expansion to meshlets is launched.
+ *
+ * The wants go into the clipmap's late set (`GPUProbeClipmap.write_want_bindings`), so the pass belongs after the
+ * clipmap's lifetime in the frame, and its probes are admitted by the next frame's.
+ *
+ * @param {Object} options
+ * @param {import("../../../../../engine/graphics/render/frame_graph/FrameGraph.js").FrameGraph} options.graph
+ * @param {import("./GPUProbeClipmap.js").GPUProbeClipmap} options.clipmap the clipmap the fragments pick from
+ * @param {import("../../../scene/GPUSceneContext.js").GPUSceneContext} options.scene the meshlets' scene
+ * @param {number} options.camera graph handle of the view's camera uniform
+ * @param {number} options.meshlet_collection graph handle of the list, `MESHLET_COLLECTION_STRUCT`
+ * @param {number} options.meshlet_iterator_command graph handle of the indirect dispatch that walks the list, a
+ *   workgroup of `COMPUTE_SHADER_DEFAULT_GROUP_SIZE` meshlets, folded
+ */
+export function graph_probe_clipmap_want_meshlets({ graph, clipmap, scene, camera, meshlet_collection, meshlet_iterator_command }: {
+    graph: import("../../../../../engine/graphics/render/frame_graph/FrameGraph.js").FrameGraph;
+    clipmap: import("./GPUProbeClipmap.js").GPUProbeClipmap;
+    scene: import("../../../scene/GPUSceneContext.js").GPUSceneContext;
+    camera: number;
+    meshlet_collection: number;
+    meshlet_iterator_command: number;
+}): void;
+//# sourceMappingURL=graph_probe_clipmap_want_meshlets.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"graph_probe_clipmap_want_meshlets.d.ts","sourceRoot":"","sources":["../../../../../../../src/shade/renderer/global_illumination/probe_clipmap/probe/graph_probe_clipmap_want_meshlets.js"],"names":[],"mappings":"AAqBA;;;;;;;;;;;;;;;;;;GAkBG;AACH;IARyG,KAAK,EAAnG,OAAO,iEAAiE,EAAE,UAAU;IAC5B,OAAO,EAA/D,OAAO,sBAAsB,EAAE,eAAe;IACuB,KAAK,EAA1E,OAAO,mCAAmC,EAAE,eAAe;IAC3C,MAAM,EAAtB,MAAM;IACU,kBAAkB,EAAlC,MAAM;IACU,wBAAwB,EAAxC,MAAM;SAoGhB"}

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

@@ -0,0 +1,138 @@
+import { assert } from "../../../../../core/assert.js";
+import { BufferResourceDescriptor } from "../../../../device/graph/BufferResourceDescriptor.js";
+import { MESHLET_DEFINITION_STRUCT } from "../../../geometry/meshlet/encoding/MESHLET_DEFINITION_STRUCT.js";
+import { INDIRECT_COMPUTE_COMMAND_DESCRIPTOR } from "../../../gpu_primitive/indirect/IndirectComputeCommandBuildPass.js";
+import {
+    graph_prefix_scan_csdldf,
+    prefix_scan_csdldf_output_descriptor
+} from "../../../gpu_primitive/prefix_sum/v1/graph_prefix_scan_csdldf.js";
+import { shader_prefix_sum_to_command } from "../../../rasterize/expand/mesh/shader_prefix_sum_to_command.js";
+import { graph_create_buffer } from "../../../shader/graph/graph_create_buffer.js";
+import {
+    shader_probe_clipmap_want_meshlet_count,
+    shader_probe_clipmap_want_meshlets
+} from "./shader_probe_clipmap_want_meshlets.js";
+
+/**
+ * Bytes a meshlet list's count takes ahead of its elements, which sit on a 16-byte boundary.
+ * @type {number}
+ */
+const MESHLET_LIST_HEADER_BYTES = 16;
+
+/**
+ * Record the wants of a list of meshlets whose fragments pick probes (PROBE_CLIPMAP_PROPOSAL_2026_10_27.md §8.3):
+ * the meshlets a forward pass draws, which no pixel of the G-buffer stands for. Each wants the cages a reader
+ * anywhere inside its world box can read, a thread a cage: its cages are counted
+ * (`shader_probe_clipmap_want_meshlet_count`), the counts summed (`graph_prefix_scan_csdldf`), and the sums
+ * launch the wants (`shader_probe_clipmap_want_meshlets`), as the meshes' expansion to meshlets is launched.
+ *
+ * The wants go into the clipmap's late set (`GPUProbeClipmap.write_want_bindings`), so the pass belongs after the
+ * clipmap's lifetime in the frame, and its probes are admitted by the next frame's.
+ *
+ * @param {Object} options
+ * @param {import("../../../../../engine/graphics/render/frame_graph/FrameGraph.js").FrameGraph} options.graph
+ * @param {import("./GPUProbeClipmap.js").GPUProbeClipmap} options.clipmap the clipmap the fragments pick from
+ * @param {import("../../../scene/GPUSceneContext.js").GPUSceneContext} options.scene the meshlets' scene
+ * @param {number} options.camera graph handle of the view's camera uniform
+ * @param {number} options.meshlet_collection graph handle of the list, `MESHLET_COLLECTION_STRUCT`
+ * @param {number} options.meshlet_iterator_command graph handle of the indirect dispatch that walks the list, a
+ *   workgroup of `COMPUTE_SHADER_DEFAULT_GROUP_SIZE` meshlets, folded
+ */
+export function graph_probe_clipmap_want_meshlets({ graph, clipmap, scene, camera, meshlet_collection, meshlet_iterator_command }) {
+    assert.defined(graph, 'graph');
+    assert.defined(clipmap, 'clipmap');
+    assert.defined(scene, 'scene');
+    assert.isNonNegativeInteger(camera, 'camera');
+    assert.isNonNegativeInteger(meshlet_collection, 'meshlet_collection');
+    assert.isNonNegativeInteger(meshlet_iterator_command, 'meshlet_iterator_command');
+
+    graph.push_scope("probe clipmap want meshlets");
+
+    // a count for every meshlet the list has room for
+    const capacity = Math.floor((graph.getDescriptor(meshlet_collection).size - MESHLET_LIST_HEADER_BYTES) / MESHLET_DEFINITION_STRUCT.size);
+
+    // what the clipmap binds for a late want: its levels and settings for both passes, its late list and bits for the wants'
+    const want = {};
+
+    const count_data = {};
+
+    const count_pass = graph.add("count cages", count_data, (data, resources, context) => {
+        clipmap.write_want_bindings(want);
+
+        shader_probe_clipmap_want_meshlet_count.dispatchIndirect({
+            encoder: context.encoder,
+            command: resources.get(data.command),
+            bindings: {
+                scene_database: scene.scene_database_buffer,
+                meshlet_metadata: scene.geometries.meshlets.buffer_metadata,
+                input: resources.get(data.input),
+                output: resources.get(data.output),
+                probe_levels: want.probe_levels,
+                settings: want.settings,
+            },
+        });
+    });
+
+    count_data.command = count_pass.read(meshlet_iterator_command);
+    count_data.input = count_pass.read(meshlet_collection);
+    count_data.output = count_pass.create("cage counts", BufferResourceDescriptor.from(
+        MESHLET_LIST_HEADER_BYTES + Math.max(1, Math.ceil(capacity / 4)) * 16,
+        GPUBufferUsage.STORAGE,
+        // the count, which no thread writes for a list of no meshlet
+        0, MESHLET_LIST_HEADER_BYTES,
+    ));
+
+    const sums = graph_prefix_scan_csdldf({
+        graph,
+        input: count_data.output,
+        output: graph_create_buffer(graph, "cage offsets", prefix_scan_csdldf_output_descriptor(capacity)),
+        element_max_count: capacity,
+    });
+
+    const command_data = {};
+
+    const command_pass = graph.add("make want command", command_data, (data, resources, context) => {
+        shader_prefix_sum_to_command.dispatch({
+            encoder: context.encoder,
+            bindings: {
+                prefix_sums: resources.get(data.prefix_sums),
+                command: resources.get(data.command),
+            },
+        });
+    });
+
+    command_data.prefix_sums = command_pass.read(sums);
+    command_data.command = command_pass.create("command", INDIRECT_COMPUTE_COMMAND_DESCRIPTOR);
+
+    const want_data = {};
+
+    const want_pass = graph.add("want cages", want_data, (data, resources, context) => {
+        clipmap.write_want_bindings(want);
+
+        shader_probe_clipmap_want_meshlets.dispatchIndirect({
+            encoder: context.encoder,
+            command: resources.get(data.command),
+            bindings: {
+                camera: resources.get(data.camera),
+                scene_database: scene.scene_database_buffer,
+                meshlet_metadata: scene.geometries.meshlets.buffer_metadata,
+                input: resources.get(data.input),
+                prefix_sums: resources.get(data.prefix_sums),
+                probe_levels: want.probe_levels,
+                probe_wanted: want.probe_wanted,
+                probe_wanted_bits: want.probe_wanted_bits,
+                settings: want.settings,
+            },
+        });
+    });
+
+    want_data.command = want_pass.read(command_data.command);
+    want_data.camera = want_pass.read(camera);
+    want_data.input = want_pass.read(meshlet_collection);
+    want_data.prefix_sums = want_pass.read(sums);
+
+    // it writes the clipmap's own late set, which the graph does not hold
+    want_pass.make_side_effect();
+
+    graph.pop_scope();
+}

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

@@ -4,13 +4,17 @@
 export const PROBE_DUE_SETTINGS: WebGPUStruct;
 /**
  * Due (PROBE_CLIPMAP_PROPOSAL_2026_10_27.md §8.5): a thread an entry of the frame's active list,
- * dispatched twice through `PROBE_DISPATCH_ACTIVE` after schedule has set the period T. A probe is due
- * when a want waits on it:
- * - it is NEW, in the first pass, which lists them first: it has had no update;
- * - in the second pass, it is ALIVE or DEAD, a pixel or a hit wanted it since its last update, its
- *   wanted time past its traced time, and `(frame + h(slot)) mod T` is 0. A DEAD probe is due every
- *   period like an ALIVE one, its update casting `PROBE_DEAD_RAYS`, so that a probe inside a solid
- *   notices when the scene changes (Enshrouded's dead probes trace 16 a frame).
+ * dispatched twice through `PROBE_DISPATCH_ACTIVE` after schedule has set the period T. A probe is due:
+ * - in the first pass, which lists them first, when it is NEW: it has had no update;
+ * - in the second pass, when it is ALIVE or DEAD and `(frame + h(slot)) mod P` is 0, where P is
+ *   - T when a want waits on it: a pixel or a hit wanted it since its last update, its wanted time past
+ *     its traced time;
+ *   - T · `idle_periods` when it is idle, none waiting on it. Every live probe keeps being updated, so one
+ *     that readers reach without wanting it, the bounce at a hit among them, and one a want comes back to,
+ *     holds light no older than that. Its update is any other probe's.
+ *
+ *   A DEAD probe is due like an ALIVE one, its update casting `PROBE_DEAD_RAYS`, so that a probe inside a
+ *   solid notices when the scene changes (Enshrouded's dead probes trace 16 a frame).
  *
  * Wanted since its last update, not this frame: a hit wants a probe the frame after its own probe's
  * update, so a probe that only hits keep is wanted on few of its turns. Measured on Sponza with the
@@ -19,8 +23,8 @@ export const PROBE_DUE_SETTINGS: WebGPUStruct;
  * waits on nothing: the update comes after admit in its frame, so its traced time is the want's or later.
  *
  * The due go on the trace list, which holds the frame's updates, at most U: past it the count still
- * rises and nothing is written, and a probe not listed waits its next turn. With T = ⌈P_w / U⌉ over the
- * probes waiting, the expected count a frame is under U, so only NEW probes past U, a camera cut, wait.
+ * rises and nothing is written, and a probe not listed waits its next turn. Schedule's T keeps the
+ * expected count a frame under U, so only NEW probes past U, a camera cut, wait.
  *
  * @type {ComputeShader}
  */

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

@@ -1 +1 @@
-{"version":3,"file":"shader_probe_clipmap_due.d.ts","sourceRoot":"","sources":["../../../../../../../src/shade/renderer/global_illumination/probe_clipmap/probe/shader_probe_clipmap_due.js"],"names":[],"mappings":"AAkBA;;GAEG;AACH,iCAFU,YAAY,CAWC;AAavB;;;;;;;;;;;;;;;;;;;;;GAqBG;AACH,uCAFU,aAAa,CA4CpB;6BApG0B,sCAAsC;8BAHrC,kCAAkC"}
+{"version":3,"file":"shader_probe_clipmap_due.d.ts","sourceRoot":"","sources":["../../../../../../../src/shade/renderer/global_illumination/probe_clipmap/probe/shader_probe_clipmap_due.js"],"names":[],"mappings":"AAkBA;;GAEG;AACH,iCAFU,YAAY,CAaC;AAavB;;;;;;;;;;;;;;;;;;;;;;;;;GAyBG;AACH,uCAFU,aAAa,CA6CpB;6BA3G0B,sCAAsC;8BAHrC,kCAAkC"}

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

@@ -28,6 +28,8 @@ export const PROBE_DUE_SETTINGS = WebGPUStruct.from({
     frame: u32,
     /** 1 for the pass that lists the NEW probes, 0 for the one that lists the rest */
     new_only: u32,
+    /** periods between an idle probe's turns, `probe_clipmap_idle_periods`, at least 1 */
+    idle_periods: u32,
 }, "ProbeDueSettings");
 
 const resources = new ShaderResourceSetDescriptor();
@@ -43,13 +45,17 @@ resources.createGroup()
 
 /**
  * Due (PROBE_CLIPMAP_PROPOSAL_2026_10_27.md §8.5): a thread an entry of the frame's active list,
- * dispatched twice through `PROBE_DISPATCH_ACTIVE` after schedule has set the period T. A probe is due
- * when a want waits on it:
- * - it is NEW, in the first pass, which lists them first: it has had no update;
- * - in the second pass, it is ALIVE or DEAD, a pixel or a hit wanted it since its last update, its
- *   wanted time past its traced time, and `(frame + h(slot)) mod T` is 0. A DEAD probe is due every
- *   period like an ALIVE one, its update casting `PROBE_DEAD_RAYS`, so that a probe inside a solid
- *   notices when the scene changes (Enshrouded's dead probes trace 16 a frame).
+ * dispatched twice through `PROBE_DISPATCH_ACTIVE` after schedule has set the period T. A probe is due:
+ * - in the first pass, which lists them first, when it is NEW: it has had no update;
+ * - in the second pass, when it is ALIVE or DEAD and `(frame + h(slot)) mod P` is 0, where P is
+ *   - T when a want waits on it: a pixel or a hit wanted it since its last update, its wanted time past
+ *     its traced time;
+ *   - T · `idle_periods` when it is idle, none waiting on it. Every live probe keeps being updated, so one
+ *     that readers reach without wanting it, the bounce at a hit among them, and one a want comes back to,
+ *     holds light no older than that. Its update is any other probe's.
+ *
+ *   A DEAD probe is due like an ALIVE one, its update casting `PROBE_DEAD_RAYS`, so that a probe inside a
+ *   solid notices when the scene changes (Enshrouded's dead probes trace 16 a frame).
  *
  * Wanted since its last update, not this frame: a hit wants a probe the frame after its own probe's
  * update, so a probe that only hits keep is wanted on few of its turns. Measured on Sponza with the
@@ -58,8 +64,8 @@ resources.createGroup()
  * waits on nothing: the update comes after admit in its frame, so its traced time is the want's or later.
  *
  * The due go on the trace list, which holds the frame's updates, at most U: past it the count still
- * rises and nothing is written, and a probe not listed waits its next turn. With T = ⌈P_w / U⌉ over the
- * probes waiting, the expected count a frame is under U, so only NEW probes past U, a camera cut, wait.
+ * rises and nothing is written, and a probe not listed waits its next turn. Schedule's T keeps the
+ * expected count a frame under U, so only NEW probes past U, a camera cut, wait.
  *
  * @type {ComputeShader}
  */
@@ -87,13 +93,14 @@ fn main(
         // wanted since its last update
         let waiting = probe_records[slot].wanted_frame > probe_records[slot].traced_frame;
 
-        let period = max(probe_counters[PROBE_COUNTER_PERIOD], 1u);
+        // an idle probe's turn comes once in as many periods as the settings give
+        let period = max(probe_counters[PROBE_COUNTER_PERIOD], 1u) * select(max(settings.idle_periods, 1u), 1u, waiting);
         let turn = settings.frame + hash_lowbias32(slot);
 
         if (settings.new_only != 0u) {
             due = kind == PROBE_STATE_NEW;
         } else {
-            due = waiting && (kind == PROBE_STATE_ALIVE || kind == PROBE_STATE_DEAD) && turn % period == 0u;
+            due = (kind == PROBE_STATE_ALIVE || kind == PROBE_STATE_DEAD) && turn % period == 0u;
         }
     }
 

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

@@ -204,7 +204,7 @@ fn probe_clipmap_local_irradiance(cascade: u32, position: vec3<f32>, normal: vec
         return estimate;
     }
 
-    let shadow = brick_clipmap_trace(lifted, to_light / span, 0.0, reach, settings.brick_cascade_count);
+    let shadow = brick_clipmap_trace(lifted, to_light / span, 0.0, reach, settings.brick_cascade_count, settings.brick_atlas_shift);
 
     return select(vec3<f32>(0.0), estimate, shadow.kind == BRICK_TRACE_MISS);
 }

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

@@ -1 +1 @@
-{"version":3,"file":"shader_probe_clipmap_relocate.d.ts","sourceRoot":"","sources":["../../../../../../../src/shade/renderer/global_illumination/probe_clipmap/probe/shader_probe_clipmap_relocate.js"],"names":[],"mappings":"AAyBA;;GAEG;AACH,sCAFU,YAAY,CAOM;AAkB5B;;;;;;;;;;;;;;;;;;;GAmBG;AACH,4CAFU,aAAa,CAyDpB;6BAzH0B,sCAAsC;8BAHrC,kCAAkC"}
+{"version":3,"file":"shader_probe_clipmap_relocate.d.ts","sourceRoot":"","sources":["../../../../../../../src/shade/renderer/global_illumination/probe_clipmap/probe/shader_probe_clipmap_relocate.js"],"names":[],"mappings":"AAyBA;;GAEG;AACH,sCAFU,YAAY,CASM;AAkB5B;;;;;;;;;;;;;;;;;;;GAmBG;AACH,4CAFU,aAAa,CAyDpB;6BA3H0B,sCAAsC;8BAHrC,kCAAkC"}

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

@@ -31,6 +31,8 @@ export const PROBE_RELOCATE_SETTINGS = WebGPUStruct.from({
     trace_capacity: u32,
     /** the brick clipmap's cascades, what its field is read through */
     brick_cascade_count: u32,
+    /** the brick atlas's footprint as shifts, `GPUBrickClipmap#atlas_shift` */
+    brick_atlas_shift: u32,
 }, "ProbeRelocateSettings");
 
 const resources = new ShaderResourceSetDescriptor();
@@ -97,13 +99,13 @@ fn main(
     var position = lattice;
 
     for (var step = 0u; step < ${PROBE_RELOCATION_STEPS}u; step++) {
-        let distance = brick_clipmap_distance(position, settings.brick_cascade_count);
+        let distance = brick_clipmap_distance(position, settings.brick_cascade_count, settings.brick_atlas_shift);
 
         if (distance >= clearance) {
             break;
         }
 
-        let gradient = brick_clipmap_gradient(position, settings.brick_cascade_count);
+        let gradient = brick_clipmap_gradient(position, settings.brick_cascade_count, settings.brick_atlas_shift);
 
         if (all(gradient == vec3<f32>(0.0))) {
             break;

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

@@ -1 +1 @@
-{"version":3,"file":"shader_probe_clipmap_retire.d.ts","sourceRoot":"","sources":["../../../../../../../src/shade/renderer/global_illumination/probe_clipmap/probe/shader_probe_clipmap_retire.js"],"names":[],"mappings":"AAyBA;;GAEG;AACH,oCAFU,YAAY,CASI;AAiB1B;;;;;;;;;;;;;;;;;;;;;;;;;GAyBG;AACH,0CAFU,aAAa,CAsFpB;6BAxJ0B,sCAAsC;8BAHrC,kCAAkC"}
+{"version":3,"file":"shader_probe_clipmap_retire.d.ts","sourceRoot":"","sources":["../../../../../../../src/shade/renderer/global_illumination/probe_clipmap/probe/shader_probe_clipmap_retire.js"],"names":[],"mappings":"AAyBA;;GAEG;AACH,oCAFU,YAAY,CASI;AAiB1B;;;;;;;;;;;;;;;;;;;;;;;;;GAyBG;AACH,0CAFU,aAAa,CAqFpB;6BAvJ0B,sCAAsC;8BAHrC,kCAAkC"}

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

@@ -120,10 +120,9 @@ fn main(
 
         // the oldest buckets whole, and as many of the one below them as are asked for; one that left its
         // window goes anyway and takes none of those
-        let whole = PROBE_AGE_BUCKETS - min(probe_eviction.buckets, PROBE_AGE_BUCKETS);
-        var evicted = evictable && counted >= whole;
+        var evicted = evictable && age_eviction_whole(counted, probe_eviction.buckets);
 
-        if (held && evictable && counted + 1u == whole && probe_eviction.remaining > 0u) {
+        if (held && evictable && age_eviction_partial(counted, probe_eviction.buckets) && probe_eviction.remaining > 0u) {
             evicted = atomicAdd(&probe_counters[PROBE_COUNTER_EVICTED], 1u) < probe_eviction.remaining;
         }
 

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

@@ -6,9 +6,11 @@ export const PROBE_SCHEDULE_SETTINGS: WebGPUStruct;
  * Schedule (PROBE_CLIPMAP_PROPOSAL_2026_10_27.md §8.3, §8.5): one thread, after admit, when the frame's
  * active list is whole.
  * - The period: with P_w the probes waiting for an update, the NEW and those wanted since their last
- *   update, `T = max(1, ⌈P_w / U⌉)` frames, so that every probe a want waits on is updated within a period
- *   and the period follows the live count. Retire and admit counted them in
- *   `probe_counters[PROBE_COUNTER_WAITING]`, which it empties for the next frame's; the period goes to
+ *   update, P_i the idle, every other live probe, and m `idle_periods`,
+ *   `T = max(1, ⌈(P_w + P_i / m) / U⌉)` frames. Every probe a want waits on is updated within a period and
+ *   every idle one within m of them, a frame's updates U at most on average, and the period follows the
+ *   live count. Retire and admit counted the waiting in `probe_counters[PROBE_COUNTER_WAITING]`, which it
+ *   empties for the next frame's; the idle are the rest of the frame's active list. The period goes to
  *   `probe_counters[PROBE_COUNTER_PERIOD]` for the due passes.
  * - The next frame's eviction, `probe_eviction`: as many slots as the free ones fall short of the frame's
  *   wanted points and the slack, the probes wanted longest ago first. Walking retire's age buckets from the

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

@@ -1 +1 @@
-{"version":3,"file":"shader_probe_clipmap_schedule.d.ts","sourceRoot":"","sources":["../../../../../../../src/shade/renderer/global_illumination/probe_clipmap/probe/shader_probe_clipmap_schedule.js"],"names":[],"mappings":"AAgBA;;GAEG;AACH,sCAFU,YAAY,CAWM;AAa5B;;;;;;;;;;;;;;;;;;;;;;;;;GAyBG;AACH,4CAFU,aAAa,CA8DpB;6BAzH0B,sCAAsC;8BAHrC,kCAAkC"}
+{"version":3,"file":"shader_probe_clipmap_schedule.d.ts","sourceRoot":"","sources":["../../../../../../../src/shade/renderer/global_illumination/probe_clipmap/probe/shader_probe_clipmap_schedule.js"],"names":[],"mappings":"AAgBA;;GAEG;AACH,sCAFU,YAAY,CAaM;AAa5B;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2BG;AACH,4CAFU,aAAa,CA2CpB;6BA1G0B,sCAAsC;8BAHrC,kCAAkC"}

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

@@ -26,6 +26,8 @@ export const PROBE_SCHEDULE_SETTINGS = WebGPUStruct.from({
     trace_capacity: u32,
     /** slots kept free beyond the frame's wanted points, ⌈capacity · PROBE_FREE_SLACK⌉ */
     slack: u32,
+    /** idle probes the period counts as one waiting, `probe_clipmap_idle_periods`, at least 1 */
+    idle_periods: u32,
 }, "ProbeScheduleSettings");
 
 const resources = new ShaderResourceSetDescriptor();
@@ -43,9 +45,11 @@ resources.createGroup()
  * Schedule (PROBE_CLIPMAP_PROPOSAL_2026_10_27.md §8.3, §8.5): one thread, after admit, when the frame's
  * active list is whole.
  * - The period: with P_w the probes waiting for an update, the NEW and those wanted since their last
- *   update, `T = max(1, ⌈P_w / U⌉)` frames, so that every probe a want waits on is updated within a period
- *   and the period follows the live count. Retire and admit counted them in
- *   `probe_counters[PROBE_COUNTER_WAITING]`, which it empties for the next frame's; the period goes to
+ *   update, P_i the idle, every other live probe, and m `idle_periods`,
+ *   `T = max(1, ⌈(P_w + P_i / m) / U⌉)` frames. Every probe a want waits on is updated within a period and
+ *   every idle one within m of them, a frame's updates U at most on average, and the period follows the
+ *   live count. Retire and admit counted the waiting in `probe_counters[PROBE_COUNTER_WAITING]`, which it
+ *   empties for the next frame's; the idle are the rest of the frame's active list. The period goes to
  *   `probe_counters[PROBE_COUNTER_PERIOD]` for the due passes.
  * - The next frame's eviction, `probe_eviction`: as many slots as the free ones fall short of the frame's
  *   wanted points and the slack, the probes wanted longest ago first. Walking retire's age buckets from the
@@ -73,47 +77,28 @@ export const shader_probe_clipmap_schedule = ComputeShader.from({
         `
 @compute @workgroup_size(1)
 fn main() {
+    let live = min(probe_active_write.count, settings.capacity);
     let waiting = atomicLoad(&probe_counters[PROBE_COUNTER_WAITING]);
+    let idle = live - min(waiting, live);
+    let idle_periods = max(settings.idle_periods, 1u);
     let traced = max(settings.trace_capacity, 1u);
 
     atomicStore(&probe_counters[PROBE_COUNTER_WAITING], 0u);
-    atomicStore(&probe_counters[PROBE_COUNTER_PERIOD], max(divide_round_up_u32(waiting, traced), 1u));
+    // ⌈(P_w + P_i / m) / U⌉ in whole numbers
+    atomicStore(&probe_counters[PROBE_COUNTER_PERIOD], max(divide_round_up_u32(waiting * idle_periods + idle, traced * idle_periods), 1u));
 
     // the slots short of the frame's wanted points and the slack
     let wanted = min(probe_wanted.count, settings.wanted_capacity);
     let room = wanted + settings.slack;
     let free = atomicLoad(&probe_counters[PROBE_COUNTER_FREE]);
 
-    var lacking = select(0u, room - free, room > free);
-    var buckets = 0u;
-    var remaining = 0u;
-
-    for (var k = 0u; k < PROBE_AGE_BUCKETS; k++) {
-        let at = PROBE_COUNTER_AGES + PROBE_AGE_BUCKETS - 1u - k;
-        let aged = atomicLoad(&probe_counters[at]);
-
-        atomicStore(&probe_counters[at], 0u);
+    let plan = age_eviction_plan(&probe_counters, PROBE_COUNTER_AGES, select(0u, room - free, room > free));
 
-        // a bucket nothing was counted in is taken only for an older one: what ages into a bucket below every
-        // probe counted is not asked for
-        if (lacking > 0u && aged > 0u) {
-            if (aged <= lacking) {
-                lacking -= aged;
-                buckets = k + 1u;
-            } else {
-                buckets = k;
-                remaining = lacking;
-                lacking = 0u;
-            }
-        }
-    }
-
-    probe_eviction.buckets = buckets;
-    probe_eviction.remaining = remaining;
+    probe_eviction.buckets = plan.x;
+    probe_eviction.remaining = plan.y;
 
     atomicStore(&probe_counters[PROBE_COUNTER_EVICTED], 0u);
 
-    let live = min(probe_active_write.count, settings.capacity);
     let folded = folded_dispatch(divide_round_up_u32(live, PROBE_THREAD_WORKGROUP_SIZE));
 
     probe_dispatch[PROBE_DISPATCH_ACTIVE] = folded.x;

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

@@ -110,7 +110,7 @@ fn main(
         let cascade = (record.flags >> PROBE_RAY_CASCADE_SHIFT) & PROBE_RAY_CASCADE_MASK;
 
         let draw = hash_to_float01(pcg4d(vec4<u32>(probe_trace.elements[k], record.direction, 0x510E527Fu, 0u)).x);
-        let surface = probe_clipmap_hit_material_pick(position, normal, cascade, draw);
+        let surface = probe_clipmap_hit_material_pick(position, normal, cascade, draw, settings.brick_atlas_shift);
         let direct = rgbe9995_decode(record.light);
 
         radiance = surface.emissive + surface.albedo * direct * RECIPROCAL_PI;

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

@@ -1 +1 @@
-{"version":3,"file":"shader_probe_clipmap_trace.d.ts","sourceRoot":"","sources":["../../../../../../../src/shade/renderer/global_illumination/probe_clipmap/probe/shader_probe_clipmap_trace.js"],"names":[],"mappings":"AAkDA;;GAEG;AACH,mCAFU,YAAY,CAeG;AAsBzB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA+BG;AACH,yCAFU,aAAa,CAuJpB;6BAvP0B,sCAAsC;8BAHrC,kCAAkC"}
+{"version":3,"file":"shader_probe_clipmap_trace.d.ts","sourceRoot":"","sources":["../../../../../../../src/shade/renderer/global_illumination/probe_clipmap/probe/shader_probe_clipmap_trace.js"],"names":[],"mappings":"AAkDA;;GAEG;AACH,mCAFU,YAAY,CAiBG;AAsBzB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA+BG;AACH,yCAFU,aAAa,CAuJpB;6BAzP0B,sCAAsC;8BAHrC,kCAAkC"}

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

@@ -64,6 +64,8 @@ export const PROBE_TRACE_SETTINGS = WebGPUStruct.from({
     t_max: f32,
     /** updates between a probe's uniform ones, `PROBE_UNIFORM_PERIOD` */
     uniform_period: u32,
+    /** the brick atlas's footprint as shifts, `GPUBrickClipmap#atlas_shift` */
+    brick_atlas_shift: u32,
 }, "ProbeTraceSettings");
 
 const resources = new ShaderResourceSetDescriptor();
@@ -198,7 +200,7 @@ fn main(
     let start = brick_clipmap_start(origin, cascade_count);
     let t_min = brick_levels[min(start, cascade_count - 1u)].cell_size / ${MESH_SDF_BRICK_VOXELS}.0;
 
-    let hit = brick_clipmap_trace(origin, direction, t_min, settings.t_max, cascade_count);
+    let hit = brick_clipmap_trace(origin, direction, t_min, settings.t_max, cascade_count, settings.brick_atlas_shift);
 
     let is_hit = hit.kind == BRICK_TRACE_HIT;
     let back_face = is_hit && dot(hit.normal, direction) > 0.0;
@@ -229,7 +231,7 @@ fn main(
                     // a point of the disk of its own for each light, apart from the origin's draw
                     let hash = pcg3d(vec3<u32>(slot, packed, 0x3C6EF372u + shadowed));
                     let toward = cone_sample_direction(-light.direction, light.disk_radius, vec2<f32>(hash_to_float01(hash.x), hash_to_float01(hash.y)));
-                    let shadow = brick_clipmap_trace(lifted, toward, 0.0, settings.t_max, cascade_count);
+                    let shadow = brick_clipmap_trace(lifted, toward, 0.0, settings.t_max, cascade_count, settings.brick_atlas_shift);
 
                     visible = select(0.0, 1.0, shadow.kind == BRICK_TRACE_MISS);
                 }