@woosh/meep-engine 3.61.1 → 3.61.2

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

@@ -1,6 +1,6 @@
 /**
- * A probe's record (PROBE_CLIPMAP_PROPOSAL_2026_10_27.md §8.2), 48 bytes a slot: where it is, when it
- * was wanted and traced, its last update's back faces, and its irradiance. Where
+ * A probe's record (PROBE_CLIPMAP_PROPOSAL_2026_10_27.md §8.2), 64 bytes a slot: where it is, when it
+ * was wanted and traced, its last update's back faces, and the radiance its rays saw. Where
  * relocation moved it is the state's second word, which readers weighing it load with the state.
  *
  * @type {WebGPUStruct}
@@ -274,7 +274,7 @@ export const PROBE_CANDIDATES_WRITE_RESOURCE: ShaderResourceDescriptor;
  */
 export const PROBE_CANDIDATES_READ_RESOURCE: ShaderResourceDescriptor;
 /**
- * A row of a listed probe's radiance map, projected: its irradiance SH, and its rays this update.
+ * A row of a listed probe's radiance map, projected: its radiance SH3, and its rays this update.
  * @type {WebGPUStruct}
  */
 export const PROBE_PROJECTION_ROW_STRUCT: WebGPUStruct;
@@ -326,8 +326,9 @@ export const PROBE_DEPTH_STORE_RESOURCE: ShaderResourceDescriptor;
  * fn probe_clipmap_age_bucket(age: u32) -> u32 // the bucket of frames unwanted that eviction orders by
  * fn probe_record_flags(back_face: f32, cascade: u32) -> u32
  * fn probe_record_cascade(flags: u32) -> u32
- * fn probe_record_sh_encode(sh: MetroL1) -> vec3<u32> // held to the half float's largest, ±65,504
- * fn probe_record_sh_decode(sh: vec3<u32>) -> MetroL1
+ * fn probe_record_sh_encode(sh: array<vec3<f32>, 9>) -> array<u32, 7> // sh: radiance SH3
+ * fn probe_record_sh_decode(words: array<u32, 7>) -> array<vec3<f32>, 9> // radiance SH3
+ * fn probe_record_mean_radiance(words: array<u32, 7>) -> vec3<f32> // over the sphere
  * fn probe_clipmap_offset_encode(offset: vec3<f32>, spacing: f32) -> u32 // the state's second word
  * fn probe_clipmap_offset_decode(word: u32, spacing: f32) -> vec3<f32>
  * fn probe_clipmap_maps_words(radiance_resolution: u32, depth_resolution: u32) -> u32 // a listed probe's, in probe_maps
@@ -374,17 +375,23 @@ export const chunk_probe_clipmap_ray_layout: CodeChunk;
  */
 export const chunk_probe_clipmap_ray_texel: CodeChunk;
 /**
- * The STBN jitter of a ray in its texel (§8.6): the noise moved by the slot's hash so that neighbouring
- * probes do not jitter alike, and a fresh sample for each update and each round of a texel's rays. The
- * trace aims its ray by it, and the light pass picks the probes at its hit with it (§8.7).
+ * A ray's noise (§8.6, §8.7): a hash of the probe's slot, its update count, the ray's place among the
+ * update's rays and a stream, the same in every pass that knows the ray. It never repeats over a probe's
+ * updates. Uniform and guided updates alike, the trace jitters its ray inside its texel by stream
+ * `PROBE_RAY_NOISE_JITTER`, and the bounce picks the probes at its hit by `PROBE_RAY_NOISE_PICK`, which is
+ * independent of the jitter that placed the hit.
+ *
+ * This is white noise. Nothing stratifies it across texels, across updates, or across a texel's rays,
+ * which may clump. Each component lies inside (0, 1), at the centre of one of 2^23 bins, so a weighted
+ * draw by it never meets either end.
  *
  * ```wgsl
- * fn probe_clipmap_ray_jitter(slot: u32, texel: u32, ray: u32, updates: u32, rays: u32, n: u32) -> vec2<f32> // ray: its index among the probe's R; n: n_r
+ * fn probe_clipmap_ray_noise(slot: u32, updates: u32, ray: u32, stream: u32) -> vec2<f32> // ray: its index among the update's rays
  * ```
  *
  * @type {CodeChunk}
  */
