@woosh/meep-engine 3.64.1 → 3.65.0

package/src/shade/renderer/global_illumination/probe_clipmap/material/chunk_brick_material.js

@@ -36,13 +36,14 @@ export const BRICK_MATERIAL_EMISSIVE_RESOURCE = ShaderResourceDescriptor.texture
  *
  * ```wgsl
  * fn brick_material_tile(slot: u32) -> vec3<u32>
- * fn brick_material_corners(slot: u32, local: vec3<f32>, normal: vec3<f32>) -> SurfaceMaterialCorners
+ * fn brick_material_corners(slot: u32, local: vec3<f32>, normal: vec3<f32>, atlas_shift: u32) -> SurfaceMaterialCorners
  * ```
  *
  * `brick_material_tile` is the slot's tile's origin in the planes. `local` is a point by the surface in
  * voxels from the cell's corner, a hit's position, and `normal` the field's normal there. Surfaces
  * within {@link BRICK_TRACE_HIT_VOXELS} of each other are one: a ray stands on a surface from anywhere
- * that far out of it, so it cannot tell closer ones apart.
+ * that far out of it, so it cannot tell closer ones apart. `atlas_shift` is the brick atlas's footprint, as
+ * `chunk_brick_clipmap_sample` takes it; the material planes' own footprint is read off them, once a read.
  *
  * @type {CodeChunk}
  */
@@ -55,11 +56,11 @@ fn brick_material_tile(slot: u32) -> vec3<u32> {
     return tile_atlas_slot_origin(slot, textureDimensions(brick_material_albedo_codes, 0).xy / t, vec3<u32>(t));
 }
 
