@woosh/meep-engine 3.64.0 → 3.65.0

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

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

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

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

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

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

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

@@ -189,8 +189,8 @@ export const PROBE_RAY_SUMS_WRITE_RESOURCE: ShaderResourceDescriptor;
  */
 export const PROBE_RAY_SUMS_READ_RESOURCE: ShaderResourceDescriptor;
 /**
- * A slot's ray request (§8.6), as projection writes it after each update: the rays its next guided update
- * asks for, and what tells it the probe's light moved.
+ * A slot's request (§8.6, §8.8), as projection writes it after each update: what the probe's next update takes,
+ * by its L0 estimator, a multi-scale mean estimator over the probe's whole light (`shader_probe_clipmap_project`).
  *
  * @type {WebGPUStruct}
  */
@@ -201,7 +201,7 @@ export const PROBE_REQUEST_STRUCT: WebGPUStruct;
  */
 export const PROBE_REQUESTS_WRITE_RESOURCE: ShaderResourceDescriptor;
 /**
- * Each slot's ray request, as the ray counts pass reads it.
+ * Each slot's request, as the ray counts and accumulation read it.
  * @type {ShaderResourceDescriptor}
  */
 export const PROBE_REQUESTS_READ_RESOURCE: ShaderResourceDescriptor;

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

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

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

@@ -1,3 +1,4 @@
+import { chunk_age_eviction } from "../../../gpu_primitive/age_eviction/chunk_age_eviction.js";
 import { COLLECTION_U32_STRUCT_READ } from "../../../gpu_primitive/COLLECTION_U32_STRUCT_READ.js";
 import { COLLECTION_U32_STRUCT_WRITE } from "../../../gpu_primitive/COLLECTION_U32_STRUCT_WRITE.js";
 import { chunk_clipmap_key } from "../../../shader/chunk/clipmap/chunk_clipmap_key.js";
@@ -340,20 +341,20 @@ export const PROBE_RAY_SUMS_WRITE_RESOURCE = ShaderResourceDescriptor.storageBuf
 export const PROBE_RAY_SUMS_READ_RESOURCE = ShaderResourceDescriptor.storageBuffer("probe_ray_sums", COLLECTION_U32_STRUCT_READ);
 
 /**
- * A slot's ray request (§8.6), as projection writes it after each update: the rays its next guided update
- * asks for, and what tells it the probe's light moved.
+ * A slot's request (§8.6, §8.8), as projection writes it after each update: what the probe's next update takes,
+ * by its L0 estimator, a multi-scale mean estimator over the probe's whole light (`shader_probe_clipmap_project`).
  *
  * @type {WebGPUStruct}
  */
 export const PROBE_REQUEST_STRUCT = WebGPUStruct.from({
     /** the rays the probe's next guided update asks for */
     rays: u32,
-    /** the running mean of the update's change score: its texels' falls from their means, each in its own deviation, summed over the root of their count */
-    change_mean: f32,
-    /** the running variance of the change score */
-    change_variance: f32,
-    /** the scores its running statistics hold, up to `PROBE_RADIANCE_SAMPLES_LIMIT` */
-    changes: u32,
+    /** the least blend of every texel's long mean on the next update: the L0 estimator's catch-up */
+    blend: f32,
+    /** the L0 estimator's inconsistency, the smoothed history of its means' gap over its deviation */
+    inconsistency: f32,
+    /** the L0 estimator's blend reduction */
+    reduction: f32,
 }, "ProbeRequest").pack();
 
 /**
@@ -363,7 +364,7 @@ export const PROBE_REQUEST_STRUCT = WebGPUStruct.from({
 export const PROBE_REQUESTS_WRITE_RESOURCE = ShaderResourceDescriptor.storageBuffer("probe_requests", WebGPUArray.from(PROBE_REQUEST_STRUCT), true);
 
 /**
- * Each slot's ray request, as the ray counts pass reads it.
+ * Each slot's request, as the ray counts and accumulation read it.
  * @type {ShaderResourceDescriptor}
  */
 export const PROBE_REQUESTS_READ_RESOURCE = ShaderResourceDescriptor.storageBuffer("probe_requests", WebGPUArray.from(PROBE_REQUEST_STRUCT));
