@woosh/meep-engine 3.64.1 → 3.65.0

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

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

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

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

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

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

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

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

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

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

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));
 }

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

@@ -0,0 +1,31 @@
+/**
+ * A one-step sphere parallax for a probe's radiance tap (PROBE_CLIPMAP_PROPOSAL_2026_10_27.md §9.3, "Parallax
+ * correction"): the direction along which a probe sees what a ray from another point reaches.
+ *
+ * ```wgsl
+ * fn probe_clipmap_parallax(slot: u32, probe: vec3<f32>, spacing: f32, position: vec3<f32>, direction: vec3<f32>) -> vec3<f32>
+ * ```
+ *
+ * - `probe` is where the slot's probe stands, `spacing` its cascade's; `direction` is unit.
+ * - The ray from `position` along `direction` is met with a sphere about the probe whose radius is the probe's
+ *   mean depth along `direction`, one bilinear tap of its depth tile. The far root is taken, so a point inside
+ *   the sphere always meets it. The result is the unit direction from the probe to where they meet.
+ * - Where the ray misses the sphere, or meets it only behind the point, the result is `direction`.
+ *
+ * **Misses.** The depth is the visibility's (§8.2): a ray that missed, and a hit further than
+ * `PROBE_DEPTH_LIMIT` spacings, are both stored as the limit. The sphere therefore never stands further than
+ * the limit, and whatever lies past it, the sky included, is taken to be that near. A point a distance d from
+ * the probe has its direction toward such a thing turned by up to asin(d / (limit · spacing)), where the right
+ * turn for the sky is none. The probes of a cage each turn by their own angle, so their taps of one distant
+ * thing land on different texels. The depth cannot tell a miss from a hit at the limit, and its two moments say
+ * what share of a texel's rays went past the limit but not how far: a parallax that is right past the limit
+ * needs a distance the probe does not store.
+ *
+ * `probe_clipmap_sample_radiance` does not take this parallax, for that reason: it taps along the lobe. The
+ * chunk is kept for a reader whose probes see nothing past the limit.
+ *
+ * @type {CodeChunk}
+ */
+export const chunk_probe_clipmap_parallax: CodeChunk;
+import { CodeChunk } from "../../../shader/compiler/CodeChunk.js";
+//# sourceMappingURL=chunk_probe_clipmap_parallax.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"chunk_probe_clipmap_parallax.d.ts","sourceRoot":"","sources":["../../../../../../../src/shade/renderer/global_illumination/probe_clipmap/probe/chunk_probe_clipmap_parallax.js"],"names":[],"mappings":"AAGA;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2BG;AACH,2CAFU,SAAS,CAwBZ;0BArDmB,uCAAuC"}

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

@@ -0,0 +1,54 @@
+import { CodeChunk } from "../../../shader/compiler/CodeChunk.js";
+import { chunk_probe_clipmap_pick } from "./chunk_probe_clipmap_pick.js";
+
+/**
+ * A one-step sphere parallax for a probe's radiance tap (PROBE_CLIPMAP_PROPOSAL_2026_10_27.md §9.3, "Parallax
+ * correction"): the direction along which a probe sees what a ray from another point reaches.
+ *
+ * ```wgsl
+ * fn probe_clipmap_parallax(slot: u32, probe: vec3<f32>, spacing: f32, position: vec3<f32>, direction: vec3<f32>) -> vec3<f32>
+ * ```
+ *
+ * - `probe` is where the slot's probe stands, `spacing` its cascade's; `direction` is unit.
+ * - The ray from `position` along `direction` is met with a sphere about the probe whose radius is the probe's
+ *   mean depth along `direction`, one bilinear tap of its depth tile. The far root is taken, so a point inside
+ *   the sphere always meets it. The result is the unit direction from the probe to where they meet.
+ * - Where the ray misses the sphere, or meets it only behind the point, the result is `direction`.
+ *
+ * **Misses.** The depth is the visibility's (§8.2): a ray that missed, and a hit further than
+ * `PROBE_DEPTH_LIMIT` spacings, are both stored as the limit. The sphere therefore never stands further than
+ * the limit, and whatever lies past it, the sky included, is taken to be that near. A point a distance d from
+ * the probe has its direction toward such a thing turned by up to asin(d / (limit · spacing)), where the right
+ * turn for the sky is none. The probes of a cage each turn by their own angle, so their taps of one distant
+ * thing land on different texels. The depth cannot tell a miss from a hit at the limit, and its two moments say
+ * what share of a texel's rays went past the limit but not how far: a parallax that is right past the limit
+ * needs a distance the probe does not store.
+ *
+ * `probe_clipmap_sample_radiance` does not take this parallax, for that reason: it taps along the lobe. The
+ * chunk is kept for a reader whose probes see nothing past the limit.
+ *
+ * @type {CodeChunk}
+ */
+export const chunk_probe_clipmap_parallax = CodeChunk.from(
+    //language=WGSL
+    `
+fn probe_clipmap_parallax(slot: u32, probe: vec3<f32>, spacing: f32, position: vec3<f32>, direction: vec3<f32>) -> vec3<f32> {
+    // a miss reads the limit here, as a hit at the limit does: see the chunk's notes on misses
+    let radius = probe_clipmap_depth_moments(slot, direction).x * spacing;
+    let origin = position - probe;
+    let b = dot(direction, origin);
+    let discriminant = b * b - (dot(origin, origin) - radius * radius);
+
+    if (discriminant >= 0.0) {
+        let t = sqrt(discriminant) - b;
+
+        if (t > 0.0) {
+            return normalize(origin + t * direction);
+        }
+    }
+
+    return direction;
+}
+`, [
+        chunk_probe_clipmap_pick,
+    ]);

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

