@woosh/meep-engine 3.64.1 → 3.67.0

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

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

@@ -4,8 +4,13 @@
  *
  * ```wgsl
  * fn probe_clipmap_want(wants: bool, position: vec3<f32>, bias_direction: vec3<f32>, cascade_count: u32, resolution: u32, anchor: vec3<f32>, select_half: f32, wanted_capacity: u32)
+ * fn probe_clipmap_want_cage(wants: bool, cascade: u32, cage: vec3<i32>, resolution: u32, wanted_capacity: u32)
  * ```
  *
+ * `probe_clipmap_want_cage` wants one cage by name, the cage whose least point is `cage` in `cascade`, for a
+ * caller that knows its cages without a point to read them from; the cascade's cage window must hold it
+ * (`clipmap_contains`). `probe_clipmap_want` is the two it reads from a point.
+ *
  * The cages are the pick's: the cascade `probe_clipmap_select_in` answers for the point, by the windows'
  * `anchor` and `select_half` as the pick reads them, the cage of the point biased along `bias_direction` by
  * that cascade's spacing, and in the cascade's blend skirt the next cascade's cage too, biased by its own. A cage a bias moved out of its window is not wanted. Each cage
@@ -16,8 +21,8 @@
  * workgroup's table and sets its bits; the rest want it through that lane. Measured on the AMD iGPU at
  * 1280×720 on Sponza before the claims, the bits' atomics were 140 of want's 345 µs and the appends 90.
  *
- * Every lane of the workgroup calls it once, wanting or not, from uniform control flow: the appends are
- * the subgroup's.
+ * Every lane of the workgroup calls `probe_clipmap_want` once, or `probe_clipmap_want_cage` at most twice, which
+ * the claim table is sized for, wanting or not, from uniform control flow: the appends are the subgroup's.
  *
  * @type {CodeChunk}
  */

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

@@ -1 +1 @@
-{"version":3,"file":"chunk_probe_clipmap_want.d.ts","sourceRoot":"","sources":["../../../../../../../src/shade/renderer/global_illumination/probe_clipmap/probe/chunk_probe_clipmap_want.js"],"names":[],"mappings":"AA0BA;;;;;;;;;;;;;;;;;;;;;;GAsBG;AACH,uCAFU,SAAS,CAgFZ;0BA9HmB,uCAAuC"}
+{"version":3,"file":"chunk_probe_clipmap_want.d.ts","sourceRoot":"","sources":["../../../../../../../src/shade/renderer/global_illumination/probe_clipmap/probe/chunk_probe_clipmap_want.js"],"names":[],"mappings":"AA0BA;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2BG;AACH,uCAFU,SAAS,CA+EZ;0BAlImB,uCAAuC"}

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

@@ -13,7 +13,7 @@ import { PROBE_THREAD_WORKGROUP_SIZE } from "./PROBE_CLIPMAP.js";
 /**
  * Slots of a workgroup's claim table: twice the claims its lanes make at most, a cage in each of two
  * cascades a lane, so a probe finds a slot within a few. Sized for {@link PROBE_THREAD_WORKGROUP_SIZE}
- * lanes: want's 8×8 tiles, and the hits' wants' 64.
+ * lanes: want's 8×8 tiles, and the hits' wants' 64; the meshlets' wants' lanes are twice as many, a cage each.
  * @type {number}
  */
 const WANT_CLAIM_SLOTS = 2 * 2 * PROBE_THREAD_WORKGROUP_SIZE;
@@ -30,8 +30,13 @@ const WANT_CLAIM_PROBES = 16;
  *
  * ```wgsl
  * fn probe_clipmap_want(wants: bool, position: vec3<f32>, bias_direction: vec3<f32>, cascade_count: u32, resolution: u32, anchor: vec3<f32>, select_half: f32, wanted_capacity: u32)
+ * fn probe_clipmap_want_cage(wants: bool, cascade: u32, cage: vec3<i32>, resolution: u32, wanted_capacity: u32)
  * ```
  *
