@woosh/meep-engine 3.64.1 → 3.65.0

package/src/shade/renderer/global_illumination/probe_clipmap/GPUProbeClipmapGI.js

@@ -21,6 +21,7 @@ import { ProbeClipmapDebugView } from "./debug/ProbeClipmapDebugView.js";
 import { PROBE_RECORD_STRUCT } from "./probe/chunk_probe_clipmap.js";
 import { PROBE_SAMPLING_STRUCT } from "./probe/chunk_probe_clipmap_pick.js";
 import { GPUProbeClipmap } from "./probe/GPUProbeClipmap.js";
+import { graph_probe_clipmap_want_meshlets } from "./probe/graph_probe_clipmap_want_meshlets.js";
 import { PROBE_DEPTH_TEXEL_RAYS, PROBE_RAY_CASCADE_MASK, PROBE_TEXEL_RAYS } from "./probe/PROBE_CLIPMAP.js";
 import { ProbeClipmapHitWants } from "./probe/ProbeClipmapHitWants.js";
 import { ProbeClipmapIndirectLobe } from "./probe/ProbeClipmapIndirectLobe.js";
@@ -88,6 +89,17 @@ export class GPUProbeClipmapGI {
     /** The world cache's wants, the frustum's hits. @type {ProbeClipmapHitWants|undefined} */
     #hit_wants = undefined;
 
+    /**
+     * The frustum's wants from surfaces drawn apart from the G-buffer ({@link graph_want_surface}), each with what
+     * its pass keeps from frame to frame; the first {@link #surface_wants_used} are this frame's.
+     * @type {{wants: ProbeClipmapScreenWants, data: Object, bindings: Object, execute: function}[]}
+     */
+    #surface_wants = [];
+    #surface_wants_used = 0;
+
+    /** The frame's blue noise, which the surfaces' wants pick their pixels by. */
+    #stbn = null;
+
     /** The coarsest brick window's box, metres, which the world light clusters cull lights against. */
     #clusters_min = [0, 0, 0];
     #clusters_max = [0, 0, 0];
@@ -316,6 +328,9 @@ export class GPUProbeClipmapGI {
 
         this.#screen_wants.set({ depth, normal, camera: view.camera.buffer, stbn, resolution: view.resolution });
 
+        this.#stbn = stbn;
+        this.#surface_wants_used = 0;
+
         frustum.graph_update({
             graph,
             wants: this.#screen_wants,
@@ -394,6 +409,92 @@ export class GPUProbeClipmapGI {
         return this.#probe_clipmap !== undefined;
     }
 
+    /**
+     * Record the wants of a screen surface drawn apart from the G-buffer whose reader picks the frustum's probes a
+     * pixel (PROBE_CLIPMAP_PROPOSAL_2026_10_27.md §8.3): the water's interface. A pixel of each screen tile wants
+     * the cages its pick reads, as the G-buffer's pixels do (`ProbeClipmapScreenWants`).
+     *
+     * For a pass after this frame's {@link graph_update}, once the surface is drawn. Its wants are taken by the
+     * next frame's lifetime, so a probe the surface newly reads is there a frame after the surface is. Records
+     * nothing where there are no probes ({@link has_probes}): out of the mode it costs nothing.
+     *
+     * @param {Object} options
+     * @param {FrameGraph} options.graph
+     * @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 {number} [options.normal_channel] the channel that holds the normal, 0 to 3
+     * @param {boolean} [options.two_sided] whether the reader turns a normal that faces away from the eye to face it
+     * @param {GPUBuffer} options.camera the camera uniform the surface was drawn with
+     * @param {ArrayLike<number>} options.resolution the surface's pixels, x and y
+     */
+    graph_want_surface({ graph, depth, normal, normal_channel = 0, two_sided = false, camera, resolution }) {
+        assert.defined(graph, 'graph');
+
+        if (!this.has_probes) {
+            return;
+        }
+
+        const index = this.#surface_wants_used++;
+
+        if (index === this.#surface_wants.length) {
+            const entry = {
+                wants: new ProbeClipmapScreenWants(),
+                data: {},
+                bindings: {},
+                execute: (data, resources, context) => {
+                    // as the frustum's clipmap holds its late set now
+                    entry.wants.encode(context.encoder, data, resources, this.#probe_clipmap.write_want_bindings(entry.bindings));
+                },
+            };
+
+            this.#surface_wants.push(entry);
+        }
+
+        const entry = this.#surface_wants[index];
+
+        entry.wants.set({ depth, normal, normal_channel, two_sided, camera, stbn: this.#stbn, resolution });
+
+        const pass = graph.add("Probe Clipmap Want Surface", entry.data, entry.execute);
+
+        entry.wants.graph_declare(pass, entry.data);
+
+        // it writes the clipmap's own late set, which the graph does not hold
+        pass.make_side_effect();
+    }
+
+    /**
+     * Record the wants of a list of meshlets a forward pass draws, whose fragments pick the frustum's probes
+     * (PROBE_CLIPMAP_PROPOSAL_2026_10_27.md §8.3): each wants the cages a reader anywhere inside its box can
+     * read (`graph_probe_clipmap_want_meshlets`).
+     *
+     * For a pass after this frame's {@link graph_update}; taken by the next frame's lifetime, as
+     * {@link graph_want_surface}'s are. Records nothing where there are no probes ({@link has_probes}).
+     *
+     * @param {Object} options
+     * @param {FrameGraph} options.graph
+     * @param {import("../../scene/GPUSceneContext.js").GPUSceneContext} options.scene the meshlets' scene
+     * @param {number} options.camera graph handle of the view's camera uniform
+     * @param {number} options.meshlet_collection graph handle of the list, `MESHLET_COLLECTION_STRUCT`
+     * @param {number} options.meshlet_iterator_command graph handle of the indirect dispatch that walks the list
+     */
+    graph_want_meshlets({ graph, scene, camera, meshlet_collection, meshlet_iterator_command }) {
+        assert.defined(graph, 'graph');
+
+        if (!this.has_probes) {
+            return;
+        }
+
+        graph_probe_clipmap_want_meshlets({
+            graph,
+            clipmap: this.#probe_clipmap,
+            scene,
+            camera,
+            meshlet_collection,
+            meshlet_iterator_command,
+        });
+    }
+
     /**
      * Put what the probes' readers bind into `bindings`, `PROBE_CLIPMAP_SAMPLING_GROUP` but its sampler:
      * once {@link has_probes}, the probes as this frame's {@link graph_update} left them

package/src/shade/renderer/global_illumination/probe_clipmap/ProbeClipmapSettings.d.ts

@@ -210,7 +210,8 @@ export class ProbeClipmapSettings {
     /**
      * Rays the frustum's probes trace a frame at most, `FRUSTUM_RAY_BUDGET_FRACTION` of {@link ray_budget}
      * rounded down, so `floor(frustum_ray_budget / rays_per_probe)` of them update a frame and every wanted one
-     * is traced again after as many frames as that takes.
+     * is traced again after as many frames as that takes, an idle one, live and wanted by nothing, once in
+     * `probe_clipmap_idle_periods` of those.
      * @returns {number}
      */
     get frustum_ray_budget(): number;

package/src/shade/renderer/global_illumination/probe_clipmap/ProbeClipmapSettings.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"ProbeClipmapSettings.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/global_illumination/probe_clipmap/ProbeClipmapSettings.js"],"names":[],"mappings":"AAMA;;;;;;;;;;;;;;;;GAgBG;AACH;IAaI;;;OAGG;IACH,mCAIC;IAjBD;;;;OAIG;IACH,kCAEC;IAsBD;;;OAGG;IACH,wCAKC;IAjBD;;;OAGG;IACH,uCAEC;IAyBD;;OAEG;IACH,gCAKC;IAlBD;;;;;OAKG;IACH,+BAEC;IAuBD;;OAEG;IACH,kCAIC;IAhBD;;;;OAIG;IACH,iCAEC;IAuBD;;OAEG;IACH,mCAKC;IAlBD;;;;;OAKG;IACH,kCAEC;IAyBD;;;OAGG;IACH,mCAMC;IArBD;;;;;;OAMG;IACH,kCAEC;IAsCD;;;OAGG;IACH,oCAKC;IA/BD;;;;;;;;;;;;;;;;;OAiBG;IACH,mCAEC;IAsCD;;;OAGG;IACH,mCAIC;IA/BD;;;;;;;;;;;;;;;;;;OAkBG;IACH,kCAEC;IAuBD;;;OAGG;IACH,mCAIC;IAjBD;;;;OAIG;IACH,kCAEC;IAsBD;;;OAGG;IACH,wCAKC;IAjBD;;;OAGG;IACH,uCAEC;IAyBD;;OAEG;IACH,6BAKC;IAlBD;;;;;OAKG;IACH,4BAEC;IAuBD;;;OAGG;IACH,mCAMC;IAnBD;;;;OAIG;IACH,kCAEC;IAyBD;;OAEG;IACH,gCAKC;IAjBD;;;;OAIG;IACH,+BAEC;IAuBD;;;;OAIG;IACH,8BAKC;IAnBD;;;;OAIG;IACH,6BAEC;IAyBD;;;OAGG;IACH,0BAIC;IAjBD;;;;OAIG;IACH,yBAEC;IAYD;;;;;OAKG;IACH,iCAEC;IAED;;;OAGG;IACH,+BAEC;IAeD;;;OAGG;IACH,yCAIC;IAnBD;;;;;;OAMG;IACH,wCAEC;IAuBD;;OAEG;IACH,+CAMC;IAlBD;;;;OAIG;IACH,8CAEC;IAwBD;;OAEG;IACH,4CAKC;IAjBD;;;;OAIG;IACH,2CAEC;IAuBD;;;OAGG;IACH,0CAKC;IAlBD;;;;OAIG;IACH,yCAEC;IA2BD;;OAEG;IACH,+BAKC;IApBD;;;;;;;OAOG;IACH,8BAEC;IAyBD;;OAEG;IACH,mCAIC;IAlBD;;;;;;OAMG;IACH,kCAEC;IAwBD;;OAEG;IACH,+BAIC;IAlBD;;;;;;OAMG;IACH,8BAEC;IAsBD;;OAEG;IACH,0BAIC;IAhBD;;;;OAIG;IACH,yBAEC;;CAUJ"}
+{"version":3,"file":"ProbeClipmapSettings.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/global_illumination/probe_clipmap/ProbeClipmapSettings.js"],"names":[],"mappings":"AAMA;;;;;;;;;;;;;;;;GAgBG;AACH;IAaI;;;OAGG;IACH,mCAIC;IAjBD;;;;OAIG;IACH,kCAEC;IAsBD;;;OAGG;IACH,wCAKC;IAjBD;;;OAGG;IACH,uCAEC;IAyBD;;OAEG;IACH,gCAKC;IAlBD;;;;;OAKG;IACH,+BAEC;IAuBD;;OAEG;IACH,kCAIC;IAhBD;;;;OAIG;IACH,iCAEC;IAuBD;;OAEG;IACH,mCAKC;IAlBD;;;;;OAKG;IACH,kCAEC;IAyBD;;;OAGG;IACH,mCAMC;IArBD;;;;;;OAMG;IACH,kCAEC;IAsCD;;;OAGG;IACH,oCAKC;IA/BD;;;;;;;;;;;;;;;;;OAiBG;IACH,mCAEC;IAsCD;;;OAGG;IACH,mCAIC;IA/BD;;;;;;;;;;;;;;;;;;OAkBG;IACH,kCAEC;IAuBD;;;OAGG;IACH,mCAIC;IAjBD;;;;OAIG;IACH,kCAEC;IAsBD;;;OAGG;IACH,wCAKC;IAjBD;;;OAGG;IACH,uCAEC;IAyBD;;OAEG;IACH,6BAKC;IAlBD;;;;;OAKG;IACH,4BAEC;IAuBD;;;OAGG;IACH,mCAMC;IAnBD;;;;OAIG;IACH,kCAEC;IAyBD;;OAEG;IACH,gCAKC;IAjBD;;;;OAIG;IACH,+BAEC;IAuBD;;;;OAIG;IACH,8BAKC;IAnBD;;;;OAIG;IACH,6BAEC;IAyBD;;;OAGG;IACH,0BAIC;IAjBD;;;;OAIG;IACH,yBAEC;IAYD;;;;;;OAMG;IACH,iCAEC;IAED;;;OAGG;IACH,+BAEC;IAeD;;;OAGG;IACH,yCAIC;IAnBD;;;;;;OAMG;IACH,wCAEC;IAuBD;;OAEG;IACH,+CAMC;IAlBD;;;;OAIG;IACH,8CAEC;IAwBD;;OAEG;IACH,4CAKC;IAjBD;;;;OAIG;IACH,2CAEC;IAuBD;;;OAGG;IACH,0CAKC;IAlBD;;;;OAIG;IACH,yCAEC;IA2BD;;OAEG;IACH,+BAKC;IApBD;;;;;;;OAOG;IACH,8BAEC;IAyBD;;OAEG;IACH,mCAIC;IAlBD;;;;;;OAMG;IACH,kCAEC;IAwBD;;OAEG;IACH,+BAIC;IAlBD;;;;;;OAMG;IACH,8BAEC;IAsBD;;OAEG;IACH,0BAIC;IAhBD;;;;OAIG;IACH,yBAEC;;CAUJ"}

package/src/shade/renderer/global_illumination/probe_clipmap/ProbeClipmapSettings.js

@@ -379,7 +379,8 @@ export class ProbeClipmapSettings {
     /**
      * Rays the frustum's probes trace a frame at most, `FRUSTUM_RAY_BUDGET_FRACTION` of {@link ray_budget}
      * rounded down, so `floor(frustum_ray_budget / rays_per_probe)` of them update a frame and every wanted one
-     * is traced again after as many frames as that takes.
+     * is traced again after as many frames as that takes, an idle one, live and wanted by nothing, once in
+     * `probe_clipmap_idle_periods` of those.
      * @returns {number}
      */
     get frustum_ray_budget() {

package/src/shade/renderer/global_illumination/probe_clipmap/brick/GPUBrickClipmap.d.ts

@@ -121,6 +121,14 @@ export class GPUBrickClipmap {
      * @returns {Object} bindings
      */
     write_bindings(bindings: any): any;
+    /**
+     * The atlas's footprint as `tile_atlas_slot_shift` packs it: what every reader of the bricks takes in
+     * its immediate data as `brick_atlas_shift` and passes to `chunk_brick_clipmap_sample`. It changes
+     * only when a grow widens the atlas, in {@link graph_update}: take it after that, each frame, as the
+     * atlas itself.
+     * @returns {number}
+     */
+    get atlas_shift(): number;
     /**
      * Slots of the atlas.
      * @returns {number}

package/src/shade/renderer/global_illumination/probe_clipmap/brick/GPUBrickClipmap.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"GPUBrickClipmap.d.ts","sourceRoot":"","sources":["../../../../../../../src/shade/renderer/global_illumination/probe_clipmap/brick/GPUBrickClipmap.js"],"names":[],"mappings":"AA6FA;;;;;;;;;;;;;;;;;;;;;;;;;GAyBG;AAEH;;;GAGG;AAEH;;;;;;;;GAQG;AAEH;;;;;;;;;;;;;;;;;;;;;;;;GAwBG;AACH;IAkKI;;;;;;;;OAQG;IACH;QAN2B,aAAa,EAA7B,MAAM;QACU,UAAU,EAA1B,MAAM;QAGU,UAAU,EAA1B,MAAM;OAgGhB;IAxQD;;;OAGG;IACH,wBAHU,MAAM,CAGF;IAEd;;;;OAIG;IACH,qBAHU,MAAM,CAGL;IAEX;;;;OAIG;IACH,qBAHU,MAAM,CAGL;IAwPX;;OAEG;IACH,4BAEC;IAED;;OAEG;IACH,4BAEC;IAED;;OAEG;IACH,4BAEC;IAED;;;;OAIG;IACH,wBAEC;IAED;;;;;;;OAOG;IACH,mCAQC;IAED;;;OAGG;IACH,uBAEC;IAED;;;;OAIG;IACH,gBAJW,MAAM,QACN,MAAM,GACJ,MAAM,CAIlB;IAED;;;OAGG;IACH,mBAHW,MAAM,GACJ,MAAM,CAIlB;IAED;;;;;;OAMG;IACH,sBAFW,UAAU,MAAM,CAAC,QAiB3B;IAED;;;OAGG;IACH,oBAHW,oBAAoB,GAClB,OAAO,CAMnB;IAED;;;;;;;;;;;;;;;;;;;OAmBG;IACH;QAb+B,KAAK,EAAzB,UAAU;QACM,CAAC,EAAjB,MAAM;QACU,CAAC,EAAjB,MAAM;QACU,CAAC,EAAjB,MAAM;QACU,MAAM,EAAtB,MAAM;QAC4B,SAAS,EAA3C,UAAU,aAAa,CAAC;QACiB,gBAAgB,GAAzD,UAAU,mBAAmB,CAAC;QACA,KAAK,EAAnC,eAAe,GAAC,IAAI;QACH,MAAM,GAAvB,MAAM;QAEJ,MAAM,CAiHlB;IAgWD,gBAcC;;CACJ;mCAr9BY,OAAO,4BAA4B,EAAE,oBAAoB;yBACzD,OAAO,iEAAiE,EAAE,UAAU;8BACpF,OAAO,mCAAmC,EAAE,eAAe;;;;;;;WA+C1D,UAAU;;;;WACV,MAAM;;;;;;UACN,MAAM;;;;;aAGN,MAAM;;;;sBAEN,MAAM;;;;;mBAEN,MAAM;;;;gBACN,MAAM;mBACN,MAAM;;;;;;;;;;WAGN,eAAe;;;;;;aAEf,eAAe;;;+BAON,UAAU,QAAE,oBAAoB,KAAG,IAAI;;;;;;;;;iCAUvC,UAAU,QAAE,oBAAoB,KAAG,IAAI;;+BA1G/B,0CAA0C"}
+{"version":3,"file":"GPUBrickClipmap.d.ts","sourceRoot":"","sources":["../../../../../../../src/shade/renderer/global_illumination/probe_clipmap/brick/GPUBrickClipmap.js"],"names":[],"mappings":"AA8FA;;;;;;;;;;;;;;;;;;;;;;;;;GAyBG;AAEH;;;GAGG;AAEH;;;;;;;;GAQG;AAEH;;;;;;;;;;;;;;;;;;;;;;;;GAwBG;AACH;IAkKI;;;;;;;;OAQG;IACH;QAN2B,aAAa,EAA7B,MAAM;QACU,UAAU,EAA1B,MAAM;QAGU,UAAU,EAA1B,MAAM;OAgGhB;IAxQD;;;OAGG;IACH,wBAHU,MAAM,CAGF;IAEd;;;;OAIG;IACH,qBAHU,MAAM,CAGL;IAEX;;;;OAIG;IACH,qBAHU,MAAM,CAGL;IAwPX;;OAEG;IACH,4BAEC;IAED;;OAEG;IACH,4BAEC;IAED;;OAEG;IACH,4BAEC;IAED;;;;OAIG;IACH,wBAEC;IAED;;;;;;;OAOG;IACH,mCAQC;IAED;;;;;;OAMG;IACH,0BAEC;IAED;;;OAGG;IACH,uBAEC;IAED;;;;OAIG;IACH,gBAJW,MAAM,QACN,MAAM,GACJ,MAAM,CAIlB;IAED;;;OAGG;IACH,mBAHW,MAAM,GACJ,MAAM,CAIlB;IAED;;;;;;OAMG;IACH,sBAFW,UAAU,MAAM,CAAC,QAiB3B;IAED;;;OAGG;IACH,oBAHW,oBAAoB,GAClB,OAAO,CAMnB;IAED;;;;;;;;;;;;;;;;;;;OAmBG;IACH;QAb+B,KAAK,EAAzB,UAAU;QACM,CAAC,EAAjB,MAAM;QACU,CAAC,EAAjB,MAAM;QACU,CAAC,EAAjB,MAAM;QACU,MAAM,EAAtB,MAAM;QAC4B,SAAS,EAA3C,UAAU,aAAa,CAAC;QACiB,gBAAgB,GAAzD,UAAU,mBAAmB,CAAC;QACA,KAAK,EAAnC,eAAe,GAAC,IAAI;QACH,MAAM,GAAvB,MAAM;QAEJ,MAAM,CAiHlB;IAgWD,gBAcC;;CACJ;mCAh+BY,OAAO,4BAA4B,EAAE,oBAAoB;yBACzD,OAAO,iEAAiE,EAAE,UAAU;8BACpF,OAAO,mCAAmC,EAAE,eAAe;;;;;;;WA+C1D,UAAU;;;;WACV,MAAM;;;;;;UACN,MAAM;;;;;aAGN,MAAM;;;;sBAEN,MAAM;;;;;mBAEN,MAAM;;;;gBACN,MAAM;mBACN,MAAM;;;;;;;;;;WAGN,eAAe;;;;;;aAEf,eAAe;;;+BAON,UAAU,QAAE,oBAAoB,KAAG,IAAI;;;;;;;;;iCAUvC,UAAU,QAAE,oBAAoB,KAAG,IAAI;;+BA3G/B,0CAA0C"}

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

@@ -25,6 +25,7 @@ import {
 } from "../../../shader/chunk/clipmap/CLIPMAP_LEVEL_STRUCT.js";
 import { graph_import_buffer } from "../../../shader/graph/graph_import_buffer.js";
 import { GPUTileAtlas3D } from "../../../texture/atlas/GPUTileAtlas3D.js";
+import { tile_atlas_slot_shift } from "../../../texture/atlas/tile_atlas_slot_shift.js";
 import {
     BRICK_OCCUPANCY_BLOCK,
     BRICK_STAGING_WORDS,
@@ -473,6 +474,17 @@ export class GPUBrickClipmap {
         return bindings;
     }
 
+    /**
+     * The atlas's footprint as `tile_atlas_slot_shift` packs it: what every reader of the bricks takes in
+     * its immediate data as `brick_atlas_shift` and passes to `chunk_brick_clipmap_sample`. It changes
+     * only when a grow widens the atlas, in {@link graph_update}: take it after that, each frame, as the
+     * atlas itself.
+     * @returns {number}
+     */
+    get atlas_shift() {
+        return tile_atlas_slot_shift(this.#atlas.slots_x, this.#atlas.slots_y);
+    }
+
     /**
      * Slots of the atlas.
      * @returns {number}

package/src/shade/renderer/global_illumination/probe_clipmap/brick/chunk_brick_clipmap_trace.d.ts

@@ -45,15 +45,19 @@ export const BRICK_LEVELS_RESOURCE: ShaderResourceDescriptor;
  * 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;
@@ -98,9 +102,11 @@ export const chunk_brick_clipmap_march: CodeChunk;
  * 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
@@ -118,7 +124,7 @@ export const chunk_brick_clipmap_trace: CodeChunk;
  * 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
@@ -133,7 +139,7 @@ export const chunk_brick_clipmap_distance: CodeChunk;
  * 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

package/src/shade/renderer/global_illumination/probe_clipmap/brick/chunk_brick_clipmap_trace.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"chunk_brick_clipmap_trace.d.ts","sourceRoot":"","sources":["../../../../../../../src/shade/renderer/global_illumination/probe_clipmap/brick/chunk_brick_clipmap_trace.js"],"names":[],"mappings":"AAoBA;;;;GAIG;AACH,gCAFU,MAAM,CAEoB;AAEpC;;;;GAIG;AACH,gCAFU,MAAM,CAEwB;AAExC;;;;GAIG;AACH,qCAFU,MAAM,CAE0B;AAE1C;;;GAGG;AACH,yCAFU,wBAAwB,CAEoE;AAEtG;;;GAGG;AACH,+CAFU,wBAAwB,CAEgF;AAElH;;;GAGG;AACH,2CAFU,wBAAwB,CAEyE;AAE3G;;;GAGG;AACH,qCAFU,wBAAwB,CAEqF;AAEvH;;;GAGG;AACH,oCAFU,wBAAwB,CAEyE;AAE3G;;;;;;;;;;;;;;GAcG;AACH,yCAFU,SAAS,CAyCZ;AAKP;;;;;;;;;;;;GAYG;AACH,yCAFU,SAAS,CAyBZ;AAIP;;;;;;;;;;;;;;;;;;;;;GAqBG;AACH,wCAFU,SAAS,CAgFZ;AAKP;;;;;;;;;;;;;;;;;;GAkBG;AACH,wCAFU,SAAS,CAoGZ;AAEP;;;;;;;;;;;;GAYG;AACH,2CAFU,SAAS,CAsCZ;AAIP;;;;;;;;;;;;;;GAcG;AACH,2CAFU,SAAS,CA0BZ;yCA7dkC,sDAAsD;0BADrE,uCAAuC"}
+{"version":3,"file":"chunk_brick_clipmap_trace.d.ts","sourceRoot":"","sources":["../../../../../../../src/shade/renderer/global_illumination/probe_clipmap/brick/chunk_brick_clipmap_trace.js"],"names":[],"mappings":"AAoBA;;;;GAIG;AACH,gCAFU,MAAM,CAEoB;AAEpC;;;;GAIG;AACH,gCAFU,MAAM,CAEwB;AAExC;;;;GAIG;AACH,qCAFU,MAAM,CAE0B;AAE1C;;;GAGG;AACH,yCAFU,wBAAwB,CAEoE;AAEtG;;;GAGG;AACH,+CAFU,wBAAwB,CAEgF;AAElH;;;GAGG;AACH,2CAFU,wBAAwB,CAEyE;AAE3G;;;GAGG;AACH,qCAFU,wBAAwB,CAEqF;AAEvH;;;GAGG;AACH,oCAFU,wBAAwB,CAEyE;AAE3G;;;;;;;;;;;;;;;;;;GAkBG;AACH,yCAFU,SAAS,CAyCZ;AAKP;;;;;;;;;;;;GAYG;AACH,yCAFU,SAAS,CAyBZ;AAIP;;;;;;;;;;;;;;;;;;;;;GAqBG;AACH,wCAFU,SAAS,CAgFZ;AAKP;;;;;;;;;;;;;;;;;;;;GAoBG;AACH,wCAFU,SAAS,CAoGZ;AAEP;;;;;;;;;;;;GAYG;AACH,2CAFU,SAAS,CAsCZ;AAIP;;;;;;;;;;;;;;GAcG;AACH,2CAFU,SAAS,CA0BZ;yCAnekC,sDAAsD;0BADrE,uCAAuC"}

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