@woosh/meep-engine 3.64.1 → 3.67.0

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);
                 }

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

@@ -2,6 +2,11 @@
  * @type {WebGPUStruct}
  */
 export const PROBE_WANT_SETTINGS: WebGPUStruct;
+/**
+ * {@link PROBE_WANT_SETTINGS} and how the surface's normals are read.
+ * @type {WebGPUStruct}
+ */
+export const PROBE_WANT_SURFACE_SETTINGS: WebGPUStruct;
 /**
  * Want (PROBE_CLIPMAP_PROPOSAL_2026_10_27.md §8.3): a thread a tile of {@link PROBE_WANT_TILE}² pixels,
  * the launch the screen's tiles.
@@ -10,6 +15,12 @@ export const PROBE_WANT_SETTINGS: WebGPUStruct;
  * that pixel's pick reads (§9.1), biased along `mix(n, v, 0.2)`, through `probe_clipmap_want`. A sky
  * pixel wants nothing.
  *
+ * The surface is any the frame holds a depth and a normal of, a pixel each: the G-buffer's, or one drawn
+ * apart from it whose reader picks its probes per pixel, the water's interface. `gBufferDepth` is its
+ * reverse-Z depth, zero where it has no surface; `gBufferNormals` its normals, octahedral in the channel
+ * `settings.normal_channel`, as the G-buffer packs its own in its first. Where `settings.two_sided` is set,
+ * a normal that faces away from the eye is turned to face it, as a reader of such a surface turns it.
+ *
  * At a cascade's outer edge a lattice cell is 58 pixels on a 1080p screen at a 60° field of view, and
  * 19 at 120°, so a tile of 8 samples every cell several times a frame, and a workgroup's 64 tiles want
  * a few cages between them, which its claims keep to one want each.

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

@@ -1 +1 @@
-{"version":3,"file":"shader_probe_clipmap_want.d.ts","sourceRoot":"","sources":["../../../../../../../src/shade/renderer/global_illumination/probe_clipmap/probe/shader_probe_clipmap_want.js"],"names":[],"mappings":"AAqBA;;GAEG;AACH,kCAFU,YAAY,CAcE;AAexB;;;;;;;;;;;;;GAaG;AACH,wCAFU,aAAa,CAqCpB;6BA1F0B,sCAAsC;8BAHrC,kCAAkC"}
+{"version":3,"file":"shader_probe_clipmap_want.d.ts","sourceRoot":"","sources":["../../../../../../../src/shade/renderer/global_illumination/probe_clipmap/probe/shader_probe_clipmap_want.js"],"names":[],"mappings":"AAqBA;;GAEG;AACH,kCAFU,YAAY,CAcE;AAExB;;;GAGG;AACH,0CAFU,YAAY,CAaS;AAe/B;;;;;;;;;;;;;;;;;;;GAmBG;AACH,wCAFU,aAAa,CAyCpB;6BArH0B,sCAAsC;8BAHrC,kCAAkC"}

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

@@ -36,9 +36,26 @@ export const PROBE_WANT_SETTINGS = WebGPUStruct.from({
     select_half: f32,
 }, "ProbeWantSettings");
 
+/**
+ * {@link PROBE_WANT_SETTINGS} and how the surface's normals are read.
+ * @type {WebGPUStruct}
+ */
+export const PROBE_WANT_SURFACE_SETTINGS = WebGPUStruct.from({
+    cascade_count: u32,
+    resolution: u32,
+    frame: u32,
+    wanted_capacity: u32,
+    anchor: vec3f,
+    select_half: f32,
+    /** the channel of the normals' texel that holds the normal: 0 to 3 */
+    normal_channel: u32,
+    /** non-zero where a normal may face away from the eye and its reader turns it to face it */
+    two_sided: u32,
+}, "ProbeWantSurfaceSettings");
+
 const resources = new ShaderResourceSetDescriptor();
 
-resources.setImmediate("settings", PROBE_WANT_SETTINGS);
+resources.setImmediate("settings", PROBE_WANT_SURFACE_SETTINGS);
 
 resources.createGroup()
     .addTexture("gBufferDepth")
@@ -57,6 +74,12 @@ resources.createGroup()
  * that pixel's pick reads (§9.1), biased along `mix(n, v, 0.2)`, through `probe_clipmap_want`. A sky
  * pixel wants nothing.
  *