-export const chunk_probe_clipmap_ray_jitter: CodeChunk;
+export const chunk_probe_clipmap_ray_noise: CodeChunk;
 /**
  * Where a ray of an update starts (§8.6): a point of the ball of `PROBE_RAY_ORIGIN_JITTER` of the spacing
  * around the probe, uniform in its volume, as Brick4's bake jitters its probes. The point is drawn from the
@@ -469,18 +476,6 @@ export const chunk_probe_clipmap_guide_expected: CodeChunk;
  * @type {CodeChunk}
  */
 export const chunk_probe_clipmap_listed: CodeChunk;
-/**
- * The jitter of a guided update's ray in its texel. The first ray takes the texel's STBN jitter
- * (`probe_clipmap_ray_jitter` at round 0). The rest rotate it by the R2 sequence, so a texel's rays
- * spread over it the way a lattice does.
- *
- * ```wgsl
- * fn probe_clipmap_guided_ray_jitter(slot: u32, texel: u32, round: u32, updates: u32, rays: u32, n: u32) -> vec2<f32> // round: the ray's place among its texel's
- * ```
- *
- * @type {CodeChunk}
- */
-export const chunk_probe_clipmap_guided_ray_jitter: CodeChunk;
 import { WebGPUStruct } from "../../../shader/type/WebGPUStruct.js";
 import { ShaderResourceDescriptor } from "../../../shader/resource/ShaderResourceDescriptor.js";
 import { CodeChunk } from "../../../shader/compiler/CodeChunk.js";

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

@@ -6,14 +6,12 @@ import { chunk_rgb_to_luminance } from "../../../shader/chunk/color/chunk_rgb_to
 import { chunk_sphere_sample_volume } from "../../../shader/chunk/geometry/sphere/chunk_sphere_sample_volume.js";
 import { chunk_mod_v3i } from "../../../shader/chunk/geometry/vec3/chunk_mod_v3i.js";
 import { chunk_lower_bound_branchless } from "../../../shader/chunk/math/chunk_lower_bound_branchless.js";
-import { chunk_stbn_sample_vec2 } from "../../../shader/chunk/noise/chunk_stbn_sample_vec2.js";
-import { chunk_r2_canonical } from "../../../shader/chunk/noise/r/chunk_r2_canonical.js";
-import { chunk_hash_lowbias32 } from "../../../shader/chunk/random/chunk_hash_lowbias32.js";
 import { chunk_hash_to_float01 } from "../../../shader/chunk/random/chunk_hash_to_float01.js";
 import { chunk_pcg3d } from "../../../shader/chunk/random/pcg/chunk_pcg3d.js";
