@woosh/meep-engine 3.61.1 → 3.61.3

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

@@ -0,0 +1,138 @@
+import { MESH_SDF_BRICK_VOXELS } from "../../../geometry/sdf/MESH_SDF.js";
+import { CodeChunk } from "../../../shader/compiler/CodeChunk.js";
+import { chunk_brick_clipmap } from "../brick/chunk_brick_clipmap.js";
+import { BRICK_LEVELS_RESOURCE, BRICK_MAP_TEXTURE_RESOURCE } from "../brick/chunk_brick_clipmap_trace.js";
+import {
+    chunk_brick_material_metal_rough,
+    chunk_brick_material_surface,
+    chunk_brick_material_surface_pick
+} from "../material/chunk_brick_material.js";
+
+/**
+ * The brick of a hit's cascade holding its position: its slot, or no slot, and the position in voxels
+ * from its corner; and the material a hit's read gives.
+ */
+const brick_at = CodeChunk.from(
+    //language=WGSL
+    `
+struct ProbeClipmapHitBrick {
+    entry: u32,
+    local: vec3<f32>,
+}
+
+struct ProbeClipmapHitMaterial {
+    found: bool,
+    albedo: vec3<f32>,
+    emissive: vec3<f32>,
+}
+
+fn probe_clipmap_hit_brick(position: vec3<f32>, cascade: u32) -> ProbeClipmapHitBrick {
+    let level = brick_levels[cascade];
+    let resolution = u32(level.size.x);
+    let cell = vec3<i32>(floor(position / level.cell_size));
+
+    var out: ProbeClipmapHitBrick;
+
+    out.entry = textureLoad(brick_map, brick_clipmap_map_texel(cascade, vec3<u32>(cell) & vec3<u32>(resolution - 1u), resolution), 0).x;
+    out.local = (position - vec3<f32>(cell) * level.cell_size) / (level.cell_size / ${MESH_SDF_BRICK_VOXELS}.0);
+
+    return out;
+}
+`, [chunk_brick_clipmap]);
+
+brick_at.requireResource(BRICK_LEVELS_RESOURCE);
+brick_at.requireResource(BRICK_MAP_TEXTURE_RESOURCE);
+
+/**
+ * The material a probe ray's hit takes its light with:
+ *
+ * ```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
+ * ```
+ *
+ * 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.
+ *
+ * @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 {
+    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);
+
+        out.found = seen.found;
+        out.albedo = seen.albedo;
+        out.emissive = seen.emissive;
+    }
+
+    return out;
+}
+`, [brick_at, chunk_brick_clipmap, chunk_brick_material_surface]);
+
+/**
+ * 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
+ * ```
+ *
+ * As {@link chunk_probe_clipmap_hit_material} finds the hit's brick, one of the texels its blend weighs
+ * drawn by `u` in [0, 1) in proportion to its weight (`brick_material_surface_pick`): the blend on
+ * average, which a probe's blend of its rays takes.
+ *
+ * @type {CodeChunk}
+ */
+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 {
+    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);
+
+        out.found = seen.found;
+        out.albedo = seen.albedo;
+        out.emissive = seen.emissive;
+    }
+
+    return out;
+}
+`, [brick_at, chunk_brick_clipmap, chunk_brick_material_surface_pick]);
+
+/**
+ * A probe ray's hit's metalness and roughness, as {@link chunk_probe_clipmap_hit_material} finds its
+ * 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)
+ * ```
+ *
+ * @type {CodeChunk}
+ */
+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> {
+    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);
+
+    return vec3<f32>(seen.metal_rough, select(0.0, 1.0, seen.found));
+}
+`, [brick_at, chunk_brick_clipmap, chunk_brick_material_metal_rough]);

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

@@ -0,0 +1,21 @@
+/**
+ * What the fused indirect pass writes of a pixel's indirect light, by {@link PROBE_CLIPMAP_INDIRECT_LOBE}:
+ *
+ * ```wgsl
+ * fn probe_clipmap_indirect_lobe(
+ *     specular: vec3<f32>,   // the radiance resolved by the surface's material and occluded
+ *     diffuse: vec3<f32>,    // the irradiance resolved by the surface's material and occluded
+ *     radiance: vec3<f32>,   // the probes' radiance along the surface's lobe, as sampled
+ *     irradiance: vec3<f32>, // the probes' irradiance at the bent normal, as sampled
+ * ) -> vec3<f32>
+ * ```
+ *
+ * - `Both`, the default: `specular + diffuse`, what the frame adds.
+ * - `Diffuse`: `irradiance / π`, the light alone, in radiance units: what a white Lambertian surface would send back.
+ * - `Specular`: `radiance`, the light alone.
+ *
+ * @type {CodeChunkChoice}
+ */
+export const chunk_probe_clipmap_indirect_lobe: CodeChunkChoice;
+import { CodeChunkChoice } from "../../../shader/compiler/CodeChunkChoice.js";
+//# sourceMappingURL=chunk_probe_clipmap_indirect_lobe.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"chunk_probe_clipmap_indirect_lobe.d.ts","sourceRoot":"","sources":["../../../../../../../src/shade/renderer/global_illumination/probe_clipmap/probe/chunk_probe_clipmap_indirect_lobe.js"],"names":[],"mappings":"AAMA;;;;;;;;;;;;;;;;;GAiBG;AACH,gDAFU,eAAe,CAE0E;gCAvBnE,6CAA6C"}

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

@@ -0,0 +1,49 @@
+import { CodeChunk } from "../../../shader/compiler/CodeChunk.js";
+import { CodeChunkChoice } from "../../../shader/compiler/CodeChunkChoice.js";
+import { RECIPROCAL_PI_DECLARATION } from "../../../shader/chunk/math/RECIPROCAL_PI_DECLARATION.js";
+import { PROBE_CLIPMAP_INDIRECT_LOBE } from "./PROBE_CLIPMAP_INDIRECT_LOBE.js";
+import { ProbeClipmapIndirectLobe } from "./ProbeClipmapIndirectLobe.js";
+
+/**
+ * What the fused indirect pass writes of a pixel's indirect light, by {@link PROBE_CLIPMAP_INDIRECT_LOBE}:
+ *
+ * ```wgsl
+ * fn probe_clipmap_indirect_lobe(
+ *     specular: vec3<f32>,   // the radiance resolved by the surface's material and occluded
+ *     diffuse: vec3<f32>,    // the irradiance resolved by the surface's material and occluded
+ *     radiance: vec3<f32>,   // the probes' radiance along the surface's lobe, as sampled
+ *     irradiance: vec3<f32>, // the probes' irradiance at the bent normal, as sampled
+ * ) -> vec3<f32>
+ * ```
+ *
+ * - `Both`, the default: `specular + diffuse`, what the frame adds.
+ * - `Diffuse`: `irradiance / π`, the light alone, in radiance units: what a white Lambertian surface would send back.
+ * - `Specular`: `radiance`, the light alone.
+ *
+ * @type {CodeChunkChoice}
+ */
+export const chunk_probe_clipmap_indirect_lobe = CodeChunkChoice.from(PROBE_CLIPMAP_INDIRECT_LOBE);
+
+chunk_probe_clipmap_indirect_lobe.add(ProbeClipmapIndirectLobe.Both, CodeChunk.from(
+    //language=WGSL
+    `
+fn probe_clipmap_indirect_lobe(specular: vec3<f32>, diffuse: vec3<f32>, radiance: vec3<f32>, irradiance: vec3<f32>) -> vec3<f32> {
+    return specular + diffuse;
+}
+`));
+
+chunk_probe_clipmap_indirect_lobe.add(ProbeClipmapIndirectLobe.Diffuse, CodeChunk.from(
+    //language=WGSL
+    `
+fn probe_clipmap_indirect_lobe(specular: vec3<f32>, diffuse: vec3<f32>, radiance: vec3<f32>, irradiance: vec3<f32>) -> vec3<f32> {
+    return irradiance * RECIPROCAL_PI;
+}
+`, [RECIPROCAL_PI_DECLARATION]));
+
+chunk_probe_clipmap_indirect_lobe.add(ProbeClipmapIndirectLobe.Specular, CodeChunk.from(
+    //language=WGSL
+    `
+fn probe_clipmap_indirect_lobe(specular: vec3<f32>, diffuse: vec3<f32>, radiance: vec3<f32>, irradiance: vec3<f32>) -> vec3<f32> {
+    return radiance;
+}
+`));

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

@@ -37,6 +37,8 @@ export const PROBE_DEPTH_SAMPLER_RESOURCE: ShaderResourceDescriptor;
  * fn probe_clipmap_depth_moments_in(sampling, depth, slot: u32, direction: vec3<f32>) -> vec2<f32>
  * ```
  *