@@ -463,10 +464,12 @@ export const PROBE_PROJECTION_ROW_STRUCT = WebGPUStruct.from({
     resolved: u32,
     /** of them, the back faces */
     back_faces: u32,
-    /** how far the update's samples fell from their texels' means, each in its own deviation, luminance, summed */
-    change: f32,
-    /** the texels that blended a sample */
-    blended: f32,
+    /** the texels' short means less their means, luminance, each by its solid angle, summed: L0's gap */
+    gap: f32,
+    /** the texels' deviations squared, luminance, each by its solid angle squared, summed: L0's variance */
+    variance: f32,
+    /** the texels' short means, luminance, each by its solid angle, summed: L0's short mean */
+    level: f32,
 }, "ProbeProjectionRow").pack();
 
 /**
@@ -614,7 +617,7 @@ fn probe_state(kind: u32, updates: u32) -> u32 {
 }
 
 fn probe_clipmap_age_bucket(age: u32) -> u32 {
-    return min(32u - countLeadingZeros(age), PROBE_AGE_BUCKETS - 1u);
+    return age_eviction_bucket(age);
 }
 
 fn probe_record_flags(back_face: f32, cascade: u32) -> u32 {
@@ -659,6 +662,7 @@ fn probe_clipmap_offset_decode(word: u32, spacing: f32) -> vec3<f32> {
     return vec3<f32>(steps) * (${PROBE_RELOCATION_LIMIT} * spacing / 511.0);
 }
 `, [
+    chunk_age_eviction,
     PROBE_RECORD_STRUCT.declaration_chunk,
     chunk_brick4_sh3_color_pack,
     chunk_brick4_sh3_color_unpack,

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

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

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

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

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

@@ -0,0 +1,174 @@
+import { CLIPMAP_LEVEL_LIMIT, CLIPMAP_LEVEL_STRUCT } from "../../../shader/chunk/clipmap/CLIPMAP_LEVEL_STRUCT.js";
+import { CodeChunk } from "../../../shader/compiler/CodeChunk.js";
+import { chunk_probe_clipmap, PROBE_LEVELS_RESOURCE } from "./chunk_probe_clipmap.js";
+import { PROBE_RECEIVER_BIAS } from "./PROBE_CLIPMAP.js";
+
+/**
+ * The cages a reader anywhere inside a world box can read (PROBE_CLIPMAP_PROPOSAL_2026_10_27.md §8.3, §9.1), for
+ * a want that knows its readers by their bounds alone: a meshlet's, whose fragments pick probes.
+ *
+ * ```wgsl
+ * struct ProbeClipmapBoxCages { first: vec3<i32>, dims: vec3<u32> }
+ * fn probe_clipmap_box_cascades(box_min: vec3<f32>, box_max: vec3<f32>, cascade_count: u32, anchor: vec3<f32>, select_half: f32) -> vec2<u32>
+ * fn probe_clipmap_box_cages(box_min: vec3<f32>, box_max: vec3<f32>, cascade: u32, anchor: vec3<f32>, select_half: f32) -> ProbeClipmapBoxCages
+ * fn probe_clipmap_box_cage_count(box_min: vec3<f32>, box_max: vec3<f32>, cascade_count: u32, anchor: vec3<f32>, select_half: f32) -> u32
+ * fn probe_clipmap_cage_is_read(cascade: u32, cage: vec3<i32>, anchor: vec3<f32>, select_half: f32) -> bool
+ * fn probe_clipmap_cage_meets_box(cascade: u32, cage: vec3<i32>, local_min: vec3<f32>, local_max: vec3<f32>, transform: mat4x4<f32>) -> bool
+ * ```
+ *
+ * A reader at p reads the cage of p moved by at most {@link PROBE_RECEIVER_BIAS} of a spacing, in the cascade
+ * `probe_clipmap_select_in` answers for p and, in its blend skirt, in the next. So over a box:
+ *
+ * - `probe_clipmap_box_cascades`: the cascades its points can read, the first and one past the last, equal
+ *   where the box lies outside every selection box. From the cascade its point nearest the anchor selects to
+ *   the one its farthest does, and one more where the farthest lies in that one's skirt.
+ * - `probe_clipmap_box_cages`: in one of those, the block of cages such a reader can read: those of the box's
+ *   part inside the cascade's selection box, grown by the bias, and kept to the cascade's cage window. `dims`
+ *   holds a zero where there is none.
+ * - `probe_clipmap_box_cage_count`: the cages of every block.
+ *
+ * The blocks are a superset of what any surface inside the box reads. Two tests a thread a cage can afford
+ * narrow them, each still a superset:
+ *
+ * - `probe_clipmap_cage_is_read`: whether a point within the bias of the cage selects its cascade, or the
+ *   finer one in its skirt; a block holds cages no point reads where its box crosses a selection box's face.
+ * - `probe_clipmap_cage_meets_box`: whether the cage, grown by the bias, meets the box as it lies in its own
+ *   space, by its three axes: a flat box turned away from the world's axes fills its world box with cages
+ *   it never crosses.
+ *
+ * Reads `probe_levels`.
+ *
+ * @type {CodeChunk}
+ */
+export const chunk_probe_clipmap_box_cages = CodeChunk.from(
+    //language=WGSL
+    `
+struct ProbeClipmapBoxCages {
+    // the least cage of the block
+    first: vec3<i32>,
+    // its cages along each axis
+    dims: vec3<u32>,
+}
+
+fn probe_clipmap_box_max3(v: vec3<f32>) -> f32 {
+    return max(max(v.x, v.y), v.z);
+}
+
+// the finest cascade whose selection box holds a point \`reach\` from the anchor along its longest axis, or the count
+fn probe_clipmap_cascade_at_reach(reach: f32, cascade_count: u32, select_half: f32) -> u32 {
+    for (var i = 0u; i < ${CLIPMAP_LEVEL_LIMIT}u; i++) {
+        if (i >= cascade_count) {
+            break;
+        }
+
+        if (select_half * probe_levels[i].cell_size >= reach) {
+            return i;
+        }
+    }
+
+    return cascade_count;
+}
+
+fn probe_clipmap_box_cascades(box_min: vec3<f32>, box_max: vec3<f32>, cascade_count: u32, anchor: vec3<f32>, select_half: f32) -> vec2<u32> {
+    let reach_near = probe_clipmap_box_max3(abs(clamp(anchor, box_min, box_max) - anchor));
+    let reach_far = probe_clipmap_box_max3(max(abs(box_min - anchor), abs(box_max - anchor)));
+
+    let first = probe_clipmap_cascade_at_reach(reach_near, cascade_count, select_half);
+
+    if (first >= cascade_count) {
+        return vec2<u32>(cascade_count);
+    }
+
+    let last = min(probe_clipmap_cascade_at_reach(reach_far, cascade_count, select_half), cascade_count - 1u);
+    // past the last one's skirt line its farthest points read the next as well
+    let skirt = reach_far > (select_half - PROBE_BLEND_SKIRT) * probe_levels[last].cell_size;
+
+    return vec2<u32>(first, min(last + select(1u, 2u, skirt), cascade_count));
+}
+
+fn probe_clipmap_box_cages(box_min: vec3<f32>, box_max: vec3<f32>, cascade: u32, anchor: vec3<f32>, select_half: f32) -> ProbeClipmapBoxCages {
+    let level = probe_levels[cascade];
+    let cell = level.cell_size;
+    let bias = ${PROBE_RECEIVER_BIAS} * cell;
+
+    // the box's part whose points select this cascade or a finer one
+    let half = vec3<f32>(select_half * cell);
+    let a = max(box_min, anchor - half);
+    let b = min(box_max, anchor + half);
+
+    // their cages, the bias either way, inside the cage window
+    let first = max(vec3<i32>(floor((a - bias) / cell)), level.corner);
+    let last = min(vec3<i32>(floor((b + bias) / cell)), level.corner + level.size - vec3<i32>(1));
+
+    var out: ProbeClipmapBoxCages;
+
+    out.first = first;
+    out.dims = vec3<u32>(max(last - first + vec3<i32>(1), vec3<i32>(0)));
+
+    if (any(a > b)) {
+        out.dims = vec3<u32>(0u);
+    }
+
+    return out;
+}
+
+fn probe_clipmap_box_cage_count(box_min: vec3<f32>, box_max: vec3<f32>, cascade_count: u32, anchor: vec3<f32>, select_half: f32) -> u32 {
+    let cascades = probe_clipmap_box_cascades(box_min, box_max, cascade_count, anchor, select_half);
+
+    var count = 0u;
+
+    for (var i = 0u; i < ${CLIPMAP_LEVEL_LIMIT}u; i++) {
+        let cascade = cascades.x + i;
+
+        if (cascade >= cascades.y) {
+            break;
+        }
+
+        let cages = probe_clipmap_box_cages(box_min, box_max, cascade, anchor, select_half);
+
+        count += cages.dims.x * cages.dims.y * cages.dims.z;
+    }
+
+    return count;
+}
+
+fn probe_clipmap_cage_is_read(cascade: u32, cage: vec3<i32>, anchor: vec3<f32>, select_half: f32) -> bool {
+    let cell = probe_levels[cascade].cell_size;
+    // the points that read the cage lie within the bias of it
+    let half = (0.5 + ${PROBE_RECEIVER_BIAS}) * cell;
+    let from_anchor = abs((vec3<f32>(cage) + 0.5) * cell - anchor);
+
+    // one of them selects this cascade or a finer one
+    var read = probe_clipmap_box_max3(max(from_anchor - half, vec3<f32>(0.0))) <= select_half * cell;
+
+    if (cascade > 0u) {
+        // and not every one selects a finer one short of its skirt
+        read = read && probe_clipmap_box_max3(from_anchor + half) > (select_half - PROBE_BLEND_SKIRT) * probe_levels[cascade - 1u].cell_size;
+    }
+
+    return read;
+}
+
+fn probe_clipmap_cage_meets_box(cascade: u32, cage: vec3<i32>, local_min: vec3<f32>, local_max: vec3<f32>, transform: mat4x4<f32>) -> bool {
+    let cell = probe_levels[cascade].cell_size;
+    let half = (0.5 + ${PROBE_RECEIVER_BIAS}) * cell;
+    let local_half = 0.5 * (local_max - local_min);
+    let offset = (vec3<f32>(cage) + 0.5) * cell - (transform * vec4<f32>(0.5 * (local_min + local_max), 1.0)).xyz;
+
+    // each of the box's own axes by name: a dynamic index would put the matrix in local memory
+    let x = transform[0].xyz;
+    let y = transform[1].xyz;
+    let z = transform[2].xyz;
+
+    // along an axis, the cage's reach and the box's, against how far apart their centres are: the axis is
+    // left at the transform's scale, which every term carries
+    return abs(dot(offset, x)) <= half * (abs(x.x) + abs(x.y) + abs(x.z)) + local_half.x * dot(x, x)
+        && abs(dot(offset, y)) <= half * (abs(y.x) + abs(y.y) + abs(y.z)) + local_half.y * dot(y, y)
+        && abs(dot(offset, z)) <= half * (abs(z.x) + abs(z.y) + abs(z.z)) + local_half.z * dot(z, z);
+}
+`, [
+        chunk_probe_clipmap,
+        CLIPMAP_LEVEL_STRUCT.declaration_chunk,
+    ]);
+
+chunk_probe_clipmap_box_cages.requireResource(PROBE_LEVELS_RESOURCE);

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