-fn brick_material_corners(slot: u32, local: vec3<f32>, normal: vec3<f32>) -> SurfaceMaterialCorners {
-    let point = surface_material_point(local, brick_clipmap_sample(slot, local, 1.0), normal);
+fn brick_material_corners(slot: u32, local: vec3<f32>, normal: vec3<f32>, atlas_shift: u32) -> SurfaceMaterialCorners {
+    let point = surface_material_point(local, brick_clipmap_sample(slot, local, 1.0, atlas_shift), normal);
     let present = surface_material_present(brick_material_albedo_codes, brick_material_tile(slot) + surface_material_base(point));
 
-    return surface_material_corners(brick_atlas, brick_clipmap_slot_texel(slot), point, present, normal, ${BRICK_TRACE_HIT_VOXELS});
+    return surface_material_corners(brick_atlas, brick_clipmap_slot_texel(slot, atlas_shift), point, present, normal, ${BRICK_TRACE_HIT_VOXELS});
 }
 `, [
         chunk_surface_material_read,
@@ -74,7 +75,7 @@ chunk_brick_material_corners.requireResource(BRICK_MATERIAL_ALBEDO_RESOURCE);
  * (`surface_material_surface`):
  *
  * ```wgsl
- * fn brick_material_surface(slot: u32, local: vec3<f32>, normal: vec3<f32>) -> SurfaceMaterialSurface
+ * fn brick_material_surface(slot: u32, local: vec3<f32>, normal: vec3<f32>, atlas_shift: u32) -> SurfaceMaterialSurface
  * ```
  *
  * @type {CodeChunk}
@@ -82,8 +83,8 @@ chunk_brick_material_corners.requireResource(BRICK_MATERIAL_ALBEDO_RESOURCE);
 export const chunk_brick_material_surface = CodeChunk.from(
     //language=WGSL
     `
-fn brick_material_surface(slot: u32, local: vec3<f32>, normal: vec3<f32>) -> SurfaceMaterialSurface {
-    return surface_material_surface(brick_atlas, brick_material_albedo_codes, brick_material_emissive_codes, brick_material_tile(slot), brick_material_corners(slot, local, normal));
+fn brick_material_surface(slot: u32, local: vec3<f32>, normal: vec3<f32>, atlas_shift: u32) -> SurfaceMaterialSurface {
+    return surface_material_surface(brick_atlas, brick_material_albedo_codes, brick_material_emissive_codes, brick_material_tile(slot), brick_material_corners(slot, local, normal, atlas_shift));
 }
 `, [
         chunk_brick_material_corners,
@@ -98,7 +99,7 @@ chunk_brick_material_surface.requireResource(BRICK_MATERIAL_EMISSIVE_RESOURCE);
  * average, over the reads a probe's rays make:
  *
  * ```wgsl
- * fn brick_material_surface_pick(slot: u32, local: vec3<f32>, normal: vec3<f32>, u: f32) -> SurfaceMaterialSurface
+ * fn brick_material_surface_pick(slot: u32, local: vec3<f32>, normal: vec3<f32>, u: f32, atlas_shift: u32) -> SurfaceMaterialSurface
  * ```
  *
  * @type {CodeChunk}
@@ -106,8 +107,8 @@ chunk_brick_material_surface.requireResource(BRICK_MATERIAL_EMISSIVE_RESOURCE);
 export const chunk_brick_material_surface_pick = CodeChunk.from(
     //language=WGSL
     `
-fn brick_material_surface_pick(slot: u32, local: vec3<f32>, normal: vec3<f32>, u: f32) -> SurfaceMaterialSurface {
-    let corners = brick_material_corners(slot, local, normal);
+fn brick_material_surface_pick(slot: u32, local: vec3<f32>, normal: vec3<f32>, u: f32, atlas_shift: u32) -> SurfaceMaterialSurface {
+    let corners = brick_material_corners(slot, local, normal, atlas_shift);
 
     return surface_material_surface_at(brick_material_albedo_codes, brick_material_emissive_codes, brick_material_tile(slot), corners, surface_material_pick(brick_atlas, corners, u));
 }
@@ -123,7 +124,7 @@ chunk_brick_material_surface_pick.requireResource(BRICK_MATERIAL_EMISSIVE_RESOUR
  * texels {@link chunk_brick_material_surface} takes:
  *
  * ```wgsl
- * fn brick_material_metal_rough(slot: u32, local: vec3<f32>, normal: vec3<f32>) -> SurfaceMaterialMetalRough
+ * fn brick_material_metal_rough(slot: u32, local: vec3<f32>, normal: vec3<f32>, atlas_shift: u32) -> SurfaceMaterialMetalRough
  * ```
  *
  * @type {CodeChunk}
@@ -131,8 +132,8 @@ chunk_brick_material_surface_pick.requireResource(BRICK_MATERIAL_EMISSIVE_RESOUR
 export const chunk_brick_material_metal_rough = CodeChunk.from(
     //language=WGSL
     `
-fn brick_material_metal_rough(slot: u32, local: vec3<f32>, normal: vec3<f32>) -> SurfaceMaterialMetalRough {
-    return surface_material_metal_rough(brick_atlas, brick_material_metal_rough_codes, brick_material_tile(slot), brick_material_corners(slot, local, normal));
+fn brick_material_metal_rough(slot: u32, local: vec3<f32>, normal: vec3<f32>, atlas_shift: u32) -> SurfaceMaterialMetalRough {
+    return surface_material_metal_rough(brick_atlas, brick_material_metal_rough_codes, brick_material_tile(slot), brick_material_corners(slot, local, normal, atlas_shift));
 }
 `, [
         chunk_brick_material_corners,

package/src/shade/renderer/global_illumination/probe_clipmap/material/shader_brick_material_gather.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"shader_brick_material_gather.d.ts","sourceRoot":"","sources":["../../../../../../../src/shade/renderer/global_illumination/probe_clipmap/material/shader_brick_material_gather.js"],"names":[],"mappings":"AA0CA;;GAEG;AACH,6CAFU,YAAY,CAOY;AAmClC;;;;;;;;;;;;;;;;;GAiBG;AACH,2CAFU,aAAa,CA0EpB;6BA1J0B,sCAAsC;8BALrC,kCAAkC"}
+{"version":3,"file":"shader_brick_material_gather.d.ts","sourceRoot":"","sources":["../../../../../../../src/shade/renderer/global_illumination/probe_clipmap/material/shader_brick_material_gather.js"],"names":[],"mappings":"AA0CA;;GAEG;AACH,6CAFU,YAAY,CASY;AAmClC;;;;;;;;;;;;;;;;;GAiBG;AACH,2CAFU,aAAa,CA0EpB;6BA5J0B,sCAAsC;8BALrC,kCAAkC"}

package/src/shade/renderer/global_illumination/probe_clipmap/material/shader_brick_material_gather.js

@@ -48,6 +48,8 @@ export const BRICK_MATERIAL_GATHER_SETTINGS = WebGPUStruct.from({
     ring_capacity: u32,
     /** cells a cascade's window has a side */
     resolution: u32,
+    /** the brick atlas's footprint as shifts, `GPUBrickClipmap#atlas_shift` */
+    brick_atlas_shift: u32,
 }, "BrickMaterialGatherSettings");
 
 /**
@@ -133,8 +135,8 @@ fn main(
 
     // in voxels: a voxel of 1
     let local = vec3<f32>(t);
-    let d = brick_clipmap_sample(taken.entry, local, 1.0);
-    let n = brick_clipmap_normal(taken.entry, local);
+    let d = brick_clipmap_sample(taken.entry, local, 1.0, settings.brick_atlas_shift);
+    let n = brick_clipmap_normal(taken.entry, local, settings.brick_atlas_shift);
 
     if (!(any(n != vec3<f32>(0.0)) && abs(d) * max(max(abs(n.x), abs(n.y)), abs(n.z)) < 1.0)) {
         return;

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

@@ -31,8 +31,11 @@
  * **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
@@ -136,6 +139,20 @@ export class GPUProbeClipmap {
      * @returns {Object} bindings
      */
     write_sampling_bindings(bindings: any): any;
+    /**
+     * 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: any): any;
     /**
      * @returns {GPUTexture}
      */

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

@@ -1 +1 @@
-{"version":3,"file":"GPUProbeClipmap.d.ts","sourceRoot":"","sources":["../../../../../../../src/shade/renderer/global_illumination/probe_clipmap/probe/GPUProbeClipmap.js"],"names":[],"mappings":"AA0HA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAsDG;AACH;IA2RI;;;;;;;;;;;;;;;;;;;OAmBG;IACH;QAjB2B,aAAa,EAA7B,MAAM;QAEU,UAAU,EAA1B,MAAM;QAKU,OAAO,EAAvB,MAAM;QACU,mBAAmB,EAAnC,MAAM;QAEU,gBAAgB,EAAhC,MAAM;QACW,cAAc,EAA/B,OAAO;QAES,KAAK,EAArB,MAAM;QACU,QAAQ,EAAxB,MAAM;OAmHhB;IA9ZD;;;OAGG;IACH,wBAHU,MAAM,CAGF;IAEd;;;;OAIG;IACH,qBAHU,MAAM,CAGL;IAEX;;;;OAIG;IACH,kBAHU,MAAM,CAGR;IAER;;;;OAIG;IACH,8BAHU,MAAM,CAGI;IAEpB;;;;OAIG;IACH,2BAHU,MAAM,CAGC;IAEjB;;;;;OAKG;IACH,yBAHU,OAAO,CAGF;IAEf;;;;OAIG;IACH,gBAHU,MAAM,CAGV;IAiXN;;;;;;;;OAQG;IACH,4CAUC;IAED;;OAEG;IACH,8BAEC;IAED;;;;;OAKG;IACH,uBAEC;IAED;;;OAGG;IACH,yBAEC;IAED;;;OAGG;IACH,sBAEC;IAGD;;;OAGG;IACH,0BAEC;IAED;;;;;OAKG;IACH,wBAEC;IAED;;;OAGG;IACH,uBAEC;IAED;;;;OAIG;IACH,gBAJW,MAAM,QACN,MAAM,GACJ,MAAM,CAIlB;IAED;;;OAGG;IACH,mBAHW,MAAM,GACJ,MAAM,CAIlB;IAED;;;OAGG;IACH,oBAHW,oBAAoB,GAClB,OAAO,CAQnB;IAED;;;;;;;OAOG;IACH,SAJW,MAAM,KACN,MAAM,KACN,MAAM,QAkChB;IAED;;;;;;;;OAQG;IACH,sBAFW,eAAe,QA+BzB;IAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OA8BG;IACH;QAzB+B,KAAK,EAAzB,UAAU;QACiB,KAAK,EAAhC,iBAAiB;QACD,eAAe,EAA/B,MAAM;QACU,UAAU,EAA1B,MAAM;QACU,cAAc,EAA9B,MAAM;QACyD,aAAa,EAA5E,OAAO,6BAA6B,EAAE,eAAe;QAErC,MAAM,EAAtB,MAAM;QAE+D,KAAK,EAA1E,OAAO,mCAAmC,EAAE,eAAe;QAEP,QAAQ,EAA5D;YAAC,cAAc,qBAA0B;SAAC;QAEzB,kBAAkB,EAAnC,OAAO;QAEU,cAAc,EAA/B,OAAO;QAEiC,QAAQ,EAAhD;YAAC,MAAM,EAAE,MAAM,CAAC;YAAC,IAAI,EAAE,MAAM,CAAA;SAAC;QAEL,YAAY,EAArC,eAAe;QACU,eAAe,EAAxC,eAAe;QACC,QAAQ,EAAxB,MAAM;aA0OhB;IA6gBD,gBAcC;;CACJ;mCAn9CY,OAAO,4BAA4B,EAAE,oBAAoB;yBACzD,OAAO,iEAAiE,EAAE,UAAU;gCACpF,OAAO,8BAA8B,EAAE,uBAAuB,GAAC,OAAO,2BAA2B,EAAE,oBAAoB"}
+{"version":3,"file":"GPUProbeClipmap.d.ts","sourceRoot":"","sources":["../../../../../../../src/shade/renderer/global_illumination/probe_clipmap/probe/GPUProbeClipmap.js"],"names":[],"mappings":"AA6HA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAyDG;AACH;IAmTI;;;;;;;;;;;;;;;;;;;OAmBG;IACH;QAjB2B,aAAa,EAA7B,MAAM;QAEU,UAAU,EAA1B,MAAM;QAKU,OAAO,EAAvB,MAAM;QACU,mBAAmB,EAAnC,MAAM;QAEU,gBAAgB,EAAhC,MAAM;QACW,cAAc,EAA/B,OAAO;QAES,KAAK,EAArB,MAAM;QACU,QAAQ,EAAxB,MAAM;OAmHhB;IAtbD;;;OAGG;IACH,wBAHU,MAAM,CAGF;IAEd;;;;OAIG;IACH,qBAHU,MAAM,CAGL;IAEX;;;;OAIG;IACH,kBAHU,MAAM,CAGR;IAER;;;;OAIG;IACH,8BAHU,MAAM,CAGI;IAEpB;;;;OAIG;IACH,2BAHU,MAAM,CAGC;IAEjB;;;;;OAKG;IACH,yBAHU,OAAO,CAGF;IAEf;;;;OAIG;IACH,gBAHU,MAAM,CAGV;IAyYN;;;;;;;;OAQG;IACH,4CAUC;IAED;;;;;;;;;;;;OAYG;IACH,wCAuBC;IAED;;OAEG;IACH,8BAEC;IAED;;;;;OAKG;IACH,uBAEC;IAED;;;OAGG;IACH,yBAEC;IAED;;;OAGG;IACH,sBAEC;IAGD;;;OAGG;IACH,0BAEC;IAED;;;;;OAKG;IACH,wBAEC;IAED;;;OAGG;IACH,uBAEC;IAED;;;;OAIG;IACH,gBAJW,MAAM,QACN,MAAM,GACJ,MAAM,CAIlB;IAED;;;OAGG;IACH,mBAHW,MAAM,GACJ,MAAM,CAIlB;IAED;;;OAGG;IACH,oBAHW,oBAAoB,GAClB,OAAO,CAQnB;IAED;;;;;;;OAOG;IACH,SAJW,MAAM,KACN,MAAM,KACN,MAAM,QAkChB;IAED;;;;;;;;OAQG;IACH,sBAFW,eAAe,QA+BzB;IAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OA8BG;IACH;QAzB+B,KAAK,EAAzB,UAAU;QACiB,KAAK,EAAhC,iBAAiB;QACD,eAAe,EAA/B,MAAM;QACU,UAAU,EAA1B,MAAM;QACU,cAAc,EAA9B,MAAM;QACyD,aAAa,EAA5E,OAAO,6BAA6B,EAAE,eAAe;QAErC,MAAM,EAAtB,MAAM;QAE+D,KAAK,EAA1E,OAAO,mCAAmC,EAAE,eAAe;QAEP,QAAQ,EAA5D;YAAC,cAAc,qBAA0B;SAAC;QAEzB,kBAAkB,EAAnC,OAAO;QAEU,cAAc,EAA/B,OAAO;QAEiC,QAAQ,EAAhD;YAAC,MAAM,EAAE,MAAM,CAAC;YAAC,IAAI,EAAE,MAAM,CAAA;SAAC;QAEL,YAAY,EAArC,eAAe;QACU,eAAe,EAAxC,eAAe;QACC,QAAQ,EAAxB,MAAM;aAuQhB;IAkiBD,gBAcC;;CACJ;mCAtkDY,OAAO,4BAA4B,EAAE,oBAAoB;yBACzD,OAAO,iEAAiE,EAAE,UAAU;gCACpF,OAAO,8BAA8B,EAAE,uBAAuB,GAAC,OAAO,2BAA2B,EAAE,oBAAoB"}

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"}