+ * `probe_clipmap_want_cage` wants one cage by name, the cage whose least point is `cage` in `cascade`, for a
+ * caller that knows its cages without a point to read them from; the cascade's cage window must hold it
+ * (`clipmap_contains`). `probe_clipmap_want` is the two it reads from a point.
+ *
  * The cages are the pick's: the cascade `probe_clipmap_select_in` answers for the point, by the windows'
  * `anchor` and `select_half` as the pick reads them, the cage of the point biased along `bias_direction` by
  * that cascade's spacing, and in the cascade's blend skirt the next cascade's cage too, biased by its own. A cage a bias moved out of its window is not wanted. Each cage
@@ -42,8 +47,8 @@ const WANT_CLAIM_PROBES = 16;
  * workgroup's table and sets its bits; the rest want it through that lane. Measured on the AMD iGPU at
  * 1280×720 on Sponza before the claims, the bits' atomics were 140 of want's 345 µs and the appends 90.
  *
- * Every lane of the workgroup calls it once, wanting or not, from uniform control flow: the appends are
- * the subgroup's.
+ * Every lane of the workgroup calls `probe_clipmap_want` once, or `probe_clipmap_want_cage` at most twice, which
+ * the claim table is sized for, wanting or not, from uniform control flow: the appends are the subgroup's.
  *
  * @type {CodeChunk}
  */
@@ -80,46 +85,45 @@ fn probe_want_claim(key: u32) -> bool {
     return true;
 }
 