@@ -3,13 +3,13 @@
  *
  * ```wgsl
  * struct ProbeClipmapHitMaterial { found: bool, albedo: vec3<f32>, emissive: vec3<f32> }
- * fn probe_clipmap_hit_material(position: vec3<f32>, normal: vec3<f32>, cascade: u32) -> ProbeClipmapHitMaterial
+ * fn probe_clipmap_hit_material(position: vec3<f32>, normal: vec3<f32>, cascade: u32, atlas_shift: u32) -> ProbeClipmapHitMaterial
  * ```
  *
  * The hit is at `position` in brick cascade `cascade`, its field's normal `normal`: the brick holding it,
  * looked up in the brick map at the hit's cascade as the march found it, and its material there
  * (`brick_material_surface`), albedo and emissive. A hit whose brick carries no material for its surface
- * is black, `found` false.
+ * is black, `found` false. `atlas_shift` is the brick atlas's footprint, as `chunk_brick_clipmap_sample` takes it.
  *
  * @type {CodeChunk}
  */
@@ -18,7 +18,7 @@ export const chunk_probe_clipmap_hit_material: CodeChunk;
  * The material a probe ray's hit takes its light with, from one texel of the brick material:
  *
  * ```wgsl
- * fn probe_clipmap_hit_material_pick(position: vec3<f32>, normal: vec3<f32>, cascade: u32, u: f32) -> ProbeClipmapHitMaterial
+ * fn probe_clipmap_hit_material_pick(position: vec3<f32>, normal: vec3<f32>, cascade: u32, u: f32, atlas_shift: u32) -> ProbeClipmapHitMaterial
  * ```
  *
  * As {@link chunk_probe_clipmap_hit_material} finds the hit's brick, one of the texels its blend weighs