+ * The surface is any the frame holds a depth and a normal of, a pixel each: the G-buffer's, or one drawn
+ * apart from it whose reader picks its probes per pixel, the water's interface. `gBufferDepth` is its
+ * reverse-Z depth, zero where it has no surface; `gBufferNormals` its normals, octahedral in the channel
+ * `settings.normal_channel`, as the G-buffer packs its own in its first. Where `settings.two_sided` is set,
+ * a normal that faces away from the eye is turned to face it, as a reader of such a surface turns it.
+ *
  * At a cascade's outer edge a lattice cell is 58 pixels on a 1080p screen at a 60° field of view, and
  * 19 at 120°, so a tile of 8 samples every cell several times a frame, and a workgroup's 64 tiles want
  * a few cages between them, which its claims keep to one want each.
@@ -83,8 +106,12 @@ fn main(@builtin(global_invocation_id) id: vec3<u32>) {
 
     let uv = (vec2<f32>(pixel) + 0.5) / vec2<f32>(size);
     let position = project_position_from_depth(uv, depth, camera.view_projection_matrix_inverse);
-    let normal = decode_g_buffer_normal(textureLoad(gBufferNormals, pixel, 0).x);
+    let texel = textureLoad(gBufferNormals, pixel, 0);
+    // each channel by name: a dynamic index would put the texel in local memory
+    let encoded = select(select(texel.x, texel.y, settings.normal_channel == 1u), select(texel.z, texel.w, settings.normal_channel == 3u), settings.normal_channel >= 2u);
+    let stored = decode_g_buffer_normal(encoded);
     let view_direction = normalize(mat4_extract_position(camera.transform) - position);
+    let normal = select(stored, -stored, settings.two_sided != 0u && dot(stored, view_direction) < 0.0);
     let bias_direction = mix(normal, view_direction, ${PROBE_RECEIVER_BIAS_VIEW});
 
     probe_clipmap_want(on_screen && !is_background(depth), position, bias_direction, settings.cascade_count, settings.resolution, settings.anchor, settings.select_half, settings.wanted_capacity);

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

@@ -0,0 +1,40 @@
+/**
+ * @type {WebGPUStruct}
+ */
+export const PROBE_WANT_LATE_SETTINGS: WebGPUStruct;
+/**
+ * The keys wanted since the last lifetime, each once, as the late wants listed them.
+ * @type {ShaderResourceDescriptor}
+ */
+export const PROBE_LATE_WANTED_READ_RESOURCE: ShaderResourceDescriptor;
+/**
+ * A bit a key of the late list, cleared as the key is taken.
+ * @type {ShaderResourceDescriptor}
+ */
+export const PROBE_LATE_WANTED_BITS_RESOURCE: ShaderResourceDescriptor;
+/**
+ * The cage windows the late list's keys were written in: the levels of the frame before.
+ * @type {ShaderResourceDescriptor}
+ */
+export const PROBE_LATE_LEVELS_RESOURCE: ShaderResourceDescriptor;
+/**
+ * The late wants taken into the frame's (PROBE_CLIPMAP_PROPOSAL_2026_10_27.md §8.3): a thread a key of the late
+ * list, through a launch its count sizes.
+ *
+ * A reader whose surface is drawn after the frame's lifetime wants its probes into the late set, through
+ * `probe_clipmap_want` as any want does, and the next lifetime runs this between its own wants and admit. A key
+ * the frame's set lacks goes on its list; either way the key's late bit is cleared, which leaves the late bits
+ * empty, and the host empties the list.
+ *
+ * A key names a storage cell, and the lattice point it stands for is the one its writer's window held there. Where
+ * a window has moved since, the cell of a point it left stands for the point that came in across from it, which
+ * nothing wanted: a key is taken only where the present window's point is one the writer's window
+ * (`probe_late_levels`) held too.
+ *
+ * @type {ComputeShader}
+ */
+export const shader_probe_clipmap_want_late: ComputeShader;
+import { WebGPUStruct } from "../../../shader/type/WebGPUStruct.js";
+import { ShaderResourceDescriptor } from "../../../shader/resource/ShaderResourceDescriptor.js";
+import { ComputeShader } from "../../../shader/ComputeShader.js";
+//# sourceMappingURL=shader_probe_clipmap_want_late.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"shader_probe_clipmap_want_late.d.ts","sourceRoot":"","sources":["../../../../../../../src/shade/renderer/global_illumination/probe_clipmap/probe/shader_probe_clipmap_want_late.js"],"names":[],"mappings":"AAmBA;;GAEG;AACH,uCAFU,YAAY,CASM;AAE5B;;;GAGG;AACH,8CAFU,wBAAwB,CAEqG;AAEvI;;;GAGG;AACH,8CAFU,wBAAwB,CAEkH;AAEpJ;;;GAGG;AACH,yCAFU,wBAAwB,CAEmF;AAcrH;;;;;;;;;;;;;;;GAeG;AACH,6CAFU,aAAa,CAkDpB;6BAnH0B,sCAAsC;yCAJ1B,sDAAsD;8BADjE,kCAAkC"}