+import { chunk_pcg4d } from "../../../shader/chunk/random/pcg/chunk_pcg4d.js";
 import {
-    METRO_L1_IRRADIANCE_STRUCT
-} from "../../../shader/chunk/spherical_harmonics/l1i/chunk_convert_to_irradiance_sh.js";
+    chunk_sh3_color_multiply_scalar
+} from "../../../shader/chunk/spherical_harmonics/chunk_sh3_color_multiply_scalar.js";
 import { CodeChunk } from "../../../shader/compiler/CodeChunk.js";
 import { ShaderResourceDescriptor } from "../../../shader/resource/ShaderResourceDescriptor.js";
 import {
@@ -22,13 +20,15 @@ import {
     u32,
     vec2u,
     vec3i,
-    vec3u,
+    vec3f,
     vec4f,
     vec4u
 } from "../../../shader/type/WEBGPU_WGSL_PRIMITIVE_TYPES.js";
 import { WebGPUArray } from "../../../shader/type/WebGPUArray.js";
 import { WebGPUStruct } from "../../../shader/type/WebGPUStruct.js";
-import { STBN_VEC2_RESOURCE } from "../../../STATIC_GRAPHICS_ENGINE_ASSET_RESOURCES.js";
+import { BRICK4_PROBE_ENCODED_SIZE } from "../../brick4/BRICK4_PROBE_ENCODED_SIZE.js";
+import { chunk_brick4_sh3_color_unpack } from "../../brick4/gpu/encoding/v2/chunk_brick4_sh3_color_decode.js";
+import { chunk_brick4_sh3_color_pack } from "../../brick4/gpu/encoding/v2/chunk_brick4_sh3_color_encode.js";
 import {
     PROBE_AGE_BUCKETS,
     PROBE_BLEND_SKIRT,
@@ -54,6 +54,8 @@ import {
     PROBE_RAY_CASCADE_SHIFT,
     PROBE_RAY_KIND_MASK,
     PROBE_RAY_NONE,
+    PROBE_RAY_NOISE_JITTER,
+    PROBE_RAY_NOISE_PICK,
     PROBE_RAY_ORIGIN_JITTER,
     PROBE_RAY_PROBE_SHIFT,
     PROBE_RECORD_CASCADE_SHIFT,
@@ -69,8 +71,8 @@ import {
 } from "./PROBE_CLIPMAP.js";
 
 /**
- * A probe's record (PROBE_CLIPMAP_PROPOSAL_2026_10_27.md §8.2), 48 bytes a slot: where it is, when it
- * was wanted and traced, its last update's back faces, and its irradiance. Where
+ * A probe's record (PROBE_CLIPMAP_PROPOSAL_2026_10_27.md §8.2), 64 bytes a slot: where it is, when it
+ * was wanted and traced, its last update's back faces, and the radiance its rays saw. Where
  * relocation moved it is the state's second word, which readers weighing it load with the state.
  *
  * @type {WebGPUStruct}
@@ -88,10 +90,13 @@ export const PROBE_RECORD_STRUCT = WebGPUStruct.from({
     /** the frame it was last updated */
     traced_frame: u32,
     /**
-     * The irradiance its rays saw, the Metro L1 encoding (luma as SH2, chroma constant) in half floats:
-     * Y's xy, Y's zw, CoCg. `probe_record_sh_decode`.
+     * The radiance its rays saw as RGB SH3, a quarter of every coefficient in Brick4's encoding
+     * (`brick4_sh3_color_pack`): band 0 RGB9E5, bands 1 and 2 eight bits a coefficient over it. A power of two
+     * scales RGB9E5's exponent alone, so `probe_record_sh_decode` gives the radiance SH3 to the bit as Brick4's
+     * codec decodes it wherever each lit channel's mean radiance is past 2·10⁻⁵, while band 0 holds a mean radiance
+     * to 73,804, past the rays' own largest light, 65,408.
      */
-    sh: vec3u,
+    sh: WebGPUArray.from(u32, BRICK4_PROBE_ENCODED_SIZE),
 }, "ProbeRecord").pack();
 
 /**
@@ -448,11 +453,11 @@ export const PROBE_CANDIDATES_WRITE_RESOURCE = ShaderResourceDescriptor.storageB
 export const PROBE_CANDIDATES_READ_RESOURCE = ShaderResourceDescriptor.storageBuffer("probe_candidates", WebGPUArray.from(PROBE_CANDIDATE_STRUCT));
 
 /**
- * A row of a listed probe's radiance map, projected: its irradiance SH, and its rays this update.
+ * A row of a listed probe's radiance map, projected: its radiance SH3, and its rays this update.
  * @type {WebGPUStruct}
  */
 export const PROBE_PROJECTION_ROW_STRUCT = WebGPUStruct.from({
-    sh: METRO_L1_IRRADIANCE_STRUCT,
+    sh: WebGPUArray.from(vec3f, 9),
     /** the update's rays that resolved, a back face's among them */
     resolved: u32,
     /** of them, the back faces */
@@ -517,8 +522,9 @@ export const PROBE_DEPTH_STORE_RESOURCE = ShaderResourceDescriptor.storageTextur
  * fn probe_clipmap_age_bucket(age: u32) -> u32 // the bucket of frames unwanted that eviction orders by
  * fn probe_record_flags(back_face: f32, cascade: u32) -> u32
  * fn probe_record_cascade(flags: u32) -> u32
- * fn probe_record_sh_encode(sh: MetroL1) -> vec3<u32> // held to the half float's largest, ±65,504
- * fn probe_record_sh_decode(sh: vec3<u32>) -> MetroL1
+ * fn probe_record_sh_encode(sh: array<vec3<f32>, 9>) -> array<u32, 7> // sh: radiance SH3
+ * fn probe_record_sh_decode(words: array<u32, 7>) -> array<vec3<f32>, 9> // radiance SH3
+ * fn probe_record_mean_radiance(words: array<u32, 7>) -> vec3<f32> // over the sphere
  * fn probe_clipmap_offset_encode(offset: vec3<f32>, spacing: f32) -> u32 // the state's second word
  * fn probe_clipmap_offset_decode(word: u32, spacing: f32) -> vec3<f32>
  * fn probe_clipmap_maps_words(radiance_resolution: u32, depth_resolution: u32) -> u32 // a listed probe's, in probe_maps
@@ -618,20 +624,20 @@ fn probe_record_cascade(flags: u32) -> u32 {
     return flags >> PROBE_RECORD_CASCADE_SHIFT;
 }
 
-fn probe_record_sh_encode(sh: ${METRO_L1_IRRADIANCE_STRUCT.wgsl_ref}) -> vec3<u32> {
-    let y = clamp(sh.Y, vec4<f32>(-65504.0), vec4<f32>(65504.0));
-    let cocg = clamp(sh.CoCg, vec2<f32>(-65504.0), vec2<f32>(65504.0));
+// the power of two at or below band 0's basis constant, 1/√(4π): band 0 holds a mean radiance past RGB9E5's largest value
+const PROBE_RECORD_SH_SCALE = 0.25;
 
-    return vec3<u32>(pack2x16float(y.xy), pack2x16float(y.zw), pack2x16float(cocg));
+fn probe_record_sh_encode(sh: array<vec3<f32>, 9>) -> array<u32, ${BRICK4_PROBE_ENCODED_SIZE}> {
+    return brick4_sh3_color_pack(sh3_color_multiply_scalar(sh, PROBE_RECORD_SH_SCALE));
 }
 
-fn probe_record_sh_decode(sh: vec3<u32>) -> ${METRO_L1_IRRADIANCE_STRUCT.wgsl_ref} {
-    var out: ${METRO_L1_IRRADIANCE_STRUCT.wgsl_ref};
-
-    out.Y = vec4<f32>(unpack2x16float(sh.x), unpack2x16float(sh.y));
-    out.CoCg = unpack2x16float(sh.z);
+fn probe_record_sh_decode(words: array<u32, ${BRICK4_PROBE_ENCODED_SIZE}>) -> array<vec3<f32>, 9> {
+    return brick4_sh3_color_unpack(words, 1.0 / PROBE_RECORD_SH_SCALE);
+}
 
-    return out;
+fn probe_record_mean_radiance(words: array<u32, ${BRICK4_PROBE_ENCODED_SIZE}>) -> vec3<f32> {
+    // band 0 times its basis constant
+    return brick4_sh3_color_unpack_dc(words) * (0.28209479177387814 / PROBE_RECORD_SH_SCALE);
 }
 
 fn probe_clipmap_maps_words(radiance_resolution: u32, depth_resolution: u32) -> u32 {
@@ -653,7 +659,9 @@ fn probe_clipmap_offset_decode(word: u32, spacing: f32) -> vec3<f32> {
 }
 `, [
     PROBE_RECORD_STRUCT.declaration_chunk,
-    METRO_L1_IRRADIANCE_STRUCT.declaration_chunk,
+    chunk_brick4_sh3_color_pack,
+    chunk_brick4_sh3_color_unpack,
+    chunk_sh3_color_multiply_scalar,
     chunk_clipmap_key,
     chunk_mod_v3i,
 ]);
@@ -751,36 +759,38 @@ fn probe_clipmap_texel_ray(texel: u32, round: u32, updates: u32, rays: u32, texe
 ]);
 
 /**
- * The STBN jitter of a ray in its texel (§8.6): the noise moved by the slot's hash so that neighbouring
- * probes do not jitter alike, and a fresh sample for each update and each round of a texel's rays. The
- * trace aims its ray by it, and the light pass picks the probes at its hit with it (§8.7).
+ * A ray's noise (§8.6, §8.7): a hash of the probe's slot, its update count, the ray's place among the
+ * update's rays and a stream, the same in every pass that knows the ray. It never repeats over a probe's
+ * updates. Uniform and guided updates alike, the trace jitters its ray inside its texel by stream
+ * `PROBE_RAY_NOISE_JITTER`, and the bounce picks the probes at its hit by `PROBE_RAY_NOISE_PICK`, which is
+ * independent of the jitter that placed the hit.
+ *
+ * This is white noise. Nothing stratifies it across texels, across updates, or across a texel's rays,
+ * which may clump. Each component lies inside (0, 1), at the centre of one of 2^23 bins, so a weighted
+ * draw by it never meets either end.
  *
  * ```wgsl
- * fn probe_clipmap_ray_jitter(slot: u32, texel: u32, ray: u32, updates: u32, rays: u32, n: u32) -> vec2<f32> // ray: its index among the probe's R; n: n_r
+ * fn probe_clipmap_ray_noise(slot: u32, updates: u32, ray: u32, stream: u32) -> vec2<f32> // ray: its index among the update's rays
  * ```
  *
  * @type {CodeChunk}
  */
-export const chunk_probe_clipmap_ray_jitter = CodeChunk.from(
+export const chunk_probe_clipmap_ray_noise = CodeChunk.from(
     //language=WGSL
     `
-fn probe_clipmap_ray_jitter(slot: u32, texel: u32, ray: u32, updates: u32, rays: u32, n: u32) -> vec2<f32> {
-    let texels = n * n;
-    let round = select(0u, ray / texels, rays >= texels);
-    let per_texel = max(rays / texels, 1u);
+const PROBE_RAY_NOISE_JITTER = ${PROBE_RAY_NOISE_JITTER}u;
+const PROBE_RAY_NOISE_PICK = ${PROBE_RAY_NOISE_PICK}u;
 
-    let scramble = hash_lowbias32(slot);
-    let noise_xy = vec2<u32>(texel % n, texel / n) + vec2<u32>(scramble & 127u, (scramble >> 7u) & 127u);
+fn probe_clipmap_ray_noise(slot: u32, updates: u32, ray: u32, stream: u32) -> vec2<f32> {
+    let hash = pcg4d(vec4<u32>(slot, updates, ray, stream));
 
-    return stbn_sample_vec2(vec3<u32>(noise_xy, updates * per_texel + round));
+    // 23 bits and a half fit f32's 24 exactly: the centre of the last bin stays under 1
+    return (vec2<f32>(hash.xy >> vec2<u32>(9u)) + 0.5) * (1.0 / 8388608.0);
 }
 `, [
-    chunk_hash_lowbias32,
-    chunk_stbn_sample_vec2,
+    chunk_pcg4d,
 ]);
 
-chunk_probe_clipmap_ray_jitter.requireResource(STBN_VEC2_RESOURCE);
-
 /**
  * Where a ray of an update starts (§8.6): a point of the ball of `PROBE_RAY_ORIGIN_JITTER` of the spacing
  * around the probe, uniform in its volume, as Brick4's bake jitters its probes. The point is drawn from the
@@ -967,25 +977,3 @@ fn probe_clipmap_listed(slot: u32, capacity: u32) -> u32 {
 
 chunk_probe_clipmap_listed.requireResource(PROBE_LISTED_READ_RESOURCE);
 chunk_probe_clipmap_listed.requireResource(PROBE_TRACE_READ_RESOURCE);
-
-/**
- * The jitter of a guided update's ray in its texel. The first ray takes the texel's STBN jitter
- * (`probe_clipmap_ray_jitter` at round 0). The rest rotate it by the R2 sequence, so a texel's rays
- * spread over it the way a lattice does.
- *
- * ```wgsl
- * fn probe_clipmap_guided_ray_jitter(slot: u32, texel: u32, round: u32, updates: u32, rays: u32, n: u32) -> vec2<f32> // round: the ray's place among its texel's
- * ```
- *
- * @type {CodeChunk}
- */
-export const chunk_probe_clipmap_guided_ray_jitter = CodeChunk.from(
-    //language=WGSL
-    `
-fn probe_clipmap_guided_ray_jitter(slot: u32, texel: u32, round: u32, updates: u32, rays: u32, n: u32) -> vec2<f32> {
-    return fract(probe_clipmap_ray_jitter(slot, texel, 0u, updates, rays, n) + r2_canonical(round) - 0.5);
-}
-`, [
-    chunk_probe_clipmap_ray_jitter,
-    chunk_r2_canonical,
-]);

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

@@ -47,9 +47,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,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;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA+BG;AACH,0CAFU,SAAS,CAiMhB;AAIH;;;;;;;;;;;;;;;;GAgBG;AACH,uCAFU,SAAS,CA0BhB;AASH;;;;;;;GAOG;AACH,2CAFU,6BAA6B,CAWG;6BAlXb,sCAAsC;yCAH1B,sDAAsD;kCAd7D,qDAAqD;0BAa7D,uCAAuC;8CAEnB,2DAA2D"}

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

@@ -7,9 +7,7 @@ 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";
@@ -116,9 +114,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 +139,7 @@ struct ProbeClipmapPair {
 }
 
 struct ProbeClipmapSH {
-    sh: ${METRO_L1_IRRADIANCE_STRUCT.wgsl_ref},
+    sh: array<vec3<f32>, 9>,
     found: bool,
 }
 
@@ -292,24 +289,16 @@ 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;
@@ -323,8 +312,8 @@ fn probe_clipmap_sh_in(records: ${RECORDS}, pick: ProbeClipmapPick) -> ProbeClip
     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/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

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

@@ -1 +1 @@
-{"version":3,"file":"shader_probe_clipmap_accumulate.d.ts","sourceRoot":"","sources":["../../../../../../../src/shade/renderer/global_illumination/probe_clipmap/probe/shader_probe_clipmap_accumulate.js"],"names":[],"mappings":"AA8CA;;GAEG;AACH,wCAFU,YAAY,CAmBQ;AAoB9B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAmDG;AACH,8CAFU,aAAa,CA0TpB;6BApb0B,sCAAsC;8BAHrC,kCAAkC"}
+{"version":3,"file":"shader_probe_clipmap_accumulate.d.ts","sourceRoot":"","sources":["../../../../../../../src/shade/renderer/global_illumination/probe_clipmap/probe/shader_probe_clipmap_accumulate.js"],"names":[],"mappings":"AA+CA;;GAEG;AACH,wCAFU,YAAY,CAmBQ;AAsB9B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAmDG;AACH,8CAFU,aAAa,CA2TpB;6BAvb0B,sCAAsC;8BAJrC,kCAAkC"}

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

@@ -11,6 +11,7 @@ import { chunk_pcg3d } from "../../../shader/chunk/random/pcg/chunk_pcg3d.js";
 import { CodeChunk } from "../../../shader/compiler/CodeChunk.js";
 import { ComputeShader } from "../../../shader/ComputeShader.js";
 import { ShaderResourceSetDescriptor } from "../../../shader/resource/ShaderResourceSetDescriptor.js";
+import { F32_CONTAINER_STRUCT } from "../../../shader/type/F32_CONTAINER_STRUCT.js";
 import { u32 } from "../../../shader/type/WEBGPU_WGSL_PRIMITIVE_TYPES.js";
 import { WebGPUStruct } from "../../../shader/type/WebGPUStruct.js";
 import { BRICK_TRACE_MISS, BRICK_TRACE_UNRESOLVED } from "../brick/BRICK_CLIPMAP.js";
@@ -82,7 +83,9 @@ resources.createGroup()
     .add(PROBE_DEPTH_HISTORY_RESOURCE)
     .add(PROBE_ESTIMATORS_RESOURCE)
     // read only where the frame re-samples (chunk_probe_clipmap_resampled)
-    .add(PROBE_RESAMPLES_READ_RESOURCE);
+    .add(PROBE_RESAMPLES_READ_RESOURCE)
+    // the factor the display multiplies radiance by ahead of its tone curve, as the last frame was shown
+    .addUniform("probe_exposure", F32_CONTAINER_STRUCT);
 
 /**
  * Accumulate (PROBE_CLIPMAP_PROPOSAL_2026_10_27.md §8.8): a thread a texel of each listed probe's maps,
@@ -101,7 +104,7 @@ resources.createGroup()
  *   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
@@ -282,8 +285,8 @@ fn main(
             if (history.a > 0.0) {
                 let ramp = 1.0 / (history.a + 1.0);
                 let before = probe_accumulate_estimator(history.rgb, probe_estimators[estimator]);
-                // the estimator's own floor on the variance
-                let deviation = rgb_to_luminance(sqrt(max(vec3<f32>(1e-5), before.variance)));
+                // the estimator's own floor on the deviation, at the display's exposure
+                let deviation = rgb_to_luminance(max(multiscale_mean_deviation_floor(before.short_mean, probe_exposure.value), sqrt(max(vec3<f32>(0.0), before.variance))));
 
                 change = vec2<f32>(clamp(rgb_to_luminance(sample - history.rgb) / deviation, -${PROBE_CHANGE_SIGNIFICANCE}.0, ${PROBE_CHANGE_SIGNIFICANCE}.0), 1.0);
 
@@ -294,6 +297,7 @@ fn main(
                     max(ramp, ${PROBE_VARIANCE_BLEND}),
                     select(0.0, ramp, history.a < ${PROBE_RADIANCE_SAMPLES_LIMIT}.0),
                     ramp <= ${PROBE_VARIANCE_BLEND},
+                    probe_exposure.value,
                 );
             }
 

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

@@ -156,7 +156,7 @@ fn main(
                 probe_records[slot].flags = probe_record_flags(0.0, cascade);
                 probe_records[slot].wanted_frame = settings.frame;
                 probe_records[slot].traced_frame = settings.frame;
-                probe_records[slot].sh = vec3<u32>(0u);
+                probe_records[slot].sh = probe_record_sh_encode(array<vec3<f32>, 9>());
 
                 // at its lattice point until its first update relocates it
                 probe_states[slot] = vec2<u32>(probe_state(PROBE_STATE_NEW, 0u), 0u);

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

@@ -4,7 +4,8 @@
  * `PROBE_DISPATCH_RAYS`. It adds ρ_d·E_ind/π to the ray's light, ρ_d the albedo shade left in its `row`.
  *
  * - **The first clipmap**: the frustum's probes, picked at the hit along its normal, the view back along
- *   the ray, with the ray's own jitter as the noise (`probe_clipmap_pick_in`).
+ *   the ray, with the ray's own pick noise (`probe_clipmap_ray_noise`, `PROBE_RAY_NOISE_PICK`), drawn
+ *   apart from the jitter that placed the hit (`probe_clipmap_pick_in`).
  * - **Where it has probes**, their SH is the bounce, and the ray's `row` is cleared: a hit the first clipmap
  *   serves wants nothing of the fallback (`shader_probe_clipmap_want_hits`).
  * - **Where it has none**, the fallback's, the world cache's: the same pick there, at its own spacing.

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

@@ -1 +1 @@
-{"version":3,"file":"shader_probe_clipmap_bounce.d.ts","sourceRoot":"","sources":["../../../../../../../src/shade/renderer/global_illumination/probe_clipmap/probe/shader_probe_clipmap_bounce.js"],"names":[],"mappings":"AAuEA;;;;;;;;;;;;;;;;;;;;;;GAsBG;AACH,0CAFU,aAAa,CAgFpB;8BAjK2B,kCAAkC"}
+{"version":3,"file":"shader_probe_clipmap_bounce.d.ts","sourceRoot":"","sources":["../../../../../../../src/shade/renderer/global_illumination/probe_clipmap/probe/shader_probe_clipmap_bounce.js"],"names":[],"mappings":"AAqEA;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AACH,0CAFU,aAAa,CA4EpB;8BA3J2B,kCAAkC"}