+ * - **The cascade**: `probe_clipmap_select_in` by the sampling's `anchor` and `select_half`, as want takes it:
+ *   boxes on the anchor, so the blend between cascades moves with the anchor, not a window's step at a time.
  * - **The cage**: `probe_clipmap_cage_in` along mix(n, v, 0.2), as want takes it, so a pixel reads the
  *   probes it wanted.
  * - **The weights**, visibility only, of the cage's eight corners: a corner without an ALIVE probe weighs
@@ -47,9 +49,8 @@ export const PROBE_DEPTH_SAMPLER_RESOURCE: ShaderResourceDescriptor;
  *   cascade's blend skirt, two of the next one's too, the pairs lerped by the skirt's weight. A cascade
  *   whose corners weigh nothing gives way to the next coarser, without a skirt. With none left the
  *   weights are zero, and the fallback is the caller's (§9.1, step 6).
- * - **The SH**: the picked records' Metro L1 structs mixed by their weights; resolved with
- *   `resolve_irradiance_sh_to_diffuse` at the caller's normal, it gives E/π. `found` says whether any probe
- *   weighed anything.
+ * - **The SH**: the picked records' RGB radiance SH3 mixed by their weights; `sh3_color_get_irradiance_at`
+ *   at the caller's normal gives E. `found` says whether any probe weighed anything.
  *
  * Per cascade read: 8 indirection loads, 8 state words and 8 depth taps, then 2 indirection loads for
  * the pair; then two records a cascade read for the SH. A depth tile's place takes no integer division

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

