@woosh/meep-engine 3.64.1 → 3.67.0

package/src/shade/renderer/global_illumination/probe_clipmap/brick/chunk_brick_clipmap_trace.js

@@ -9,7 +9,7 @@ import { chunk_aabb3_distance_to_ray_v2 } from "../../../shader/chunk/geometry/a
 import { CodeChunk } from "../../../shader/compiler/CodeChunk.js";
 import { ShaderResourceDescriptor } from "../../../shader/resource/ShaderResourceDescriptor.js";
 import { WebGPUArray } from "../../../shader/type/WebGPUArray.js";
-import { chunk_tile_atlas_slot_origin } from "../../../texture/atlas/chunk_tile_atlas_slot_origin.js";
+import { chunk_tile_atlas_slot_origin_shift } from "../../../texture/atlas/chunk_tile_atlas_slot_origin.js";
 import {
     BRICK_OCCUPANCY_BLOCK,
     BRICK_TRACE_HIT,
@@ -73,47 +73,51 @@ export const BRICK_LEVELS_RESOURCE = ShaderResourceDescriptor.uniform("brick_lev
  * A brick's distance at a point of its cell, where its slot sits in the atlas, and the field's gradient.
  *
  * ```wgsl
- * fn brick_clipmap_sample(slot: u32, local: vec3<f32>, voxel: f32) -> f32 // local in voxels from the cell's corner
- * fn brick_clipmap_slot_texel(slot: u32) -> vec3<u32>                      // the slot's texel 0 in the atlas
- * fn brick_clipmap_normal(slot: u32, local: vec3<f32>) -> vec3<f32>       // out of the solid, unit length
+ * fn brick_clipmap_sample(slot: u32, local: vec3<f32>, voxel: f32, atlas_shift: u32) -> f32 // local in voxels from the cell's corner
+ * fn brick_clipmap_slot_texel(slot: u32, atlas_shift: u32) -> vec3<u32>                      // the slot's texel 0 in the atlas
+ * fn brick_clipmap_normal(slot: u32, local: vec3<f32>, atlas_shift: u32) -> vec3<f32>       // out of the solid, unit length
  * ```
  *
  * One hardware trilinear tap of the atlas at texel `slot_origin + 0.5 + local`, `local` clamped to the
  * brick's [0, 7]: it never reads a neighbouring slot (§7.2). The gradient is a tetrahedral one, four
  * taps half a voxel off, each clamped the same way.
  *
+ * `atlas_shift` is the atlas's footprint, `GPUBrickClipmap#atlas_shift`, which every reader takes in its
+ * immediate data and passes down: a slot is found with shifts (`tile_atlas_slot_origin_shift`), with no
+ * texture query and no divide in front of the tap.
+ *
  * @type {CodeChunk}
  */
 export const chunk_brick_clipmap_sample = CodeChunk.from(
     //language=WGSL
     `
-fn brick_clipmap_slot_texel(slot: u32) -> vec3<u32> {
-    return tile_atlas_slot_origin(slot, textureDimensions(brick_atlas, 0).xy / ${MESH_SDF_BRICK_TEXELS}u, vec3<u32>(${MESH_SDF_BRICK_TEXELS}u));
+fn brick_clipmap_slot_texel(slot: u32, atlas_shift: u32) -> vec3<u32> {
+    return tile_atlas_slot_origin_shift(slot, atlas_shift, vec3<u32>(${MESH_SDF_BRICK_TEXELS}u));
 }
 
-fn brick_clipmap_tap(slot: u32, local: vec3<f32>) -> f32 {
+fn brick_clipmap_tap(slot: u32, local: vec3<f32>, atlas_shift: u32) -> f32 {
     let atlas_size = textureDimensions(brick_atlas, 0);
-    let uvw = (vec3<f32>(brick_clipmap_slot_texel(slot)) + 0.5 + clamp(local, vec3<f32>(0.0), vec3<f32>(${MESH_SDF_BRICK_VOXELS}.0))) / vec3<f32>(atlas_size);
+    let uvw = (vec3<f32>(brick_clipmap_slot_texel(slot, atlas_shift)) + 0.5 + clamp(local, vec3<f32>(0.0), vec3<f32>(${MESH_SDF_BRICK_VOXELS}.0))) / vec3<f32>(atlas_size);
 
     return textureSampleLevel(brick_atlas, brick_sampler, uvw, 0.0).r;
 }
 
-fn brick_clipmap_sample(slot: u32, local: vec3<f32>, voxel: f32) -> f32 {
+fn brick_clipmap_sample(slot: u32, local: vec3<f32>, voxel: f32, atlas_shift: u32) -> f32 {
     let band = BRICK_CLIPMAP_BAND_VOXELS * voxel;
 
-    return fma(brick_clipmap_tap(slot, local), 2.0 * band, -band);
+    return fma(brick_clipmap_tap(slot, local, atlas_shift), 2.0 * band, -band);
 }
 
-fn brick_clipmap_normal(slot: u32, local: vec3<f32>) -> vec3<f32> {
+fn brick_clipmap_normal(slot: u32, local: vec3<f32>, atlas_shift: u32) -> vec3<f32> {
     let a = vec3<f32>(1.0, -1.0, -1.0);
     let b = vec3<f32>(-1.0, -1.0, 1.0);
     let c = vec3<f32>(-1.0, 1.0, -1.0);
     let d = vec3<f32>(1.0, 1.0, 1.0);
 
-    let gradient = a * brick_clipmap_tap(slot, local + 0.5 * a)
-        + b * brick_clipmap_tap(slot, local + 0.5 * b)
-        + c * brick_clipmap_tap(slot, local + 0.5 * c)
-        + d * brick_clipmap_tap(slot, local + 0.5 * d);
+    let gradient = a * brick_clipmap_tap(slot, local + 0.5 * a, atlas_shift)
+        + b * brick_clipmap_tap(slot, local + 0.5 * b, atlas_shift)
+        + c * brick_clipmap_tap(slot, local + 0.5 * c, atlas_shift)
+        + d * brick_clipmap_tap(slot, local + 0.5 * d, atlas_shift);
 
     let length_sqr = dot(gradient, gradient);
 
@@ -122,7 +126,7 @@ fn brick_clipmap_normal(slot: u32, local: vec3<f32>) -> vec3<f32> {
 }
 `, [
         chunk_brick_clipmap,
-        chunk_tile_atlas_slot_origin,
+        chunk_tile_atlas_slot_origin_shift,
     ]);
 
 chunk_brick_clipmap_sample.requireResource(BRICK_ATLAS_TEXTURE_RESOURCE);
@@ -277,9 +281,11 @@ chunk_brick_clipmap_march.requireResource(BRICK_OCCUPANCY_TEXTURE_RESOURCE);
  * The first surface along a ray through the brick clipmap (PROBE_CLIPMAP_PROPOSAL_2026_10_27.md §7.9).
  *
  * ```wgsl
- * fn brick_clipmap_trace(origin: vec3<f32>, direction: vec3<f32>, t_min: f32, t_max: f32, cascade_count: u32) -> BrickClipmapHit
+ * fn brick_clipmap_trace(origin: vec3<f32>, direction: vec3<f32>, t_min: f32, t_max: f32, cascade_count: u32, atlas_shift: u32) -> BrickClipmapHit
  * ```
  *
+ * `atlas_shift` is the atlas's footprint, as {@link chunk_brick_clipmap_sample} takes it.
+ *
  * The march (`brick_clipmap_march`) from `t_min`, at most {@link BRICK_TRACE_STEPS} steps, each
  * reading in a brick one atlas tap:
  * - EMPTY inside is a hit where the march stands: the ray is inside a solid, and its hit is a back
@@ -316,7 +322,7 @@ struct BrickClipmapHit {
     cell_min: vec3<f32>,
 }
 
-fn brick_clipmap_trace(origin: vec3<f32>, direction: vec3<f32>, t_min: f32, t_max: f32, cascade_count: u32) -> BrickClipmapHit {
+fn brick_clipmap_trace(origin: vec3<f32>, direction: vec3<f32>, t_min: f32, t_max: f32, cascade_count: u32, atlas_shift: u32) -> BrickClipmapHit {
     var hit: BrickClipmapHit;
 
     hit.kind = BRICK_TRACE_MISS;
@@ -361,7 +367,7 @@ fn brick_clipmap_trace(origin: vec3<f32>, direction: vec3<f32>, t_min: f32, t_ma
         }
 
         let local = (march.position - march.cell_min) / march.voxel;
-        let distance = brick_clipmap_sample(march.entry, local, march.voxel);
+        let distance = brick_clipmap_sample(march.entry, local, march.voxel, atlas_shift);
 
         if (distance < ${BRICK_TRACE_HIT_VOXELS} * march.voxel) {
             hit.kind = BRICK_TRACE_HIT;
@@ -369,7 +375,7 @@ fn brick_clipmap_trace(origin: vec3<f32>, direction: vec3<f32>, t_min: f32, t_ma
             hit.cascade = march.cascade;
             hit.slot = march.entry;
             hit.position = march.position;
-            hit.normal = brick_clipmap_normal(march.entry, local);
+            hit.normal = brick_clipmap_normal(march.entry, local, atlas_shift);
             hit.distance = distance;
             hit.cell_min = march.cell_min;
 
@@ -396,7 +402,7 @@ fn brick_clipmap_trace(origin: vec3<f32>, direction: vec3<f32>, t_min: f32, t_ma
  * The finest cascade's signed distance at a point (§7.9), for probe relocation.
  *
  * ```wgsl
- * fn brick_clipmap_distance(position: vec3<f32>, cascade_count: u32) -> f32
+ * fn brick_clipmap_distance(position: vec3<f32>, cascade_count: u32, atlas_shift: u32) -> f32
  * ```
  *
  * The finest window holding the point answers, unless its cell is UNKNOWN, which defers to the
@@ -408,7 +414,7 @@ fn brick_clipmap_trace(origin: vec3<f32>, direction: vec3<f32>, t_min: f32, t_ma
 export const chunk_brick_clipmap_distance = CodeChunk.from(
     //language=WGSL
     `
-fn brick_clipmap_distance(position: vec3<f32>, cascade_count: u32) -> f32 {
+fn brick_clipmap_distance(position: vec3<f32>, cascade_count: u32, atlas_shift: u32) -> f32 {
     let count = min(cascade_count, ${CLIPMAP_LEVEL_LIMIT}u);
 
     for (var c = 0u; c < count; c++) {
@@ -432,7 +438,7 @@ fn brick_clipmap_distance(position: vec3<f32>, cascade_count: u32) -> f32 {
             return select(1.0, -1.0, entry == BRICK_CLIPMAP_EMPTY_INSIDE) * BRICK_CLIPMAP_BAND_VOXELS * voxel;
         }
 
-        return brick_clipmap_sample(entry, (position - vec3<f32>(cell) * level.cell_size) / voxel, voxel);
+        return brick_clipmap_sample(entry, (position - vec3<f32>(cell) * level.cell_size) / voxel, voxel, atlas_shift);
     }
 
     return BRICK_CLIPMAP_BAND_VOXELS * brick_levels[max(count, 1u) - 1u].cell_size / ${MESH_SDF_BRICK_VOXELS}.0;
@@ -450,7 +456,7 @@ chunk_brick_clipmap_distance.requireResource(BRICK_MAP_TEXTURE_RESOURCE);
  * no slope: for probe relocation (§8.4).
  *
  * ```wgsl
- * fn brick_clipmap_gradient(position: vec3<f32>, cascade_count: u32) -> vec3<f32>
+ * fn brick_clipmap_gradient(position: vec3<f32>, cascade_count: u32, atlas_shift: u32) -> vec3<f32>
  * ```
  *
  * Four taps of {@link chunk_brick_clipmap_distance} at the corners of a tetrahedron a voxel of the finest
@@ -463,7 +469,7 @@ chunk_brick_clipmap_distance.requireResource(BRICK_MAP_TEXTURE_RESOURCE);
 export const chunk_brick_clipmap_gradient = CodeChunk.from(
     //language=WGSL
     `
-fn brick_clipmap_gradient(position: vec3<f32>, cascade_count: u32) -> vec3<f32> {
+fn brick_clipmap_gradient(position: vec3<f32>, cascade_count: u32, atlas_shift: u32) -> vec3<f32> {
     let cascade = min(brick_clipmap_start(position, cascade_count), max(cascade_count, 1u) - 1u);
     let h = brick_levels[cascade].cell_size / ${MESH_SDF_BRICK_VOXELS}.0;
 
@@ -472,10 +478,10 @@ fn brick_clipmap_gradient(position: vec3<f32>, cascade_count: u32) -> vec3<f32>
     let k2 = vec3<f32>(-1.0, 1.0, -1.0);
     let k3 = vec3<f32>(1.0, 1.0, 1.0);
 
-    let sum = k0 * brick_clipmap_distance(position + h * k0, cascade_count)
-        + k1 * brick_clipmap_distance(position + h * k1, cascade_count)
-        + k2 * brick_clipmap_distance(position + h * k2, cascade_count)
-        + k3 * brick_clipmap_distance(position + h * k3, cascade_count);
+    let sum = k0 * brick_clipmap_distance(position + h * k0, cascade_count, atlas_shift)
+        + k1 * brick_clipmap_distance(position + h * k1, cascade_count, atlas_shift)
+        + k2 * brick_clipmap_distance(position + h * k2, cascade_count, atlas_shift)
+        + k3 * brick_clipmap_distance(position + h * k3, cascade_count, atlas_shift);
 
     let size = length(sum);
 

package/src/shade/renderer/global_illumination/probe_clipmap/debug/graph_probe_clipmap_debug_brick_clipmap.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"graph_probe_clipmap_debug_brick_clipmap.d.ts","sourceRoot":"","sources":["../../../../../../../src/shade/renderer/global_illumination/probe_clipmap/debug/graph_probe_clipmap_debug_brick_clipmap.js"],"names":[],"mappings":"AAqHA;;;;;;;GAOG;AACH;IAN+B,KAAK,EAAzB,UAAU;IACc,IAAI,EAA5B,cAAc;IACI,UAAU,EAA5B,MAAM,EAAE;IACiB,aAAa,EAAtC,eAAe;IACb,MAAM,CAoClB;AA9DD;;;;;;;;GAQG;AACH,uDAFU,WAAW,CAWlB;yBA/FU,OAAO,iEAAiE,EAAE,UAAU;6BACpF,OAAO,iCAAiC,EAAE,cAAc;8BACxD,OAAO,6BAA6B,EAAE,eAAe;4BAjBtC,gCAAgC"}
+{"version":3,"file":"graph_probe_clipmap_debug_brick_clipmap.d.ts","sourceRoot":"","sources":["../../../../../../../src/shade/renderer/global_illumination/probe_clipmap/debug/graph_probe_clipmap_debug_brick_clipmap.js"],"names":[],"mappings":"AAuHA;;;;;;;GAOG;AACH;IAN+B,KAAK,EAAzB,UAAU;IACc,IAAI,EAA5B,cAAc;IACI,UAAU,EAA5B,MAAM,EAAE;IACiB,aAAa,EAAtC,eAAe;IACb,MAAM,CAoClB;AA9DD;;;;;;;;GAQG;AACH,uDAFU,WAAW,CAWlB;yBAjGU,OAAO,iEAAiE,EAAE,UAAU;6BACpF,OAAO,iCAAiC,EAAE,cAAc;8BACxD,OAAO,6BAA6B,EAAE,eAAe;4BAjBtC,gCAAgC"}

package/src/shade/renderer/global_illumination/probe_clipmap/debug/graph_probe_clipmap_debug_brick_clipmap.js

@@ -34,6 +34,8 @@ const FAR = 1e4;
  */
 const DEBUG_BRICK_CLIPMAP_SETTINGS = WebGPUStruct.from({
     cascade_count: u32,
+    /** the brick atlas's footprint as shifts, `GPUBrickClipmap#atlas_shift` */
+    brick_atlas_shift: u32,
 }, "ProbeClipmapDebugBrickClipmapSettings");
 
 const resources = new ShaderResourceSetDescriptor();
@@ -67,7 +69,7 @@ fn main(
 ) -> @location(0) vec4<f32> {
     let ray = camera_ray_from_uv(uv, camera);
 
-    let hit = brick_clipmap_trace(ray.origin, ray.direction, 0.0, ${FAR.toFixed(1)}, settings.cascade_count);
+    let hit = brick_clipmap_trace(ray.origin, ray.direction, 0.0, ${FAR.toFixed(1)}, settings.cascade_count, settings.brick_atlas_shift);
 
     if (hit.kind == BRICK_TRACE_MISS) {
         return vec4<f32>(0.08, 0.08, 0.1, 1.0);
@@ -130,7 +132,7 @@ export function graph_probe_clipmap_debug_brick_clipmap({ graph, view, resolutio
     assert.defined(brick_clipmap, 'brick_clipmap');
 
     const data = {};
-    const settings = { cascade_count: brick_clipmap.cascade_count };
+    const settings = { cascade_count: brick_clipmap.cascade_count, brick_atlas_shift: brick_clipmap.atlas_shift };
 
     const pass = graph.add("Probe Clipmap Debug / Brick Clipmap", data, (data, resources, context) => {
         const output = resources.get(data.output);

package/src/shade/renderer/global_illumination/probe_clipmap/debug/graph_probe_clipmap_debug_brick_material.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"graph_probe_clipmap_debug_brick_material.d.ts","sourceRoot":"","sources":["../../../../../../../src/shade/renderer/global_illumination/probe_clipmap/debug/graph_probe_clipmap_debug_brick_material.js"],"names":[],"mappings":"AAsJA;;;;;;;;;GASG;AACH;IAR+B,KAAK,EAAzB,UAAU;IACc,IAAI,EAA5B,cAAc;IACI,UAAU,EAA5B,MAAM,EAAE;IACiB,aAAa,EAAtC,eAAe;IACqC,QAAQ,EAA5D;QAAC,cAAc,qBAA0B;KAAC;IACK,OAAO,EAAtD,qCAAqC;IACnC,MAAM,CAiDlB;;;;oDAtKS,MAAM;;;;;AAuFhB;;;;;;;;;;GAUG;AACH,wDAFU,WAAW,CAWlB;yBA1HU,OAAO,iEAAiE,EAAE,UAAU;6BACpF,OAAO,iCAAiC,EAAE,cAAc;8BACxD,OAAO,6BAA6B,EAAE,eAAe;4BAvBtC,gCAAgC"}
+{"version":3,"file":"graph_probe_clipmap_debug_brick_material.d.ts","sourceRoot":"","sources":["../../../../../../../src/shade/renderer/global_illumination/probe_clipmap/debug/graph_probe_clipmap_debug_brick_material.js"],"names":[],"mappings":"AAwJA;;;;;;;;;GASG;AACH;IAR+B,KAAK,EAAzB,UAAU;IACc,IAAI,EAA5B,cAAc;IACI,UAAU,EAA5B,MAAM,EAAE;IACiB,aAAa,EAAtC,eAAe;IACqC,QAAQ,EAA5D;QAAC,cAAc,qBAA0B;KAAC;IACK,OAAO,EAAtD,qCAAqC;IACnC,MAAM,CAiDlB;;;;oDAxKS,MAAM;;;;;AAyFhB;;;;;;;;;;GAUG;AACH,wDAFU,WAAW,CAWlB;yBA5HU,OAAO,iEAAiE,EAAE,UAAU;6BACpF,OAAO,iCAAiC,EAAE,cAAc;8BACxD,OAAO,6BAA6B,EAAE,eAAe;4BAvBtC,gCAAgC"}

package/src/shade/renderer/global_illumination/probe_clipmap/debug/graph_probe_clipmap_debug_brick_material.js

@@ -55,6 +55,8 @@ const DEBUG_BRICK_MATERIAL_SETTINGS = WebGPUStruct.from({
     cascade_count: u32,
     /** a {@link ProbeClipmapDebugBrickMaterialChannel} */
     channel: u32,
+    /** the brick atlas's footprint as shifts, `GPUBrickClipmap#atlas_shift` */
+    brick_atlas_shift: u32,
 }, "ProbeClipmapDebugBrickMaterialSettings");
 
 const resources = new ShaderResourceSetDescriptor();
@@ -84,7 +86,7 @@ fn main(
 ) -> @location(0) vec4<f32> {
     let ray = camera_ray_from_uv(uv, camera);
 
-    let hit = brick_clipmap_trace(ray.origin, ray.direction, 0.0, ${FAR.toFixed(1)}, settings.cascade_count);
+    let hit = brick_clipmap_trace(ray.origin, ray.direction, 0.0, ${FAR.toFixed(1)}, settings.cascade_count, settings.brick_atlas_shift);
 
     if (hit.kind == BRICK_TRACE_MISS) {
         return vec4<f32>(0.08, 0.08, 0.1, 1.0);
@@ -101,7 +103,7 @@ fn main(
     }
 
     if (settings.channel == ${ProbeClipmapDebugBrickMaterialChannel.Albedo}u) {
-        let material = probe_clipmap_hit_material(hit.position, hit.normal, hit.cascade);
+        let material = probe_clipmap_hit_material(hit.position, hit.normal, hit.cascade, settings.brick_atlas_shift);
 
         if (!material.found) {
             // the source does not know the surface: the hit is black to the probes
@@ -111,7 +113,7 @@ fn main(
         return vec4<f32>(material.albedo + material.emissive, 1.0);
     }
 
-    let metal_rough = probe_clipmap_hit_metal_rough(hit.position, hit.normal, hit.cascade);
+    let metal_rough = probe_clipmap_hit_metal_rough(hit.position, hit.normal, hit.cascade, settings.brick_atlas_shift);
 
     if (metal_rough.z == 0.0) {
         return vec4<f32>(0.3, 0.0, 0.0, 1.0);
@@ -174,7 +176,7 @@ export function graph_probe_clipmap_debug_brick_material({
     assert.enum(channel, ProbeClipmapDebugBrickMaterialChannel, 'channel');
 
     const data = {};
-    const settings = { cascade_count: brick_clipmap.cascade_count, channel };
+    const settings = { cascade_count: brick_clipmap.cascade_count, channel, brick_atlas_shift: brick_clipmap.atlas_shift };
 
     const pass = graph.add("Probe Clipmap Debug / Brick Material", data, (data, resources, context) => {
         const output = resources.get(data.output);

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

@@ -1 +1 @@
-{"version":3,"file":"GPUBrickMaterial.d.ts","sourceRoot":"","sources":["../../../../../../../src/shade/renderer/global_illumination/probe_clipmap/material/GPUBrickMaterial.js"],"names":[],"mappings":"AAuBA;;;;;;;;;;;;;;;;;GAiBG;AACH;IAyBI;;;;OAIG;IACH;QAF2B,QAAQ,EAAxB,MAAM;OAsBhB;IAhCD;;;;OAIG;IACH,cAFU,YAAU,IAAI,CAEJ;IA6BpB;;OAEG;IACH,4BAEC;IAED;;;;;;OAMG;IACH,mCAMC;IAED;;;;;;;OAOG;IACH,4BAHW,UAAU,WACV,oBAAoB,QAuB9B;IAuCD,gBAQC;;CACJ;yBAnLY,OAAO,iEAAiE,EAAE,UAAU;mCACpF,OAAO,6BAA6B,EAAE,oBAAoB;+BANxC,0CAA0C"}
+{"version":3,"file":"GPUBrickMaterial.d.ts","sourceRoot":"","sources":["../../../../../../../src/shade/renderer/global_illumination/probe_clipmap/material/GPUBrickMaterial.js"],"names":[],"mappings":"AAuBA;;;;;;;;;;;;;;;;;GAiBG;AACH;IAyBI;;;;OAIG;IACH;QAF2B,QAAQ,EAAxB,MAAM;OAsBhB;IAhCD;;;;OAIG;IACH,cAFU,YAAU,IAAI,CAEJ;IA6BpB;;OAEG;IACH,4BAEC;IAED;;;;;;OAMG;IACH,mCAMC;IAED;;;;;;;OAOG;IACH,4BAHW,UAAU,WACV,oBAAoB,QAuB9B;IAwCD,gBAQC;;CACJ;yBApLY,OAAO,iEAAiE,EAAE,UAAU;mCACpF,OAAO,6BAA6B,EAAE,oBAAoB;+BANxC,0CAA0C"}

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

@@ -51,7 +51,7 @@ export class GPUBrickMaterial {
 
     #data = { take: -1, staging: -1, state: -1 };
 
-    #settings = { ring_capacity: 0, resolution: 0 };
+    #settings = { ring_capacity: 0, resolution: 0, brick_atlas_shift: 0 };
 
     #bindings = {};
 
@@ -171,6 +171,7 @@ export class GPUBrickMaterial {
 
         settings.ring_capacity = frame.ring_capacity;
         settings.resolution = frame.resolution;
+        settings.brick_atlas_shift = frame.clipmap.atlas_shift;
         b.settings = settings;
 
         shader_brick_material_gather.dispatchIndirect({

package/src/shade/renderer/global_illumination/probe_clipmap/material/chunk_brick_material.d.ts

@@ -17,13 +17,14 @@ export const BRICK_MATERIAL_EMISSIVE_RESOURCE: ShaderResourceDescriptor;
  *
  * ```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}
  */
@@ -33,7 +34,7 @@ export const chunk_brick_material_corners: CodeChunk;
  * (`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}
@@ -45,7 +46,7 @@ export const chunk_brick_material_surface: CodeChunk;
  * 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}
@@ -56,7 +57,7 @@ export const chunk_brick_material_surface_pick: CodeChunk;
  * 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}

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

@@ -1 +1 @@
-{"version":3,"file":"chunk_brick_material.d.ts","sourceRoot":"","sources":["../../../../../../../src/shade/renderer/global_illumination/probe_clipmap/material/chunk_brick_material.js"],"names":[],"mappings":"AAgBA;;GAEG;AACH,6CAFU,wBAAwB,CAE0F;AAE5H;;GAEG;AACH,kDAFU,wBAAwB,CAEoG;AAEtI;;GAEG;AACH,+CAFU,wBAAwB,CAE8F;AAEhI;;;;;;;;;;;;;;;;GAgBG;AACH,2CAFU,SAAS,CAqBZ;AAIP;;;;;;;;;GASG;AACH,2CAFU,SAAS,CAWZ;AAIP;;;;;;;;;;GAUG;AACH,gDAFU,SAAS,CAaZ;AAIP;;;;;;;;;GASG;AACH,+CAFU,SAAS,CAWZ;yCArIkC,sDAAsD;0BADrE,uCAAuC"}
+{"version":3,"file":"chunk_brick_material.d.ts","sourceRoot":"","sources":["../../../../../../../src/shade/renderer/global_illumination/probe_clipmap/material/chunk_brick_material.js"],"names":[],"mappings":"AAgBA;;GAEG;AACH,6CAFU,wBAAwB,CAE0F;AAE5H;;GAEG;AACH,kDAFU,wBAAwB,CAEoG;AAEtI;;GAEG;AACH,+CAFU,wBAAwB,CAE8F;AAEhI;;;;;;;;;;;;;;;;;GAiBG;AACH,2CAFU,SAAS,CAqBZ;AAIP;;;;;;;;;GASG;AACH,2CAFU,SAAS,CAWZ;AAIP;;;;;;;;;;GAUG;AACH,gDAFU,SAAS,CAaZ;AAIP;;;;;;;;;GASG;AACH,+CAFU,SAAS,CAWZ;yCAtIkC,sDAAsD;0BADrE,uCAAuC"}

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