@@ -13,10 +13,14 @@
  *   picked by, at the visibility it was picked at. The trilinear part cancels.
  * - **The sample vector** is Lagarde's dominant direction, `normalize(mix(r, n, α))` with r the
  *   reflection of the view and α the roughness squared.
- * - **A radiance tap** a probe, along the sample vector after a one-step sphere parallax: the reflected ray
- *   is met with a sphere about the probe whose radius is its mean depth along the vector. The depth is held
- *   at the cage's diagonal (§8.2), past which no parallax is taken. One bilinear tap of the tile, through
- *   its skirt and the depth's sampler.
+ * - **A radiance tap** a probe, along the sample vector: one bilinear tap of the tile, through its skirt and
+ *   the depth's sampler. Every picked probe is tapped along the same direction, as if what it sees there were
+ *   infinitely far.
+ * - **No parallax** is taken toward what a probe sees along the vector. The only distance a probe stores is its
+ *   visibility depth, where a miss and a hit past `PROBE_DEPTH_LIMIT` both read the limit, so a sphere of
+ *   that depth turns the taps of the sky and of everything distant, each probe's by its own angle
+ *   (`chunk_probe_clipmap_parallax`, kept beside this chunk and not linked by it; §9.3, "Parallax
+ *   correction"). A reflection of something nearer than the limit is therefore placed as if it were far.
  * - **The rough end** is the probes' SH, mixed by the same shares and resolved for the GGX lobe
  *   (`sh3_color_get_radiance_with_GGX`, as Brick4 resolves its probes). The two are blended by
  *   `roughness_to_mip_ratio`: SH alone from roughness 0.7.

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

@@ -1 +1 @@
-{"version":3,"file":"chunk_probe_clipmap_sample_radiance.d.ts","sourceRoot":"","sources":["../../../../../../../src/shade/renderer/global_illumination/probe_clipmap/probe/chunk_probe_clipmap_sample_radiance.js"],"names":[],"mappings":"AA4BA;;;;;;;;;;;;;;;;;;;;;;;;;GAyBG;AACH,kDAFU,SAAS,CAmIZ;0BA1KmB,uCAAuC"}
+{"version":3,"file":"chunk_probe_clipmap_sample_radiance.d.ts","sourceRoot":"","sources":["../../../../../../../src/shade/renderer/global_illumination/probe_clipmap/probe/chunk_probe_clipmap_sample_radiance.js"],"names":[],"mappings":"AA4BA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA6BG;AACH,kDAFU,SAAS,CAoHZ;0BA/JmB,uCAAuC"}

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

@@ -41,10 +41,14 @@ import { PROBE_RECEIVER_BIAS_VIEW } from "./PROBE_CLIPMAP.js";
  *   picked by, at the visibility it was picked at. The trilinear part cancels.
  * - **The sample vector** is Lagarde's dominant direction, `normalize(mix(r, n, α))` with r the
  *   reflection of the view and α the roughness squared.
- * - **A radiance tap** a probe, along the sample vector after a one-step sphere parallax: the reflected ray
- *   is met with a sphere about the probe whose radius is its mean depth along the vector. The depth is held
- *   at the cage's diagonal (§8.2), past which no parallax is taken. One bilinear tap of the tile, through
- *   its skirt and the depth's sampler.
+ * - **A radiance tap** a probe, along the sample vector: one bilinear tap of the tile, through its skirt and
+ *   the depth's sampler. Every picked probe is tapped along the same direction, as if what it sees there were
+ *   infinitely far.
+ * - **No parallax** is taken toward what a probe sees along the vector. The only distance a probe stores is its
+ *   visibility depth, where a miss and a hit past `PROBE_DEPTH_LIMIT` both read the limit, so a sphere of
+ *   that depth turns the taps of the sky and of everything distant, each probe's by its own angle
+ *   (`chunk_probe_clipmap_parallax`, kept beside this chunk and not linked by it; §9.3, "Parallax
+ *   correction"). A reflection of something nearer than the limit is therefore placed as if it were far.
  * - **The rough end** is the probes' SH, mixed by the same shares and resolved for the GGX lobe
  *   (`sh3_color_get_radiance_with_GGX`, as Brick4 resolves its probes). The two are blended by
  *   `roughness_to_mip_ratio`: SH alone from roughness 0.7.
@@ -97,23 +101,8 @@ fn probe_clipmap_lobe(slot: u32, share: f32, position: vec3<f32>, normal: vec3<f
     out.weight = share * probe_visibility_weight(toward, lobe, visibility) / probe_visibility_weight(toward, normal, visibility);
     out.sh = probe_record_sh_decode(record.sh);
 
-    // the reflected ray met with a sphere about the probe, its radius the probe's mean depth along the lobe
-    let radius = probe_clipmap_depth_moments(slot, lobe).x * spacing;
-    let origin = position - probe;
-    let b = dot(lobe, origin);
-    let discriminant = b * b - (dot(origin, origin) - radius * radius);
-
-    var direction = lobe;
-
-    if (discriminant >= 0.0) {
-        let t = sqrt(discriminant) - b;
-
-        if (t > 0.0) {
-            direction = normalize(origin + t * lobe);
-        }
-    }
-
-    out.radiance = probe_clipmap_radiance(slot, direction).rgb;
+    // along the lobe itself: no parallax toward what the probe sees there (chunk_probe_clipmap_parallax, on misses)
+    out.radiance = probe_clipmap_radiance(slot, lobe).rgb;
 
     return out;
 }