@@ -1 +1 @@
-{"version":3,"file":"chunk_probe_clipmap_pick.d.ts","sourceRoot":"","sources":["../../../../../../../src/shade/renderer/global_illumination/probe_clipmap/probe/chunk_probe_clipmap_pick.js"],"names":[],"mappings":"AAgCA;;;;GAIG;AACH,oCAFU,YAAY,CAuBF;AAEpB;;;GAGG;AACH,sCAFU,wBAAwB,CAE+E;AAEjH;;;GAGG;AACH,8CAFU,wBAAwB,CAEiF;AAEnH;;;GAGG;AACH,6CAFU,iBAAiB,CAQvB;AAEJ;;;GAGG;AACH,2CAFU,wBAAwB,CAE+G;AAOjJ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAgCG;AACH,0CAFU,SAAS,CAyMhB;AAIH;;;;;;;;;;;;;;;;GAgBG;AACH,uCAFU,SAAS,CA0BhB;AASH;;;;;;;GAOG;AACH,2CAFU,6BAA6B,CAWG;6BA3Xb,sCAAsC;yCAH1B,sDAAsD;kCAhB7D,qDAAqD;0BAe7D,uCAAuC;8CAEnB,2DAA2D"}
+{"version":3,"file":"chunk_probe_clipmap_pick.d.ts","sourceRoot":"","sources":["../../../../../../../src/shade/renderer/global_illumination/probe_clipmap/probe/chunk_probe_clipmap_pick.js"],"names":[],"mappings":"AA8BA;;;;GAIG;AACH,oCAFU,YAAY,CA2BF;AAEpB;;;GAGG;AACH,sCAFU,wBAAwB,CAE+E;AAEjH;;;GAGG;AACH,8CAFU,wBAAwB,CAEiF;AAEnH;;;GAGG;AACH,6CAFU,iBAAiB,CAQvB;AAEJ;;;GAGG;AACH,2CAFU,wBAAwB,CAE+G;AAOjJ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAiCG;AACH,0CAFU,SAAS,CAiMhB;AAIH;;;;;;;;;;;;;;;;GAgBG;AACH,uCAFU,SAAS,CA0BhB;AASH;;;;;;;GAOG;AACH,2CAFU,6BAA6B,CAWG;6BAzXb,sCAAsC;yCAH1B,sDAAsD;kCAb7D,qDAAqD;0BAY7D,uCAAuC;8CAEnB,2DAA2D"}

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

@@ -1,5 +1,4 @@
 import { SamplerDescriptor } from "../../../../descriptor/texture/SamplerDescriptor.js";