@@ -33,7 +33,7 @@ export const chunk_probe_clipmap_hit_material_pick: CodeChunk;
  * surface, for the debug views: the GI's light takes none of it yet.
  *
  * ```wgsl
- * fn probe_clipmap_hit_metal_rough(position: vec3<f32>, normal: vec3<f32>, cascade: u32) -> vec3<f32> // (metalness, roughness, 1 if found)
+ * fn probe_clipmap_hit_metal_rough(position: vec3<f32>, normal: vec3<f32>, cascade: u32, atlas_shift: u32) -> vec3<f32> // (metalness, roughness, 1 if found)
  * ```
  *
  * @type {CodeChunk}

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

@@ -48,26 +48,26 @@ brick_at.requireResource(BRICK_MAP_TEXTURE_RESOURCE);
  *
  * ```wgsl
  * struct ProbeClipmapHitMaterial { found: bool, albedo: vec3<f32>, emissive: vec3<f32> }
- * fn probe_clipmap_hit_material(position: vec3<f32>, normal: vec3<f32>, cascade: u32) -> ProbeClipmapHitMaterial
+ * fn probe_clipmap_hit_material(position: vec3<f32>, normal: vec3<f32>, cascade: u32, atlas_shift: u32) -> ProbeClipmapHitMaterial
  * ```
  *
  * The hit is at `position` in brick cascade `cascade`, its field's normal `normal`: the brick holding it,
  * looked up in the brick map at the hit's cascade as the march found it, and its material there
  * (`brick_material_surface`), albedo and emissive. A hit whose brick carries no material for its surface