-fn probe_clipmap_want(wants: bool, position: vec3<f32>, bias_direction: vec3<f32>, cascade_count: u32, resolution: u32, anchor: vec3<f32>, select_half: f32, wanted_capacity: u32) {
-    let selection = probe_clipmap_select_in(&probe_levels, cascade_count, anchor, select_half, position);
-
-    let held = wants && selection.level != CLIPMAP_LEVEL_NONE;
-    let finest = select(0u, selection.level, held);
-    let next = min(finest + 1u, cascade_count - 1u);
-
-    var cage_finest: vec3<i32>;
-    var cage_next: vec3<i32>;
-
+fn probe_clipmap_want_cage(wants: bool, cascade: u32, cage: vec3<i32>, resolution: u32, wanted_capacity: u32) {
     // storage wraps by the window's side, a power of two: the low bits of a point, negative ones too
     let wrap = vec3<u32>(resolution - 1u);
 
-    let wants_finest = held && probe_clipmap_cage(finest, position, bias_direction, &cage_finest)
-        && probe_want_claim(probe_clipmap_key(finest, vec3<u32>(cage_finest) & wrap, resolution));
-    let wants_next = held && selection.edge_weight > 0.0 && finest + 1u < cascade_count
-        && probe_clipmap_cage(next, position, bias_direction, &cage_next)
-        && probe_want_claim(probe_clipmap_key(next, vec3<u32>(cage_next) & wrap, resolution));
-
-    // every lane through all sixteen corners, so that the appends stay in uniform control flow
-    for (var k = 0u; k < 16u; k++) {
-        let coarse = k >= 8u;
-        let cascade = select(finest, next, coarse);
-        let wanted = select(wants_finest, wants_next, coarse);
-        let corner = vec3<i32>(vec3<u32>(k & 1u, (k >> 1u) & 1u, (k >> 2u) & 1u));
-        let point = select(cage_finest, cage_next, coarse) + corner;
+    let claimed = wants && probe_want_claim(probe_clipmap_key(cascade, vec3<u32>(cage) & wrap, resolution));
 
-        let storage = vec3<u32>(point) & wrap;
-        let key = probe_clipmap_key(cascade, storage, resolution);
+    // every lane through all eight corners, so that the appends stay in uniform control flow
+    for (var k = 0u; k < 8u; k++) {
+        let corner = vec3<i32>(vec3<u32>(k & 1u, (k >> 1u) & 1u, (k >> 2u) & 1u));
+        let key = probe_clipmap_key(cascade, vec3<u32>(cage + corner) & wrap, resolution);
         let bit = 1u << (key & 31u);
 
         var first = false;
 
-        if (wanted) {
+        if (claimed) {
             first = (atomicOr(&probe_wanted_bits[key >> 5u], bit) & bit) == 0u;
         }
 
         collection_u32_append(&probe_wanted, first, key, wanted_capacity);
     }
 }
+
+fn probe_clipmap_want(wants: bool, position: vec3<f32>, bias_direction: vec3<f32>, cascade_count: u32, resolution: u32, anchor: vec3<f32>, select_half: f32, wanted_capacity: u32) {
+    let selection = probe_clipmap_select_in(&probe_levels, cascade_count, anchor, select_half, position);
+
+    let held = wants && selection.level != CLIPMAP_LEVEL_NONE;
+    let finest = select(0u, selection.level, held);
+    let next = min(finest + 1u, cascade_count - 1u);
+
+    var cage_finest: vec3<i32>;
+    var cage_next: vec3<i32>;
+
+    let wants_finest = held && probe_clipmap_cage(finest, position, bias_direction, &cage_finest);
+    let wants_next = held && selection.edge_weight > 0.0 && finest + 1u < cascade_count
+        && probe_clipmap_cage(next, position, bias_direction, &cage_next);
+
+    probe_clipmap_want_cage(wants_finest, finest, cage_finest, resolution, wanted_capacity);
+    probe_clipmap_want_cage(wants_next, next, cage_next, resolution, wanted_capacity);
+}
 `, [
         chunk_probe_clipmap,
         chunk_probe_clipmap_select_in,

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

@@ -0,0 +1,28 @@
+/**
+ * Record the wants of a list of meshlets whose fragments pick probes (PROBE_CLIPMAP_PROPOSAL_2026_10_27.md §8.3):
+ * the meshlets a forward pass draws, which no pixel of the G-buffer stands for. Each wants the cages a reader
+ * anywhere inside its world box can read, a thread a cage: its cages are counted
+ * (`shader_probe_clipmap_want_meshlet_count`), the counts summed (`graph_prefix_scan_csdldf`), and the sums
+ * launch the wants (`shader_probe_clipmap_want_meshlets`), as the meshes' expansion to meshlets is launched.
+ *
+ * The wants go into the clipmap's late set (`GPUProbeClipmap.write_want_bindings`), so the pass belongs after the
+ * clipmap's lifetime in the frame, and its probes are admitted by the next frame's.
+ *
+ * @param {Object} options
+ * @param {import("../../../../../engine/graphics/render/frame_graph/FrameGraph.js").FrameGraph} options.graph
+ * @param {import("./GPUProbeClipmap.js").GPUProbeClipmap} options.clipmap the clipmap the fragments pick from
+ * @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, a
+ *   workgroup of `COMPUTE_SHADER_DEFAULT_GROUP_SIZE` meshlets, folded
+ */
+export function graph_probe_clipmap_want_meshlets({ graph, clipmap, scene, camera, meshlet_collection, meshlet_iterator_command }: {
+    graph: import("../../../../../engine/graphics/render/frame_graph/FrameGraph.js").FrameGraph;
+    clipmap: import("./GPUProbeClipmap.js").GPUProbeClipmap;
+    scene: import("../../../scene/GPUSceneContext.js").GPUSceneContext;
+    camera: number;
+    meshlet_collection: number;
+    meshlet_iterator_command: number;
+}): void;
+//# sourceMappingURL=graph_probe_clipmap_want_meshlets.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"graph_probe_clipmap_want_meshlets.d.ts","sourceRoot":"","sources":["../../../../../../../src/shade/renderer/global_illumination/probe_clipmap/probe/graph_probe_clipmap_want_meshlets.js"],"names":[],"mappings":"AAqBA;;;;;;;;;;;;;;;;;;GAkBG;AACH;IARyG,KAAK,EAAnG,OAAO,iEAAiE,EAAE,UAAU;IAC5B,OAAO,EAA/D,OAAO,sBAAsB,EAAE,eAAe;IACuB,KAAK,EAA1E,OAAO,mCAAmC,EAAE,eAAe;IAC3C,MAAM,EAAtB,MAAM;IACU,kBAAkB,EAAlC,MAAM;IACU,wBAAwB,EAAxC,MAAM;SAoGhB"}