-import { chunk_clipmap_select_finest } from "../../../shader/chunk/clipmap/chunk_clipmap_select_finest.js";
 import { CLIPMAP_LEVEL_ARRAY } from "../../../shader/chunk/clipmap/CLIPMAP_LEVEL_STRUCT.js";
 import {
     chunk_uv_octahedral_unit_encode
@@ -7,16 +6,14 @@ import {
 import { chunk_index_to_grid2d_reciprocal } from "../../../shader/chunk/grid/chunk_index_to_grid2d_reciprocal.js";
 import { chunk_probe_visibility_weight } from "../../../shader/chunk/light/probe/chunk_probe_visibility_weight.js";
 import { chunk_pick2_wrs_mat2x4 } from "../../../shader/chunk/random/reservoir/chunk_pick2_wrs_mat2x4.js";
-import {
-    METRO_L1_IRRADIANCE_STRUCT
-} from "../../../shader/chunk/spherical_harmonics/l1i/chunk_convert_to_irradiance_sh.js";
+import { chunk_sh3_color_add_scaled } from "../../../shader/chunk/spherical_harmonics/chunk_sh3_color_add_scaled.js";
 import {
     chunk_texture_octahedral_skirt_uv
 } from "../../../shader/chunk/texture/octahedral/chunk_texture_octahedral_skirt_uv.js";
 import { CodeChunk } from "../../../shader/compiler/CodeChunk.js";
 import { ShaderResourceDescriptor } from "../../../shader/resource/ShaderResourceDescriptor.js";
 import { ShaderResourceGroupDescriptor } from "../../../shader/resource/ShaderResourceGroupDescriptor.js";
-import { f32, u32, vec2f } from "../../../shader/type/WEBGPU_WGSL_PRIMITIVE_TYPES.js";
+import { f32, u32, vec2f, vec3f } from "../../../shader/type/WEBGPU_WGSL_PRIMITIVE_TYPES.js";
 import { WebGPUStruct } from "../../../shader/type/WebGPUStruct.js";
 import {
     chunk_probe_clipmap,
@@ -28,6 +25,7 @@ import {
     PROBE_STATES_READ_RESOURCE
 } from "./chunk_probe_clipmap.js";
 import { chunk_probe_clipmap_cage_in } from "./chunk_probe_clipmap_cage.js";
+import { chunk_probe_clipmap_select_in } from "./chunk_probe_clipmap_select.js";
 import { PROBE_RECEIVER_BIAS_VIEW } from "./PROBE_CLIPMAP.js";
 
 /**
@@ -56,6 +54,10 @@ export const PROBE_SAMPLING_STRUCT = WebGPUStruct.from({
     radiance_texel: vec2f,
     /** one over the radiance atlas's tiles a row, rounded to f32 */
     radiance_tiles_per_row_reciprocal: f32,
+    /** where the windows were placed around, world metres: the selection boxes' centre */
+    anchor: vec3f,
+    /** a selection box's half side, in its cascade's cells */
+    select_half: f32,
 }, "ProbeSampling");
 
 /**
@@ -106,6 +108,8 @@ const RECORDS = `ptr<storage, array<${PROBE_RECORD_STRUCT.wgsl_ref}>, read>`;
  * fn probe_clipmap_depth_moments_in(sampling, depth, slot: u32, direction: vec3<f32>) -> vec2<f32>
  * ```
  *
+ * - **The cascade**: `probe_clipmap_select_in` by the sampling's `anchor` and `select_half`, as want takes it:
+ *   boxes on the anchor, so the blend between cascades moves with the anchor, not a window's step at a time.
  * - **The cage**: `probe_clipmap_cage_in` along mix(n, v, 0.2), as want takes it, so a pixel reads the
  *   probes it wanted.
  * - **The weights**, visibility only, of the cage's eight corners: a corner without an ALIVE probe weighs
@@ -116,9 +120,8 @@ const RECORDS = `ptr<storage, array<${PROBE_RECORD_STRUCT.wgsl_ref}>, read>`;
  *   cascade's blend skirt, two of the next one's too, the pairs lerped by the skirt's weight. A cascade
  *   whose corners weigh nothing gives way to the next coarser, without a skirt. With none left the
  *   weights are zero, and the fallback is the caller's (§9.1, step 6).
- * - **The SH**: the picked records' Metro L1 structs mixed by their weights; resolved with
- *   `resolve_irradiance_sh_to_diffuse` at the caller's normal, it gives E/π. `found` says whether any probe
- *   weighed anything.
+ * - **The SH**: the picked records' RGB radiance SH3 mixed by their weights; `sh3_color_get_irradiance_at`
+ *   at the caller's normal gives E. `found` says whether any probe weighed anything.
  *
  * Per cascade read: 8 indirection loads, 8 state words and 8 depth taps, then 2 indirection loads for
  * the pair; then two records a cascade read for the SH. A depth tile's place takes no integer division
@@ -142,7 +145,7 @@ struct ProbeClipmapPair {
 }
 
 struct ProbeClipmapSH {
-    sh: ${METRO_L1_IRRADIANCE_STRUCT.wgsl_ref},
+    sh: array<vec3<f32>, 9>,
     found: bool,
 }
 
@@ -243,7 +246,7 @@ fn probe_clipmap_pick_in(levels: ${LEVELS}, sampling: ${SAMPLING}, indirection:
     var out: ProbeClipmapPick;
 
     let count = (*sampling).cascade_count;
-    let selection = clipmap_select_finest(levels, count, position, PROBE_BLEND_SKIRT);
+    let selection = probe_clipmap_select_in(levels, count, (*sampling).anchor, (*sampling).select_half, position);
 
     if (selection.level == CLIPMAP_LEVEL_NONE) {
         return out;
@@ -292,39 +295,31 @@ fn probe_clipmap_sh_in(records: ${RECORDS}, pick: ProbeClipmapPick) -> ProbeClip
 
     // each by name, the slots of a weight of zero not read
     if (pick.weights.x > 0.0) {
-        let sh = probe_record_sh_decode((*records)[pick.slots.x].sh);
-        out.sh.CoCg += pick.weights.x * sh.CoCg;
-        out.sh.Y += pick.weights.x * sh.Y;
+        out.sh = sh3_color_add_scaled(out.sh, probe_record_sh_decode((*records)[pick.slots.x].sh), pick.weights.x);
     }
     if (pick.weights.y > 0.0) {
-        let sh = probe_record_sh_decode((*records)[pick.slots.y].sh);
-        out.sh.CoCg += pick.weights.y * sh.CoCg;
-        out.sh.Y += pick.weights.y * sh.Y;
+        out.sh = sh3_color_add_scaled(out.sh, probe_record_sh_decode((*records)[pick.slots.y].sh), pick.weights.y);
     }
     if (pick.weights.z > 0.0) {
-        let sh = probe_record_sh_decode((*records)[pick.slots.z].sh);
-        out.sh.CoCg += pick.weights.z * sh.CoCg;
-        out.sh.Y += pick.weights.z * sh.Y;
+        out.sh = sh3_color_add_scaled(out.sh, probe_record_sh_decode((*records)[pick.slots.z].sh), pick.weights.z);
     }
     if (pick.weights.w > 0.0) {
-        let sh = probe_record_sh_decode((*records)[pick.slots.w].sh);
-        out.sh.CoCg += pick.weights.w * sh.CoCg;
-        out.sh.Y += pick.weights.w * sh.Y;
+        out.sh = sh3_color_add_scaled(out.sh, probe_record_sh_decode((*records)[pick.slots.w].sh), pick.weights.w);
     }
 
     return out;
 }
 `, [
     chunk_probe_clipmap,
-    chunk_clipmap_select_finest,
+    chunk_probe_clipmap_select_in,
     chunk_probe_clipmap_cage_in,
     chunk_index_to_grid2d_reciprocal,
     chunk_uv_octahedral_unit_encode,
     chunk_texture_octahedral_skirt_uv,
     chunk_probe_visibility_weight,
     chunk_pick2_wrs_mat2x4,
+    chunk_sh3_color_add_scaled,
     PROBE_SAMPLING_STRUCT.declaration_chunk,
-    METRO_L1_IRRADIANCE_STRUCT.declaration_chunk,
 ]);
 
 chunk_probe_clipmap_pick_in.requireResource(PROBE_DEPTH_SAMPLER_RESOURCE);

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

@@ -18,8 +18,8 @@
  *   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.
  * - **The rough end** is the probes' SH, mixed by the same shares and resolved for the GGX lobe
- *   (`resolve_irradiance_sh_to_specular`). The two are blended by `roughness_to_mip_ratio`: SH alone from
- *   roughness 0.7.
+ *   (`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.
  * - Where no probe weighs anything, nothing is found and the fallback is the caller's.
  *
  * @type {CodeChunk}

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":"AA8BA;;;;;;;;;;;;;;;;;;;;;;;;;GAyBG;AACH,kDAFU,SAAS,CAsIZ;0BA7KmB,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;;;;;;;;;;;;;;;;;;;;;;;;;GAyBG;AACH,kDAFU,SAAS,CAmIZ;0BA1KmB,uCAAuC"}

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

@@ -4,12 +4,10 @@ import {
 } from "../../../shader/chunk/geometry/octahedron/chunk_uv_octahedral_unit_encode.js";
 import { chunk_index_to_grid2d_reciprocal } from "../../../shader/chunk/grid/chunk_index_to_grid2d_reciprocal.js";
 import { chunk_probe_visibility_weight } from "../../../shader/chunk/light/probe/chunk_probe_visibility_weight.js";
+import { chunk_sh3_color_add_scaled } from "../../../shader/chunk/spherical_harmonics/chunk_sh3_color_add_scaled.js";
 import {
-    METRO_L1_IRRADIANCE_STRUCT
-} from "../../../shader/chunk/spherical_harmonics/l1i/chunk_convert_to_irradiance_sh.js";
-import {
-    chunk_resolve_irradiance_sh_to_specular
-} from "../../../shader/chunk/spherical_harmonics/l1i/chunk_resolve_irradiance_sh_to_specular.js";
+    chunk_sh3_color_get_radiance_with_GGX
+} from "../../../shader/chunk/spherical_harmonics/chunk_sh3_color_get_radiance_with_GGX.js";
 import {
     chunk_texture_octahedral_skirt_uv
 } from "../../../shader/chunk/texture/octahedral/chunk_texture_octahedral_skirt_uv.js";
@@ -48,8 +46,8 @@ import { PROBE_RECEIVER_BIAS_VIEW } from "./PROBE_CLIPMAP.js";
  *   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.
  * - **The rough end** is the probes' SH, mixed by the same shares and resolved for the GGX lobe
- *   (`resolve_irradiance_sh_to_specular`). The two are blended by `roughness_to_mip_ratio`: SH alone from
- *   roughness 0.7.
+ *   (`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.
  * - Where no probe weighs anything, nothing is found and the fallback is the caller's.
  *
  * @type {CodeChunk}
@@ -66,7 +64,7 @@ struct ProbeClipmapLobe {
     // the probe's share for the lobe, before the shares are renormalised
     weight: f32,
     radiance: vec3<f32>,
-    sh: ${METRO_L1_IRRADIANCE_STRUCT.wgsl_ref},
+    sh: array<vec3<f32>, 9>,
 }
 
 // a slot's radiance toward a direction, and its texels' count of samples in alpha: one bilinear tap of its
@@ -135,39 +133,35 @@ fn probe_clipmap_radiance_of(pick: ProbeClipmapPick, position: vec3<f32>, normal
 
     var weight = 0.0;
     var radiance = vec3<f32>(0.0);
-    var sh: ${METRO_L1_IRRADIANCE_STRUCT.wgsl_ref};
+    var sh: array<vec3<f32>, 9>;
 
     // each by name, the slots of a share of zero not read
     if (pick.weights.x > 0.0) {
         let probe = probe_clipmap_lobe(pick.slots.x, pick.weights.x, position, normal, bias_direction, lobe);
         weight += probe.weight;
         radiance += probe.weight * probe.radiance;
-        sh.Y += probe.weight * probe.sh.Y;
-        sh.CoCg += probe.weight * probe.sh.CoCg;
+        sh = sh3_color_add_scaled(sh, probe.sh, probe.weight);
     }
     if (pick.weights.y > 0.0) {
         let probe = probe_clipmap_lobe(pick.slots.y, pick.weights.y, position, normal, bias_direction, lobe);
         weight += probe.weight;
         radiance += probe.weight * probe.radiance;
-        sh.Y += probe.weight * probe.sh.Y;
-        sh.CoCg += probe.weight * probe.sh.CoCg;
+        sh = sh3_color_add_scaled(sh, probe.sh, probe.weight);
     }
     if (pick.weights.z > 0.0) {
         let probe = probe_clipmap_lobe(pick.slots.z, pick.weights.z, position, normal, bias_direction, lobe);
         weight += probe.weight;
         radiance += probe.weight * probe.radiance;
-        sh.Y += probe.weight * probe.sh.Y;
-        sh.CoCg += probe.weight * probe.sh.CoCg;
+        sh = sh3_color_add_scaled(sh, probe.sh, probe.weight);
     }
     if (pick.weights.w > 0.0) {
         let probe = probe_clipmap_lobe(pick.slots.w, pick.weights.w, position, normal, bias_direction, lobe);
         weight += probe.weight;
         radiance += probe.weight * probe.radiance;
-        sh.Y += probe.weight * probe.sh.Y;
-        sh.CoCg += probe.weight * probe.sh.CoCg;
+        sh = sh3_color_add_scaled(sh, probe.sh, probe.weight);
     }
 
-    let rough = resolve_irradiance_sh_to_specular(sh.Y / weight, sh.CoCg / weight, lobe, alpha);
+    let rough = sh3_color_get_radiance_with_GGX(sh, lobe, alpha) / weight;
 
     out.radiance = mix(radiance / weight, rough, roughness_to_mip_ratio(roughness));
 
@@ -184,7 +178,8 @@ fn probe_clipmap_sample_radiance(position: vec3<f32>, normal: vec3<f32>, view_di
         chunk_index_to_grid2d_reciprocal,
         chunk_texture_octahedral_skirt_uv,
         chunk_uv_octahedral_unit_encode,
-        chunk_resolve_irradiance_sh_to_specular,
+        chunk_sh3_color_add_scaled,
+        chunk_sh3_color_get_radiance_with_GGX,
         chunk_roughness_to_mip_ratio,
     ]);
 

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

@@ -0,0 +1,22 @@
+/**
+ * The cascade a point reads, and how far into its blend skirt it is (PROBE_CLIPMAP_PROPOSAL_2026_10_27.md §9.1,
+ * "Selection"), in the clipmap whose levels `levels` points at. Want takes it to choose the cascades a pixel
+ * wants, and the pick to read them.
+ *
+ * ```wgsl
+ * fn probe_clipmap_select_in(levels: ptr<uniform, ClipmapLevelArray>, count: u32, anchor: vec3<f32>, select_half: f32, position: vec3<f32>) -> ClipmapSelection
+ * ```
+ *
+ * Each cascade's selection box is centred on the `anchor` the windows were placed around, `select_half` of the
+ * cascade's cells to a side. The finest of the first `count` cascades whose box holds the point answers, its
+ * `edge_weight` rising from 0 at {@link PROBE_BLEND_SKIRT} cells inside the box's nearest face to 1 on it: the
+ * share the next coarser cascade takes. A point no box holds answers `CLIPMAP_LEVEL_NONE`, with a weight of 0.
+ *
+ * The boxes follow the anchor, not the windows' corners, which move a whole step at a time: a point's weight
+ * moves as far as the anchor did over the skirt's depth, never a step's worth in one frame.
+ *
+ * @type {CodeChunk}
+ */
+export const chunk_probe_clipmap_select_in: CodeChunk;
+import { CodeChunk } from "../../../shader/compiler/CodeChunk.js";
+//# sourceMappingURL=chunk_probe_clipmap_select.d.ts.map

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

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

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

@@ -0,0 +1,50 @@
+import { chunk_clipmap_select_finest } from "../../../shader/chunk/clipmap/chunk_clipmap_select_finest.js";
+import { CLIPMAP_LEVEL_ARRAY, CLIPMAP_LEVEL_LIMIT } from "../../../shader/chunk/clipmap/CLIPMAP_LEVEL_STRUCT.js";
+import { CodeChunk } from "../../../shader/compiler/CodeChunk.js";
+import { PROBE_BLEND_SKIRT } from "./PROBE_CLIPMAP.js";
+
+/**
+ * The cascade a point reads, and how far into its blend skirt it is (PROBE_CLIPMAP_PROPOSAL_2026_10_27.md §9.1,
+ * "Selection"), in the clipmap whose levels `levels` points at. Want takes it to choose the cascades a pixel
+ * wants, and the pick to read them.
+ *
+ * ```wgsl
+ * fn probe_clipmap_select_in(levels: ptr<uniform, ClipmapLevelArray>, count: u32, anchor: vec3<f32>, select_half: f32, position: vec3<f32>) -> ClipmapSelection
+ * ```
+ *
+ * Each cascade's selection box is centred on the `anchor` the windows were placed around, `select_half` of the
+ * cascade's cells to a side. The finest of the first `count` cascades whose box holds the point answers, its
+ * `edge_weight` rising from 0 at {@link PROBE_BLEND_SKIRT} cells inside the box's nearest face to 1 on it: the
+ * share the next coarser cascade takes. A point no box holds answers `CLIPMAP_LEVEL_NONE`, with a weight of 0.
+ *
+ * The boxes follow the anchor, not the windows' corners, which move a whole step at a time: a point's weight
+ * moves as far as the anchor did over the skirt's depth, never a step's worth in one frame.
+ *
+ * @type {CodeChunk}
+ */
+export const chunk_probe_clipmap_select_in = CodeChunk.from(
+    //language=WGSL
+    `
+fn probe_clipmap_select_in(levels: ptr<uniform, ${CLIPMAP_LEVEL_ARRAY.wgsl_ref}>, count: u32, anchor: vec3<f32>, select_half: f32, position: vec3<f32>) -> ClipmapSelection {
+    let offset = abs(position - anchor);
+    let reach = max(max(offset.x, offset.y), offset.z);
+
+    for (var i = 0u; i < ${CLIPMAP_LEVEL_LIMIT}u; i++) {
+        if (i >= count) {
+            break;
+        }
+
+        // the point's depth inside the box, in the cascade's cells
+        let edge = select_half - reach / (*levels)[i].cell_size;
+
+        if (edge >= 0.0) {
+            return ClipmapSelection(i, saturate(1.0 - edge / ${PROBE_BLEND_SKIRT}.0));
+        }
+    }
+
+    return ClipmapSelection(CLIPMAP_LEVEL_NONE, 0.0);
+}
+`, [
+    // ClipmapSelection and CLIPMAP_LEVEL_NONE
+    chunk_clipmap_select_finest,
+]);

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

@@ -3,12 +3,12 @@
  * for want's pixels and the hits' wants alike.
  *
  * ```wgsl
- * fn probe_clipmap_want(wants: bool, position: vec3<f32>, bias_direction: vec3<f32>, cascade_count: u32, resolution: u32, wanted_capacity: u32)
+ * 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)
  * ```
  *
- * The cages are the pick's: the finest cascade whose cage window holds the point, 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
+ * 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
  * point's bit is set, and a point whose bit was clear goes on the wanted list by its key, so the list
  * holds every point wanted this frame once.
  *

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;0BA7HmB,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;;;;;;;;;;;;;;;;;;;;;;GAsBG;AACH,uCAFU,SAAS,CAgFZ;0BA9HmB,uCAAuC"}

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

@@ -1,5 +1,4 @@
 import { chunk_collection_u32_append } from "../../../gpu_primitive/chunk_collection_u32_append.js";
-import { chunk_clipmap_select_finest } from "../../../shader/chunk/clipmap/chunk_clipmap_select_finest.js";
 import { CodeChunk } from "../../../shader/compiler/CodeChunk.js";
 import {
     chunk_probe_clipmap,
@@ -8,6 +7,7 @@ import {
     PROBE_WANTED_WRITE_RESOURCE
 } from "./chunk_probe_clipmap.js";
 import { chunk_probe_clipmap_cage } from "./chunk_probe_clipmap_cage.js";
+import { chunk_probe_clipmap_select_in } from "./chunk_probe_clipmap_select.js";
 import { PROBE_THREAD_WORKGROUP_SIZE } from "./PROBE_CLIPMAP.js";
 
 /**
@@ -29,12 +29,12 @@ const WANT_CLAIM_PROBES = 16;
  * for want's pixels and the hits' wants alike.
  *
  * ```wgsl
- * fn probe_clipmap_want(wants: bool, position: vec3<f32>, bias_direction: vec3<f32>, cascade_count: u32, resolution: u32, wanted_capacity: u32)
+ * 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)
  * ```
  *
- * The cages are the pick's: the finest cascade whose cage window holds the point, 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
+ * 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
  * point's bit is set, and a point whose bit was clear goes on the wanted list by its key, so the list
  * holds every point wanted this frame once.
  *
@@ -80,8 +80,8 @@ 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, wanted_capacity: u32) {
-    let selection = clipmap_select_finest(&probe_levels, cascade_count, position, PROBE_BLEND_SKIRT);
+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);
@@ -122,7 +122,7 @@ fn probe_clipmap_want(wants: bool, position: vec3<f32>, bias_direction: vec3<f32
 }
 `, [
         chunk_probe_clipmap,
-        chunk_clipmap_select_finest,
+        chunk_probe_clipmap_select_in,
         chunk_probe_clipmap_cage,
         chunk_collection_u32_append,
     ]);

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

@@ -19,7 +19,7 @@ export const PROBE_ACCUMULATE_SETTINGS: WebGPUStruct;
  *   so their mean needs no weight for the guide's choice.
  * - **Radiance**: the mean of the texel's resolved rays, a back face's being zero, is a sample of the
  *   texel's multi-scale mean (`chunk_multiscale_mean`), its estimator in `probe_estimators` and its mean
- *   in the atlas.
+ *   in the atlas, at the exposure in `probe_exposure`: the display's, which the estimator's thresholds are in.
  *   - The short mean blends by β = max(1/(a+1), `PROBE_SHORT_BLEND`), its variance by max(1/(a+1),
  *     `PROBE_VARIANCE_BLEND`), a the texel's own count of the updates that reached it, held in its alpha.
  *     A sample's blend is a sample's however long since the last one: a probe nobody wanted, or a texel the