- * is black, `found` false.
+ * is black, `found` false. `atlas_shift` is the brick atlas's footprint, as `chunk_brick_clipmap_sample` takes it.
  *
  * @type {CodeChunk}
  */
 export const chunk_probe_clipmap_hit_material = CodeChunk.from(
     //language=WGSL
     `
-fn probe_clipmap_hit_material(position: vec3<f32>, normal: vec3<f32>, cascade: u32) -> ProbeClipmapHitMaterial {
+fn probe_clipmap_hit_material(position: vec3<f32>, normal: vec3<f32>, cascade: u32, atlas_shift: u32) -> ProbeClipmapHitMaterial {
     var out: ProbeClipmapHitMaterial;
 
     let brick = probe_clipmap_hit_brick(position, cascade);
 
     if (brick_clipmap_entry_holds_slot(brick.entry)) {
-        let seen = brick_material_surface(brick.entry, brick.local, normal);
+        let seen = brick_material_surface(brick.entry, brick.local, normal, atlas_shift);
 
         out.found = seen.found;
         out.albedo = seen.albedo;
@@ -82,7 +82,7 @@ fn probe_clipmap_hit_material(position: vec3<f32>, normal: vec3<f32>, cascade: u
  * The material a probe ray's hit takes its light with, from one texel of the brick material:
  *
  * ```wgsl
- * fn probe_clipmap_hit_material_pick(position: vec3<f32>, normal: vec3<f32>, cascade: u32, u: f32) -> ProbeClipmapHitMaterial
+ * fn probe_clipmap_hit_material_pick(position: vec3<f32>, normal: vec3<f32>, cascade: u32, u: f32, atlas_shift: u32) -> ProbeClipmapHitMaterial
  * ```
  *
  * As {@link chunk_probe_clipmap_hit_material} finds the hit's brick, one of the texels its blend weighs
@@ -94,13 +94,13 @@ fn probe_clipmap_hit_material(position: vec3<f32>, normal: vec3<f32>, cascade: u
 export const chunk_probe_clipmap_hit_material_pick = CodeChunk.from(
     //language=WGSL
     `
-fn probe_clipmap_hit_material_pick(position: vec3<f32>, normal: vec3<f32>, cascade: u32, u: f32) -> ProbeClipmapHitMaterial {
+fn probe_clipmap_hit_material_pick(position: vec3<f32>, normal: vec3<f32>, cascade: u32, u: f32, atlas_shift: u32) -> ProbeClipmapHitMaterial {
     var out: ProbeClipmapHitMaterial;
 
     let brick = probe_clipmap_hit_brick(position, cascade);
 
     if (brick_clipmap_entry_holds_slot(brick.entry)) {
-        let seen = brick_material_surface_pick(brick.entry, brick.local, normal, u);
+        let seen = brick_material_surface_pick(brick.entry, brick.local, normal, u, atlas_shift);
 
         out.found = seen.found;
         out.albedo = seen.albedo;
@@ -116,7 +116,7 @@ fn probe_clipmap_hit_material_pick(position: vec3<f32>, normal: vec3<f32>, casca
  * surface, for the debug views: the GI's light takes none of it yet.
  *
  * ```wgsl
- * fn probe_clipmap_hit_metal_rough(position: vec3<f32>, normal: vec3<f32>, cascade: u32) -> vec3<f32> // (metalness, roughness, 1 if found)
+ * fn probe_clipmap_hit_metal_rough(position: vec3<f32>, normal: vec3<f32>, cascade: u32, atlas_shift: u32) -> vec3<f32> // (metalness, roughness, 1 if found)
  * ```
  *
  * @type {CodeChunk}
@@ -124,14 +124,14 @@ fn probe_clipmap_hit_material_pick(position: vec3<f32>, normal: vec3<f32>, casca
 export const chunk_probe_clipmap_hit_metal_rough = CodeChunk.from(
     //language=WGSL
     `
-fn probe_clipmap_hit_metal_rough(position: vec3<f32>, normal: vec3<f32>, cascade: u32) -> vec3<f32> {
+fn probe_clipmap_hit_metal_rough(position: vec3<f32>, normal: vec3<f32>, cascade: u32, atlas_shift: u32) -> vec3<f32> {
     let brick = probe_clipmap_hit_brick(position, cascade);
 
     if (!brick_clipmap_entry_holds_slot(brick.entry)) {
         return vec3<f32>(0.0);
     }
 
-    let seen = brick_material_metal_rough(brick.entry, brick.local, normal);
+    let seen = brick_material_metal_rough(brick.entry, brick.local, normal, atlas_shift);
 
     return vec3<f32>(seen.metal_rough, select(0.0, 1.0, seen.found));
 }