@woosh/meep-engine 3.64.1 → 3.67.0

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

@@ -26,6 +26,7 @@ import {
     CLIPMAP_LEVEL_STRUCT
 } from "../../../shader/chunk/clipmap/CLIPMAP_LEVEL_STRUCT.js";
 import { ShaderSwitchSet } from "../../../shader/compiler/ShaderSwitchSet.js";
+import { build_indirect_compute_dispatch_command } from "../../../gpu_primitive/indirect/IndirectComputeCommandBuildPass.js";
 import { graph_import_buffer } from "../../../shader/graph/graph_import_buffer.js";
 import { GPUTileAtlas2D } from "../../../texture/atlas/GPUTileAtlas2D.js";
 import {
@@ -39,6 +40,7 @@ import {
 import { PROBE_SAMPLING_STRUCT } from "./chunk_probe_clipmap_pick.js";
 import {
     probe_clipmap_guide_words,
+    probe_clipmap_idle_periods,
     probe_clipmap_maps_words,
     PROBE_CASCADE_HYSTERESIS,
     PROBE_CASCADE_STEP,
@@ -92,6 +94,7 @@ import { shader_probe_clipmap_schedule } from "./shader_probe_clipmap_schedule.j
 import { shader_probe_clipmap_shade } from "./shader_probe_clipmap_shade.js";
 import { shader_probe_clipmap_trace } from "./shader_probe_clipmap_trace.js";
 import { shader_probe_clipmap_trace_command } from "./shader_probe_clipmap_trace_command.js";
+import { shader_probe_clipmap_want_late } from "./shader_probe_clipmap_want_late.js";
 
 /**
  * @typedef {import("../ProbeClipmapSettings.js").ProbeClipmapSettings} ProbeClipmapSettings
@@ -153,8 +156,11 @@ const SAMPLING_SELECT_HALF = PROBE_SAMPLING_STRUCT.get("select_half").offset >>>
  * **A frame's lifetime** ({@link graph_update}, §8.3, §8.5): retire frees the probes whose points left
  * their windows and those the last frame's schedule evicted, the wants mark the cages they read, 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.
+ * for an update and the idle ones, 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. Every live probe
+ * keeps being updated: one a want waits on every period, an idle one once in
+ * `probe_clipmap_idle_periods` of them, so the light a probe holds is no older than that whether or not
+ * anything wants it.
  *
  * **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 `PROBE_DEAD_RAYS`) and a request it
@@ -372,6 +378,20 @@ export class GPUProbeClipmap {
     /** Points the wanted list holds: the fewer of the keys and what the wants can want, as it last grew. */
     #wanted_capacity = 0;
 
+    /**
+     * The late wants (§8.3): a wanted list and its bits, which a reader drawn after the frame's lifetime wants
+     * into; the windows its keys were written in; and the launch that takes them into the next frame's wanted
+     * set. Made when a reader first asks for them ({@link write_want_bindings}).
+     * @type {{list: GPUBuffer, bits: GPUBuffer, levels: GPUBuffer, command: GPUBuffer}|null}
+     */
+    #late = null;
+
+    /** Whether a reader has asked for the late set since a lifetime last took it. */
+    #late_pending = false;
+
+    /** Whether the frame's lifetime takes the late set: {@link #late_pending} as the frame was recorded. */
+    #late_taken = false;
+
     /** Whether the next frame is the first, which fills the indirection and the free list. */
     #fill_pending = true;
 
@@ -403,20 +423,27 @@ export class GPUProbeClipmap {
     #levels_data = new ArrayBuffer(CLIPMAP_LEVEL_ARRAY.size);
     #levels_i32 = new Int32Array(this.#levels_data);
     #levels_f32 = new Float32Array(this.#levels_data);
+    #levels_u8 = new Uint8Array(this.#levels_data);
+
+    /** The levels as the frame before uploaded them: the windows its late wants were written in. */
+    #late_levels_u8 = new Uint8Array(CLIPMAP_LEVEL_ARRAY.size);
 
     #retire_settings = { capacity: 0, resolution: 0, frame: 0 };
     #want_settings = { cascade_count: 0, resolution: 0, frame: 0, wanted_capacity: 0, anchor: new Float32Array(3), select_half: 0 };
+    /** {@link #want_settings} for the late wants, whose list holds every key. */
+    #late_want_settings = { cascade_count: 0, resolution: 0, frame: 0, wanted_capacity: 0, anchor: new Float32Array(3), select_half: 0 };
+    #late_settings = { resolution: 0, wanted_capacity: 0, late_capacity: 0 };
     #admit_command_settings = { wanted_capacity: 0 };
     #admit_settings = { capacity: 0, resolution: 0, wanted_capacity: 0, frame: 0 };
-    #schedule_settings = { capacity: 0, wanted_capacity: 0, trace_capacity: 0, slack: 0 };
-    #due_settings = { capacity: 0, trace_capacity: 0, frame: 0, new_only: 0 };
+    #schedule_settings = { capacity: 0, wanted_capacity: 0, trace_capacity: 0, slack: 0, idle_periods: 1 };
+    #due_settings = { capacity: 0, trace_capacity: 0, frame: 0, new_only: 0, idle_periods: 1 };
     #trace_command_settings = { trace_capacity: 0, radiance_resolution: 0, depth_resolution: 0, radiance_skirt: 0 };
     #order_settings = { trace_capacity: 0, resolution: 0, axis_bits: 0 };
     #ray_counts_settings = { trace_capacity: 0, rays_per_probe: 0, rays_min: 0, rays_dead: 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 };
+    #relocate_settings = { trace_capacity: 0, brick_cascade_count: 0, brick_atlas_shift: 0 };
     #guide_settings = { trace_capacity: 0, rays_per_probe: 0, radiance_resolution: 0, radiance_tiles_per_row: 0, radiance_skirt: 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 };
+    #trace_settings = { trace_capacity: 0, rays_per_probe: 0, radiance_resolution: 0, brick_cascade_count: 0, t_max: 0, uniform_period: PROBE_UNIFORM_PERIOD, brick_atlas_shift: 0 };
     #accumulate_settings = { trace_capacity: 0, rays_per_probe: 0, radiance_resolution: 0, depth_resolution: 0, radiance_tiles_per_row: 0, radiance_skirt: 0, depth_tiles_per_row: 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 };
     #publish_settings = { trace_capacity: 0, radiance_resolution: 0, depth_resolution: 0, radiance_tiles_per_row: 0, radiance_skirt: 0, depth_tiles_per_row: 0 };
@@ -430,6 +457,9 @@ export class GPUProbeClipmap {
     /** What a want binds of this clipmap: its levels, wanted list and bits, and its want settings. */
     #want_bindings = {};
 
+    /** What taking the late set binds. */
+    #late_bindings = {};
+
     /** The bounce's sets as their clipmaps hold them, under the bounce pass's names. */
     #set_bindings = {};
 
@@ -613,6 +643,44 @@ export class GPUProbeClipmap {
         return bindings;
     }
 
+    /**
+     * Put what a want recorded after the frame's lifetime binds into `bindings`, under the names
+     * `chunk_probe_clipmap_want` reads them by, with its settings as `settings`: the levels, and the late
+     * wanted list and bits in place of the frame's. The next frame's lifetime takes what was wanted there into its
+     * own wanted set, where its windows still hold the point (§8.3): a probe such a want asks for is admitted
+     * a frame later than one the frame's own wants ask for.
+     *
+     * For a pass that runs after this frame's lifetime; take them each frame. Asking is what makes the next
+     * lifetime take the late set.
+     *
+     * @param {Object} bindings
+     * @returns {Object} bindings
+     */
+    write_want_bindings(bindings) {
+        if (this.#late === null) {
+            this.#late = {
+                // every key once: a late want can want any point of the lattice
+                list: this.#create_buffer('probe late wanted', LIST_HEADER_BYTES + 4 * this.#key_count, GPUBufferUsage.COPY_DST),
+                bits: this.#create_buffer('probe late wanted bits', 4 * Math.ceil(this.#key_count / 32), 0),
+                levels: this.#device.createBuffer(BufferDescriptor.fromJSON({
+                    label: `${this.label} / probe late levels`,
+                    size: CLIPMAP_LEVEL_ARRAY.size,
+                    usage: GPUBufferUsage.UNIFORM | GPUBufferUsage.COPY_DST,
+                })),
+                command: this.#create_buffer('probe late command', 16, GPUBufferUsage.INDIRECT),
+            };
+        }
+
+        this.#late_pending = true;
+
+        bindings.probe_levels = this.#levels;
+        bindings.probe_wanted = this.#late.list;
+        bindings.probe_wanted_bits = this.#late.bits;
+        bindings.settings = this.#late_want_settings;
+
+        return bindings;
+    }
+
     /**
      * @returns {GPUTexture}
      */
@@ -848,12 +916,24 @@ export class GPUProbeClipmap {
         const rays_min = Math.min(PROBE_RAYS_PER_TEXEL_MIN * texels, rays_per_probe);
         const rays_dead = Math.min(PROBE_DEAD_RAYS, rays_per_probe);
         const rays_max = PROBE_RAYS_PER_TEXEL_MAX * texels;
+        const idle_periods = probe_clipmap_idle_periods(rays_per_probe, this.radiance_resolution);
 
         this.#ensure_trace(trace_capacity);
         // 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.#device.queue.writeBuffer(this.#levels, 0, this.#levels_data, 0, this.cascade_count * CLIPMAP_LEVEL_STRUCT.aligned_size);
+        const levels_bytes = this.cascade_count * CLIPMAP_LEVEL_STRUCT.aligned_size;
+
+        // what was wanted late, in the last frame's windows, is taken in this frame's lifetime
+        this.#late_taken = this.#late_pending;
+        this.#late_pending = false;
+
+        if (this.#late_taken) {
+            this.#device.queue.writeBuffer(this.#late.levels, 0, this.#late_levels_u8, 0, levels_bytes);
+        }
+
+        this.#device.queue.writeBuffer(this.#levels, 0, this.#levels_data, 0, levels_bytes);
+        this.#late_levels_u8.set(this.#levels_u8);
 
         // 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);
@@ -884,12 +964,25 @@ export class GPUProbeClipmap {
         this.#want_settings.cascade_count = this.cascade_count;
         this.#want_settings.resolution = this.resolution;
         this.#want_settings.frame = this.#frame;
-        this.#ensure_wanted(Math.min(this.#key_count, wants.wanted_bound()));
+        // the late wants can want any point, so with them the list holds every key
+        this.#ensure_wanted(this.#late !== null ? this.#key_count : Math.min(this.#key_count, wants.wanted_bound()));
 
         this.#want_settings.wanted_capacity = this.#wanted_capacity;
         this.#want_settings.anchor.set(this.#anchor);
         this.#want_settings.select_half = this.#select_half;
 
+        const late_want = this.#late_want_settings;
+
+        late_want.cascade_count = this.cascade_count;
+        late_want.resolution = this.resolution;
+        late_want.frame = this.#frame;
+        late_want.wanted_capacity = this.#key_count;
+        late_want.anchor.set(this.#anchor);
+        late_want.select_half = this.#select_half;
+
+        this.#late_settings.resolution = this.resolution;
+        this.#late_settings.wanted_capacity = this.#wanted_capacity;
+        this.#late_settings.late_capacity = this.#key_count;
 
         this.#admit_command_settings.wanted_capacity = this.#wanted_capacity;
 
@@ -902,10 +995,12 @@ export class GPUProbeClipmap {
         this.#schedule_settings.wanted_capacity = this.#wanted_capacity;
         this.#schedule_settings.trace_capacity = trace_capacity;
         this.#schedule_settings.slack = Math.ceil(this.#capacity * PROBE_FREE_SLACK);
+        this.#schedule_settings.idle_periods = idle_periods;
 
         this.#due_settings.capacity = this.#capacity;
         this.#due_settings.trace_capacity = trace_capacity;
         this.#due_settings.frame = this.#frame;
+        this.#due_settings.idle_periods = idle_periods;
 
         this.#trace_command_settings.trace_capacity = trace_capacity;
         this.#trace_command_settings.radiance_resolution = this.radiance_resolution;
@@ -942,10 +1037,12 @@ export class GPUProbeClipmap {
         this.#trace_settings.rays_per_probe = rays_per_probe;
         this.#trace_settings.radiance_resolution = this.radiance_resolution;
         this.#trace_settings.brick_cascade_count = brick_clipmap.cascade_count;
+        this.#trace_settings.brick_atlas_shift = brick_clipmap.atlas_shift;
         this.#trace_settings.t_max = Math.sqrt(3) * brick_clipmap.resolution * brick_clipmap.cell_size(coarsest);
 
         this.#relocate_settings.trace_capacity = trace_capacity;
         this.#relocate_settings.brick_cascade_count = brick_clipmap.cascade_count;
+        this.#relocate_settings.brick_atlas_shift = brick_clipmap.atlas_shift;
 
         const accumulate = this.#accumulate_settings;
 
@@ -1239,6 +1336,27 @@ export class GPUProbeClipmap {
 
         this.#wants.encode(encoder, data, resources, want);
 
+        if (this.#late_taken) {
+            // and what was wanted after the last frame's lifetime, a thread a key
+            const late = this.#late;
+            const taken = this.#late_bindings;
+
+            build_indirect_compute_dispatch_command(PROBE_THREAD_WORKGROUP_SIZE, encoder, late.list, 0, late.command, 0);
+
+            taken.probe_levels = this.#levels;
+            taken.probe_late_levels = late.levels;
+            taken.probe_late_wanted = late.list;
+            taken.probe_late_wanted_bits = late.bits;
+            taken.probe_wanted = this.#wanted;
+            taken.probe_wanted_bits = this.#wanted_bits;
+            taken.settings = this.#late_settings;
+
+            shader_probe_clipmap_want_late.dispatchIndirect({ encoder, bindings: taken, command: late.command });
+
+            // its bits the threads cleared, key by key
+            encoder.clearBuffer(late.list, 0, 4);
+        }
+
         encoder.clearBuffer(this.#trace, 0, 4);
 
         b.settings = this.#admit_command_settings;
@@ -1258,7 +1376,7 @@ export class GPUProbeClipmap {
 
         shader_probe_clipmap_schedule.dispatch({ encoder, bindings: b });
 
-        // the frame's updates: the NEW probes first, then those whose turn it is
+        // the frame's updates: the NEW probes first, then those whose turn it is, waiting or idle
         const due = this.#due_settings;
 
         b.settings = due;
@@ -1581,7 +1699,7 @@ export class GPUProbeClipmap {
         this.#radiance.destroy();
         this.#depth.destroy();
 
-        for (const buffer of [this.#levels, this.#states, this.#estimators, this.#records, this.#free, this.#listed, this.#candidates, this.#counters, this.#dispatch, this.#eviction, ...this.#active, this.#wanted, this.#wanted_bits, this.#trace, this.#origins, this.#maps, this.#guide, this.#resamples, 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]) {
+        for (const buffer of [this.#levels, this.#states, this.#estimators, this.#records, this.#free, this.#listed, this.#candidates, this.#counters, this.#dispatch, this.#eviction, ...this.#active, this.#wanted, this.#wanted_bits, this.#trace, this.#origins, this.#maps, this.#guide, this.#resamples, 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, this.#late?.list, this.#late?.bits, this.#late?.levels, this.#late?.command]) {
             buffer?.destroy();
         }
     }

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

@@ -9,6 +9,16 @@
  * @returns {number}
  */
 export function probe_clipmap_maps_words(radiance_resolution: number, depth_resolution: number): number;
+/**
+ * Periods between an idle probe's updates, and the idle probes the period counts as one waiting: R over
+ * the rays a period an idle probe keeps ({@link PROBE_RAYS_PER_TEXEL_IDLE}), a ray at least. So the
+ * period is the probes' rays over the budget: R a waiting probe, those an idle one.
+ *
+ * @param {number} rays_per_probe rays a uniform update casts, R
+ * @param {number} radiance_resolution octahedral radiance texels a side, n_r
+ * @returns {number} a positive integer
+ */
+export function probe_clipmap_idle_periods(rays_per_probe: number, radiance_resolution: number): number;
 /**
  * Words of a listed probe's guide (`probe_guide`), as the guide passes write it, in this order:
  * - n_r² first rays, by walk position;
@@ -70,7 +80,8 @@ export const PROBE_COUNTER_FREE: number;
  */
 export const PROBE_COUNTER_STARVED: number;
 /**
- * The frame's period T, as schedule sets it (§8.5): frames between a wanted probe's updates.
+ * The frame's period T, as schedule sets it (§8.5): frames between a wanted probe's updates, and
+ * `probe_clipmap_idle_periods` of them between an idle one's.
  * @type {number}
  */
 export const PROBE_COUNTER_PERIOD: number;
@@ -275,6 +286,13 @@ export const PROBE_DEAD_RAYS: number;
  * @type {number}
  */
 export const PROBE_RAYS_PER_TEXEL_MAX: number;
+/**
+ * Rays a period an idle probe keeps, of the radiance texels: a sixteenth, Enshrouded's floor of 16 rays on
+ * its 16×16 map. An idle probe is a live one no want waits on: past its first update, and not wanted since
+ * its last. It keeps them as whole updates, one in {@link probe_clipmap_idle_periods} periods (§8.5).
+ * @type {number}
+ */
+export const PROBE_RAYS_PER_TEXEL_IDLE: number;
 /**
  * Rays a guided update gives one radiance texel at most, the same gather budget as a depth texel's
  * ({@link PROBE_DEPTH_TEXEL_RAYS}). The guide holds each texel's weight down to it and spreads what it

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

@@ -1 +1 @@
-{"version":3,"file":"PROBE_CLIPMAP.d.ts","sourceRoot":"","sources":["../../../../../../../src/shade/renderer/global_illumination/probe_clipmap/probe/PROBE_CLIPMAP.js"],"names":[],"mappings":"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"}
+{"version":3,"file":"PROBE_CLIPMAP.d.ts","sourceRoot":"","sources":["../../../../../../../src/shade/renderer/global_illumination/probe_clipmap/probe/PROBE_CLIPMAP.js"],"names":[],"mappings":"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"}

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

@@ -1,3 +1,4 @@
+import { AGE_EVICTION_BUCKETS } from "../../../gpu_primitive/age_eviction/chunk_age_eviction.js";
 import { UINT32_MAX } from "../../../../../core/binary/UINT32_MAX.js";
 
 /*
@@ -77,7 +78,8 @@ export const PROBE_COUNTER_FREE = 0;
 export const PROBE_COUNTER_STARVED = 1;
 
 /**
- * The frame's period T, as schedule sets it (§8.5): frames between a wanted probe's updates.
+ * The frame's period T, as schedule sets it (§8.5): frames between a wanted probe's updates, and
+ * `probe_clipmap_idle_periods` of them between an idle one's.
  * @type {number}
  */
 export const PROBE_COUNTER_PERIOD = 2;
@@ -102,7 +104,7 @@ export const PROBE_COUNTER_EVICTED = 4;
  * middle one, so the first holds 2⁻¹⁶ s and under and the last 2¹⁵ s, about nine hours, and over.
  * @type {number}
  */
-export const PROBE_AGE_BUCKETS = 32;
+export const PROBE_AGE_BUCKETS = AGE_EVICTION_BUCKETS;
 
 /**
  * The first of {@link PROBE_AGE_BUCKETS} counters: the probes the frame's retire kept and could have evicted,
@@ -336,6 +338,29 @@ export const PROBE_DEAD_RAYS = 16;
  */
 export const PROBE_RAYS_PER_TEXEL_MAX = 4;
 
+/**
+ * Rays a period an idle probe keeps, of the radiance texels: a sixteenth, Enshrouded's floor of 16 rays on
+ * its 16×16 map. An idle probe is a live one no want waits on: past its first update, and not wanted since
+ * its last. It keeps them as whole updates, one in {@link probe_clipmap_idle_periods} periods (§8.5).
+ * @type {number}
+ */
+export const PROBE_RAYS_PER_TEXEL_IDLE = 1 / 16;
+
+/**
+ * Periods between an idle probe's updates, and the idle probes the period counts as one waiting: R over
+ * the rays a period an idle probe keeps ({@link PROBE_RAYS_PER_TEXEL_IDLE}), a ray at least. So the
+ * period is the probes' rays over the budget: R a waiting probe, those an idle one.
+ *
+ * @param {number} rays_per_probe rays a uniform update casts, R
+ * @param {number} radiance_resolution octahedral radiance texels a side, n_r
+ * @returns {number} a positive integer
+ */
+export function probe_clipmap_idle_periods(rays_per_probe, radiance_resolution) {
+    const rays = Math.max(1, PROBE_RAYS_PER_TEXEL_IDLE * radiance_resolution * radiance_resolution);
+
+    return Math.max(1, Math.ceil(rays_per_probe / rays));
+}
+
 /**
  * Rays a guided update gives one radiance texel at most, the same gather budget as a depth texel's
  * ({@link PROBE_DEPTH_TEXEL_RAYS}). The guide holds each texel's weight down to it and spreads what it

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

@@ -1,27 +1,35 @@
 /**
- * A clipmap's probes wanted by the frame's pixels (PROBE_CLIPMAP_PROPOSAL_2026_10_27.md §8.3): one pixel of
- * each screen tile wants the cages its pick reads (`shader_probe_clipmap_want`). The wants of the frustum's
- * probes; a {@link GPUProbeClipmap} records them in its lifetime, between retire and admit.
+ * A clipmap's probes wanted by the pixels of a screen surface (PROBE_CLIPMAP_PROPOSAL_2026_10_27.md §8.3): one
+ * pixel of each screen tile wants the cages its pick reads (`shader_probe_clipmap_want`).
  *
- * Give it the frame's G-buffer with {@link set} before the clipmap's `graph_update`.
+ * The frame's G-buffer is the frustum's probes' own wants, which a {@link GPUProbeClipmap} records in its
+ * lifetime, between retire and admit: give it the G-buffer with {@link set} before the clipmap's
+ * `graph_update`. A surface drawn apart from the G-buffer, whose reader picks probes per pixel, is another
+ * one's, encoded once that surface is drawn into what `GPUProbeClipmap.write_want_bindings` binds.
  */
 export class ProbeClipmapScreenWants {
     /**
-     * The frame's G-buffer and view.
+     * The frame's surface and view.
      *
      * @param {Object} options
-     * @param {number} options.depth graph handle of the frame's depth
-     * @param {number} options.normal graph handle of the G-buffer's normals
+     * @param {number} options.depth graph handle of the surface's reverse-Z depth, zero where it has none
+     * @param {number} options.normal graph handle of its normals, a `uint` texture: a channel holds a normal
+     *   octahedral, as the G-buffer packs its own
      * @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 {ArrayLike<number>} options.resolution the surface's pixels, x and y
+     * @param {number} [options.normal_channel] the channel that holds the normal, 0 to 3: the G-buffer's is 0
+     * @param {boolean} [options.two_sided] whether the surface's reader turns a normal that faces away from the eye
+     *   to face it, as the reader of a surface seen from both sides does
      */
-    set({ depth, normal, camera, stbn, resolution }: {
+    set({ depth, normal, camera, stbn, resolution, normal_channel, two_sided }: {
         depth: number;
         normal: number;
         camera: GPUBuffer;
         stbn: any;
         resolution: ArrayLike<number>;
+        normal_channel?: number;
+        two_sided?: boolean;
     }): void;
     /**
      * @returns {number} the most points a frame's wants list: a pixel of each tile, the eight points of a cage in
@@ -29,7 +37,7 @@ export class ProbeClipmapScreenWants {
      */
     wanted_bound(): number;
     /**
-     * Declare what the wants read on the lifetime's pass.
+     * Declare what the wants read on the pass that encodes them.
      *
      * @param {import("../../../../../engine/graphics/render/frame_graph/FramePassBuilder.js").FramePassBuilder} pass
      * @param {Object} data the pass's data, which {@link encode} is given back
@@ -37,7 +45,7 @@ export class ProbeClipmapScreenWants {
     graph_declare(pass: import("../../../../../engine/graphics/render/frame_graph/FramePassBuilder.js").FramePassBuilder, data: any): void;
     /**
      * @param {GPUCommandEncoder} encoder
-     * @param {Object} data the lifetime pass's data
+     * @param {Object} data the encoding pass's data
      * @param {*} resources the frame graph's resources
      * @param {Object} clipmap what the wanting clipmap binds: `probe_levels`, `probe_wanted`,
      *   `probe_wanted_bits` and its want settings as `settings`

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

@@ -1 +1 @@
-{"version":3,"file":"ProbeClipmapScreenWants.d.ts","sourceRoot":"","sources":["../../../../../../../src/shade/renderer/global_illumination/probe_clipmap/probe/ProbeClipmapScreenWants.js"],"names":[],"mappings":"AAIA;;;;;;GAMG;AACH;IAeI;;;;;;;;;OASG;IACH;QAN2B,KAAK,EAArB,MAAM;QACU,MAAM,EAAtB,MAAM;QACa,MAAM;QACd,IAAI;QACY,UAAU,EAArC,UAAU,MAAM,CAAC;aAqB3B;IAED;;;OAGG;IACH,gBAHa,MAAM,CAKlB;IAED;;;;;OAKG;IACH,oBAHW,OAAO,uEAAuE,EAAE,gBAAgB,mBAQ1G;IAED;;;;;;OAMG;IACH,kFAcC;;CACJ"}
+{"version":3,"file":"ProbeClipmapScreenWants.d.ts","sourceRoot":"","sources":["../../../../../../../src/shade/renderer/global_illumination/probe_clipmap/probe/ProbeClipmapScreenWants.js"],"names":[],"mappings":"AAIA;;;;;;;;GAQG;AACH;IAsBI;;;;;;;;;;;;;OAaG;IACH;QAV2B,KAAK,EAArB,MAAM;QACU,MAAM,EAAtB,MAAM;QAEa,MAAM;QACd,IAAI;QACY,UAAU,EAArC,UAAU,MAAM,CAAC;QACA,cAAc,GAA/B,MAAM;QACY,SAAS,GAA3B,OAAO;aA2BjB;IAED;;;OAGG;IACH,gBAHa,MAAM,CAKlB;IAED;;;;;OAKG;IACH,oBAHW,OAAO,uEAAuE,EAAE,gBAAgB,mBAQ1G;IAED;;;;;;OAMG;IACH,kFAoBC;;CACJ"}

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

@@ -3,11 +3,13 @@ import { PROBE_WANT_TILE, PROBE_WANT_WORKGROUP_TILES } from "./PROBE_CLIPMAP.js"
 import { shader_probe_clipmap_want } from "./shader_probe_clipmap_want.js";
 
 /**
- * A clipmap's probes wanted by the frame's pixels (PROBE_CLIPMAP_PROPOSAL_2026_10_27.md §8.3): one pixel of
- * each screen tile wants the cages its pick reads (`shader_probe_clipmap_want`). The wants of the frustum's
- * probes; a {@link GPUProbeClipmap} records them in its lifetime, between retire and admit.
+ * A clipmap's probes wanted by the pixels of a screen surface (PROBE_CLIPMAP_PROPOSAL_2026_10_27.md §8.3): one
+ * pixel of each screen tile wants the cages its pick reads (`shader_probe_clipmap_want`).
  *
- * Give it the frame's G-buffer with {@link set} before the clipmap's `graph_update`.
+ * The frame's G-buffer is the frustum's probes' own wants, which a {@link GPUProbeClipmap} records in its
+ * lifetime, between retire and admit: give it the G-buffer with {@link set} before the clipmap's
+ * `graph_update`. A surface drawn apart from the G-buffer, whose reader picks probes per pixel, is another
+ * one's, encoded once that surface is drawn into what `GPUProbeClipmap.write_want_bindings` binds.
  */
 export class ProbeClipmapScreenWants {
     #depth = -1;
@@ -20,32 +22,48 @@ export class ProbeClipmapScreenWants {
 
     #groups = [0, 0];
 
+    #normal_channel = 0;
+
+    #two_sided = false;
+
+    /** The wanting clipmap's settings and how this surface's normals are read. */
+    #settings = { cascade_count: 0, resolution: 0, frame: 0, wanted_capacity: 0, anchor: null, select_half: 0, normal_channel: 0, two_sided: 0 };
+
     #tiles = 0;
 
     #bindings = {};
 
     /**
-     * The frame's G-buffer and view.
+     * The frame's surface and view.
      *
      * @param {Object} options
-     * @param {number} options.depth graph handle of the frame's depth
-     * @param {number} options.normal graph handle of the G-buffer's normals
+     * @param {number} options.depth graph handle of the surface's reverse-Z depth, zero where it has none
+     * @param {number} options.normal graph handle of its normals, a `uint` texture: a channel holds a normal
+     *   octahedral, as the G-buffer packs its own
      * @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 {ArrayLike<number>} options.resolution the surface's pixels, x and y
+     * @param {number} [options.normal_channel] the channel that holds the normal, 0 to 3: the G-buffer's is 0
+     * @param {boolean} [options.two_sided] whether the surface's reader turns a normal that faces away from the eye
+     *   to face it, as the reader of a surface seen from both sides does
      */
-    set({ depth, normal, camera, stbn, resolution }) {
+    set({ depth, normal, camera, stbn, resolution, normal_channel = 0, two_sided = false }) {
         assert.isNonNegativeInteger(depth, 'depth');
         assert.isNonNegativeInteger(normal, 'normal');
         assert.defined(camera, 'camera');
         assert.defined(stbn, 'stbn');
         assert.isPositiveInteger(resolution[0], 'resolution[0]');
         assert.isPositiveInteger(resolution[1], 'resolution[1]');
+        assert.isNonNegativeInteger(normal_channel, 'normal_channel');
+        assert.lessThan(normal_channel, 4, 'normal_channel');
+        assert.isBoolean(two_sided, 'two_sided');
 
         this.#depth = depth;
         this.#normal = normal;
         this.#camera = camera;
         this.#stbn = stbn;
+        this.#normal_channel = normal_channel;
+        this.#two_sided = two_sided;
 
         const tiles_x = Math.ceil(resolution[0] / PROBE_WANT_TILE);
         const tiles_y = Math.ceil(resolution[1] / PROBE_WANT_TILE);
@@ -64,7 +82,7 @@ export class ProbeClipmapScreenWants {
     }
 
     /**
-     * Declare what the wants read on the lifetime's pass.
+     * Declare what the wants read on the pass that encodes them.
      *
      * @param {import("../../../../../engine/graphics/render/frame_graph/FramePassBuilder.js").FramePassBuilder} pass
      * @param {Object} data the pass's data, which {@link encode} is given back
@@ -78,13 +96,19 @@ export class ProbeClipmapScreenWants {
 
     /**
      * @param {GPUCommandEncoder} encoder
-     * @param {Object} data the lifetime pass's data
+     * @param {Object} data the encoding pass's data
      * @param {*} resources the frame graph's resources
      * @param {Object} clipmap what the wanting clipmap binds: `probe_levels`, `probe_wanted`,
      *   `probe_wanted_bits` and its want settings as `settings`
      */
     encode(encoder, data, resources, clipmap) {
         const b = Object.assign(this.#bindings, clipmap);
+        const settings = Object.assign(this.#settings, clipmap.settings);
+
+        settings.normal_channel = this.#normal_channel;
+        settings.two_sided = this.#two_sided ? 1 : 0;
+
+        b.settings = settings;
 
         b.gBufferDepth = resources.get(data.want_depth);
         b.gBufferNormals = resources.get(data.want_normal);

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

@@ -1 +1 @@
-{"version":3,"file":"chunk_probe_clipmap.d.ts","sourceRoot":"","sources":["../../../../../../../src/shade/renderer/global_illumination/probe_clipmap/probe/chunk_probe_clipmap.js"],"names":[],"mappings":"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"}
+{"version":3,"file":"chunk_probe_clipmap.d.ts","sourceRoot":"","sources":["../../../../../../../src/shade/renderer/global_illumination/probe_clipmap/probe/chunk_probe_clipmap.js"],"names":[],"mappings":"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"}

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

@@ -1,3 +1,4 @@
+import { chunk_age_eviction } from "../../../gpu_primitive/age_eviction/chunk_age_eviction.js";
 import { COLLECTION_U32_STRUCT_READ } from "../../../gpu_primitive/COLLECTION_U32_STRUCT_READ.js";
 import { COLLECTION_U32_STRUCT_WRITE } from "../../../gpu_primitive/COLLECTION_U32_STRUCT_WRITE.js";
 import { chunk_clipmap_key } from "../../../shader/chunk/clipmap/chunk_clipmap_key.js";
@@ -616,7 +617,7 @@ fn probe_state(kind: u32, updates: u32) -> u32 {
 }
 
 fn probe_clipmap_age_bucket(age: u32) -> u32 {
-    return min(32u - countLeadingZeros(age), PROBE_AGE_BUCKETS - 1u);
+    return age_eviction_bucket(age);
 }
 
 fn probe_record_flags(back_face: f32, cascade: u32) -> u32 {
@@ -661,6 +662,7 @@ fn probe_clipmap_offset_decode(word: u32, spacing: f32) -> vec3<f32> {
     return vec3<f32>(steps) * (${PROBE_RELOCATION_LIMIT} * spacing / 511.0);
 }
 `, [
+    chunk_age_eviction,
     PROBE_RECORD_STRUCT.declaration_chunk,
     chunk_brick4_sh3_color_pack,
     chunk_brick4_sh3_color_unpack,

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

@@ -0,0 +1,40 @@
+/**
+ * The cages a reader anywhere inside a world box can read (PROBE_CLIPMAP_PROPOSAL_2026_10_27.md §8.3, §9.1), for
+ * a want that knows its readers by their bounds alone: a meshlet's, whose fragments pick probes.
+ *
+ * ```wgsl
+ * struct ProbeClipmapBoxCages { first: vec3<i32>, dims: vec3<u32> }
+ * fn probe_clipmap_box_cascades(box_min: vec3<f32>, box_max: vec3<f32>, cascade_count: u32, anchor: vec3<f32>, select_half: f32) -> vec2<u32>
+ * fn probe_clipmap_box_cages(box_min: vec3<f32>, box_max: vec3<f32>, cascade: u32, anchor: vec3<f32>, select_half: f32) -> ProbeClipmapBoxCages
+ * fn probe_clipmap_box_cage_count(box_min: vec3<f32>, box_max: vec3<f32>, cascade_count: u32, anchor: vec3<f32>, select_half: f32) -> u32
+ * fn probe_clipmap_cage_is_read(cascade: u32, cage: vec3<i32>, anchor: vec3<f32>, select_half: f32) -> bool
+ * fn probe_clipmap_cage_meets_box(cascade: u32, cage: vec3<i32>, local_min: vec3<f32>, local_max: vec3<f32>, transform: mat4x4<f32>) -> bool
+ * ```
+ *
+ * A reader at p reads the cage of p moved by at most {@link PROBE_RECEIVER_BIAS} of a spacing, in the cascade
+ * `probe_clipmap_select_in` answers for p and, in its blend skirt, in the next. So over a box:
+ *
+ * - `probe_clipmap_box_cascades`: the cascades its points can read, the first and one past the last, equal
+ *   where the box lies outside every selection box. From the cascade its point nearest the anchor selects to
+ *   the one its farthest does, and one more where the farthest lies in that one's skirt.
+ * - `probe_clipmap_box_cages`: in one of those, the block of cages such a reader can read: those of the box's
+ *   part inside the cascade's selection box, grown by the bias, and kept to the cascade's cage window. `dims`
+ *   holds a zero where there is none.
+ * - `probe_clipmap_box_cage_count`: the cages of every block.
+ *
+ * The blocks are a superset of what any surface inside the box reads. Two tests a thread a cage can afford
+ * narrow them, each still a superset:
+ *
+ * - `probe_clipmap_cage_is_read`: whether a point within the bias of the cage selects its cascade, or the
+ *   finer one in its skirt; a block holds cages no point reads where its box crosses a selection box's face.
+ * - `probe_clipmap_cage_meets_box`: whether the cage, grown by the bias, meets the box as it lies in its own
+ *   space, by its three axes: a flat box turned away from the world's axes fills its world box with cages
+ *   it never crosses.
+ *
+ * Reads `probe_levels`.
+ *
+ * @type {CodeChunk}
+ */
+export const chunk_probe_clipmap_box_cages: CodeChunk;
+import { CodeChunk } from "../../../shader/compiler/CodeChunk.js";
+//# sourceMappingURL=chunk_probe_clipmap_box_cages.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"chunk_probe_clipmap_box_cages.d.ts","sourceRoot":"","sources":["../../../../../../../src/shade/renderer/global_illumination/probe_clipmap/probe/chunk_probe_clipmap_box_cages.js"],"names":[],"mappings":"AAKA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAoCG;AACH,4CAFU,SAAS,CAmIZ;0BA1KmB,uCAAuC"}