@woosh/meep-engine 3.61.1 → 3.61.3

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

@@ -1,11 +1,12 @@
 /**
  * The next bounce a front-face hit takes, E_ind (PROBE_CLIPMAP_PROPOSAL_2026_10_27.md §8.7;
  * WORLD_PROBE_CACHE_SCOPE_2026_11_01.md §1.4): a thread a ray, after the light pass through the same launch,
- * `PROBE_DISPATCH_RAYS`. It adds ρ_d·E_ind/π to the ray's light, ρ_d the albedo shade left in its `row`.
+ * `PROBE_DISPATCH_RAYS`. It adds ρ_d·E_ind/π to the ray's light, ρ_d the albedo shade left in its `albedo`.
  *
  * - **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`).
- * - **Where it has probes**, their SH is the bounce, and the ray's `row` is cleared: a hit the first clipmap
+ *   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 `albedo` 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.
  * - **Where neither has**, the bounce is **zero**, not the environment: a hit behind the camera in a cave
@@ -16,7 +17,7 @@
  * none. The records hold the SH their projection last wrote, at most a frame old, so each frame takes one more
  * bounce. LPV's 0.97 a bounce is dropped: an albedo under one bounds the series already.
  *
- * Every probe ray takes it, of either clipmap; only the frustum's rays' rows are read after, by the world
+ * Every probe ray takes it, of either clipmap; only the frustum's rays' albedos are read after, by the world
  * cache's wants.
  *
  * @type {ComputeShader}

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

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

@@ -5,23 +5,22 @@ import {
     chunk_uv_octahedral_unit_decode
 } from "../../../shader/chunk/geometry/octahedron/chunk_uv_octahedral_unit_decode.js";
 import { chunk_folded_workgroup_index } from "../../../shader/chunk/grid/chunk_folded_workgroup_index.js";
+import { RECIPROCAL_PI_DECLARATION } from "../../../shader/chunk/math/RECIPROCAL_PI_DECLARATION.js";
 import {
-    chunk_resolve_irradiance_sh_to_diffuse
-} from "../../../shader/chunk/spherical_harmonics/l1i/chunk_resolve_irradiance_sh_to_diffuse.js";
+    chunk_sh3_color_get_irradiance_at
+} from "../../../shader/chunk/spherical_harmonics/chunk_sh3_color_get_irradiance_at.js";
 import { CodeChunk } from "../../../shader/compiler/CodeChunk.js";
 import { ComputeShader } from "../../../shader/ComputeShader.js";
 import { ShaderResourceDescriptor } from "../../../shader/resource/ShaderResourceDescriptor.js";
 import { ShaderResourceSetDescriptor } from "../../../shader/resource/ShaderResourceSetDescriptor.js";
 import { vec2u } from "../../../shader/type/WEBGPU_WGSL_PRIMITIVE_TYPES.js";
 import { WebGPUArray } from "../../../shader/type/WebGPUArray.js";
-import { STBN_VEC2_RESOURCE } from "../../../STATIC_GRAPHICS_ENGINE_ASSET_RESOURCES.js";
 import { BRICK_TRACE_HIT } from "../brick/BRICK_CLIPMAP.js";
 import {
     chunk_probe_clipmap,
-    chunk_probe_clipmap_ray_jitter,
     chunk_probe_clipmap_ray_layout,
+    chunk_probe_clipmap_ray_noise,
     chunk_probe_clipmap_ray_origin,
-    chunk_probe_clipmap_ray_texel,
     PROBE_ORIGINS_READ_RESOURCE,
     PROBE_RAY_SUMS_READ_RESOURCE,
     PROBE_RAYS_WRITE_RESOURCE,
@@ -48,7 +47,6 @@ resources.createGroup()
     .add(PROBE_RAYS_WRITE_RESOURCE)
     .add(PROBE_RAY_SUMS_READ_RESOURCE)
     .add(PROBE_STATES_READ_RESOURCE)
-    .add(STBN_VEC2_RESOURCE)
     .add(PROBE_DEPTH_SAMPLER_RESOURCE);
 
 // the clipmap a hit takes its bounce from first: the frustum's probes
@@ -72,11 +70,12 @@ resources.createGroup()
 /**
  * The next bounce a front-face hit takes, E_ind (PROBE_CLIPMAP_PROPOSAL_2026_10_27.md §8.7;
  * WORLD_PROBE_CACHE_SCOPE_2026_11_01.md §1.4): a thread a ray, after the light pass through the same launch,
- * `PROBE_DISPATCH_RAYS`. It adds ρ_d·E_ind/π to the ray's light, ρ_d the albedo shade left in its `row`.
+ * `PROBE_DISPATCH_RAYS`. It adds ρ_d·E_ind/π to the ray's light, ρ_d the albedo shade left in its `albedo`.
  *
  * - **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`).
- * - **Where it has probes**, their SH is the bounce, and the ray's `row` is cleared: a hit the first clipmap
+ *   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 `albedo` 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.
  * - **Where neither has**, the bounce is **zero**, not the environment: a hit behind the camera in a cave
@@ -87,7 +86,7 @@ resources.createGroup()
  * none. The records hold the SH their projection last wrote, at most a frame old, so each frame takes one more
  * bounce. LPV's 0.97 a bounce is dropped: an albedo under one bounds the series already.
  *
- * Every probe ray takes it, of either clipmap; only the frustum's rays' rows are read after, by the world
+ * Every probe ray takes it, of either clipmap; only the frustum's rays' albedos are read after, by the world
  * cache's wants.
  *
  * @type {ComputeShader}
@@ -105,7 +104,7 @@ fn main(
 ) {
     let ray = folded_workgroup_index(workgroup_id) * PROBE_THREAD_WORKGROUP_SIZE + lane;
     let record = probe_rays[ray];
-    let albedo = unpack4x8unorm(record.row).rgb;
+    let albedo = unpack4x8unorm(record.albedo).rgb;
     let front_hit = (record.flags & PROBE_RAY_KIND_MASK) == ${BRICK_TRACE_HIT}u && (record.flags & PROBE_RAY_BACK_FACE) == 0u;
 
     // only a front-face hit that bounces anything takes more light
@@ -115,19 +114,15 @@ fn main(
 
     // the probe's update's rays, and this one's place among them
     let k = record.flags >> PROBE_RAY_PROBE_SHIFT;
-    let span = probe_clipmap_probe_rays(k);
-    let rays = span.y;
-    let i = ray - span.x;
+    let i = ray - probe_clipmap_probe_rays(k).x;
 
     let slot = probe_trace.elements[k];
-    let n = settings.radiance_resolution;
     let updates = probe_state_updates(probe_states[slot].x);
-    let texel = probe_clipmap_ray_texel(i, updates, rays, n * n);
 
     let direction = uv_octahedral_unit_decode(unpack2x16unorm(record.direction));
     let position = probe_clipmap_ray_origin(probe_origins[k], slot, record.direction) + record.t * direction;
     let normal = uv_octahedral_unit_decode(unpack2x16unorm(record.normal));
-    let noise = probe_clipmap_ray_jitter(slot, texel, i, updates, rays, n);
+    let noise = probe_clipmap_ray_noise(slot, updates, i, PROBE_RAY_NOISE_PICK);
 
     var probes = probe_clipmap_sh_in(
         &bounce_first_records,
@@ -136,7 +131,7 @@ fn main(
 
     if (probes.found) {
         // served: nothing of the fallback is wanted here
-        probe_rays[ray].row = 0u;
+        probe_rays[ray].albedo = 0u;
     } else {
         probes = probe_clipmap_sh_in(
             &bounce_fallback_records,
@@ -148,8 +143,8 @@ fn main(
         return;
     }
 
-    // E/π, as the resolve gives it
-    let e = resolve_irradiance_sh_to_diffuse(probes.sh.Y, probes.sh.CoCg, normal);
+    // E/π
+    let e = sh3_color_get_irradiance_at(normal, probes.sh) * RECIPROCAL_PI;
 
     if (all(e == vec3<f32>(0.0))) {
         return;
@@ -160,13 +155,13 @@ fn main(
 `, [
             chunk_probe_clipmap,
             chunk_probe_clipmap_ray_layout,
-            chunk_probe_clipmap_ray_texel,
-            chunk_probe_clipmap_ray_jitter,
+            chunk_probe_clipmap_ray_noise,
             chunk_probe_clipmap_ray_origin,
             chunk_folded_workgroup_index,
             chunk_uv_octahedral_unit_decode,
             chunk_probe_clipmap_pick_in,
-            chunk_resolve_irradiance_sh_to_diffuse,
+            chunk_sh3_color_get_irradiance_at,
+            RECIPROCAL_PI_DECLARATION,
             chunk_rgbe9995_decode,
             chunk_rgbe9995_encode,
         ]),

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

@@ -11,7 +11,7 @@ export const PROBE_CANDIDATE_SETTINGS: WebGPUStruct;
  * - **The neighbours**: the 26 around B's lattice point in its cascade. One is a candidate if it is ALIVE, its
  *   record holds that point (the storage wraps), and it is listed this frame (`probe_clipmap_listed`), so that its
  *   rays are in `probe_rays`. A NEW one is not. M counts them.
- * - **The importance**: the neighbour's radiance, its irradiance's L0 luma, times B's visibility of it: Chebyshev
+ * - **The importance**: the neighbour's radiance, the luminance of its mean radiance, times B's visibility of it: Chebyshev
  *   over B's depth moments toward it (`probe_visibility_chebyshev`), its distance in B's spacings held to the depth
  *   limit, as the moments are. A dark neighbour, or one behind a wall, weighs about nothing.
  * - **The draw**: one by its importance, a reservoir of one through the 26 with a hash of the slot, the update count

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

@@ -1 +1 @@
-{"version":3,"file":"shader_probe_clipmap_candidate.d.ts","sourceRoot":"","sources":["../../../../../../../src/shade/renderer/global_illumination/probe_clipmap/probe/shader_probe_clipmap_candidate.js"],"names":[],"mappings":"AA6BA;;GAEG;AACH,uCAFU,YAAY,CAKO;AAqB7B;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AACH,6CAFU,aAAa,CAuFpB;6BA9J0B,sCAAsC;8BAHrC,kCAAkC"}
+{"version":3,"file":"shader_probe_clipmap_candidate.d.ts","sourceRoot":"","sources":["../../../../../../../src/shade/renderer/global_illumination/probe_clipmap/probe/shader_probe_clipmap_candidate.js"],"names":[],"mappings":"AA8BA;;GAEG;AACH,uCAFU,YAAY,CAKO;AAqB7B;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AACH,6CAFU,aAAa,CAwFpB;6BA/J0B,sCAAsC;8BAHrC,kCAAkC"}

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

@@ -1,3 +1,4 @@
+import { chunk_rgb_to_luminance } from "../../../shader/chunk/color/chunk_rgb_to_luminance.js";
 import { chunk_folded_workgroup_index } from "../../../shader/chunk/grid/chunk_folded_workgroup_index.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";
@@ -63,7 +64,7 @@ resources.createGroup()
  * - **The neighbours**: the 26 around B's lattice point in its cascade. One is a candidate if it is ALIVE, its
  *   record holds that point (the storage wraps), and it is listed this frame (`probe_clipmap_listed`), so that its
  *   rays are in `probe_rays`. A NEW one is not. M counts them.
- * - **The importance**: the neighbour's radiance, its irradiance's L0 luma, times B's visibility of it: Chebyshev
+ * - **The importance**: the neighbour's radiance, the luminance of its mean radiance, times B's visibility of it: Chebyshev
  *   over B's depth moments toward it (`probe_visibility_chebyshev`), its distance in B's spacings held to the depth
  *   limit, as the moments are. A dark neighbour, or one behind a wall, weighs about nothing.
  * - **The draw**: one by its importance, a reservoir of one through the 26 with a hash of the slot, the update count
@@ -135,7 +136,7 @@ fn main(
             let distance = length(to_neighbour);
             let toward = to_neighbour / max(distance, 1e-6);
             let visibility = probe_visibility_chebyshev(probe_clipmap_depth_moments(slot, toward), min(distance / spacing, ${PROBE_DEPTH_LIMIT}));
-            let radiance = max(probe_record_sh_decode(probe_records[neighbour].sh).Y.w, 0.0);
+            let radiance = rgb_to_luminance(probe_record_mean_radiance(probe_records[neighbour].sh));
             let importance = radiance * visibility;
 
             if (importance <= 0.0) {
@@ -160,6 +161,7 @@ fn main(
             chunk_probe_clipmap_pick,
             chunk_probe_clipmap_resample,
             chunk_folded_workgroup_index,
+            chunk_rgb_to_luminance,
             chunk_hash_to_float01,
             chunk_pcg3d,
         ]),

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

@@ -1 +1 @@
-{"version":3,"file":"shader_probe_clipmap_diffuse.d.ts","sourceRoot":"","sources":["../../../../../../../src/shade/renderer/global_illumination/probe_clipmap/probe/shader_probe_clipmap_diffuse.js"],"names":[],"mappings":"AAgFA;;;;;;;;GAQG;AACH,2CAFU,WAAW,CAalB;4BAtFyB,gCAAgC"}
+{"version":3,"file":"shader_probe_clipmap_diffuse.d.ts","sourceRoot":"","sources":["../../../../../../../src/shade/renderer/global_illumination/probe_clipmap/probe/shader_probe_clipmap_diffuse.js"],"names":[],"mappings":"AA8EA;;;;;;;;GAQG;AACH,2CAFU,WAAW,CAalB;4BArFyB,gCAAgC"}

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

@@ -6,11 +6,10 @@ import { ENVIRONMENT_MAP_SAMPLER_RESOURCE } from "../../../light/environment/ENV
 import { chunk_project_position_from_depth } from "../../../shader/chunk/camera/chunk_project_position_from_depth.js";
 import { chunk_mat4_extract_position } from "../../../shader/chunk/geometry/mat4/chunk_mat4_extract_position.js";
 import { chunk_decode_g_buffer_normal } from "../../../shader/chunk/geometry/normal/chunk_decode_g_buffer_normal.js";
-import { PI_DECLARATION } from "../../../shader/chunk/math/PI_DECLARATION.js";
 import { chunk_stbn_sample_vec2 } from "../../../shader/chunk/noise/chunk_stbn_sample_vec2.js";
 import {
-    chunk_resolve_irradiance_sh_to_diffuse
-} from "../../../shader/chunk/spherical_harmonics/l1i/chunk_resolve_irradiance_sh_to_diffuse.js";
+    chunk_sh3_color_get_irradiance_at
+} from "../../../shader/chunk/spherical_harmonics/chunk_sh3_color_get_irradiance_at.js";
 import { CodeChunk } from "../../../shader/compiler/CodeChunk.js";
 import { ImageShader } from "../../../shader/ImageShader.js";
 import { ShaderResourceSetDescriptor } from "../../../shader/resource/ShaderResourceSetDescriptor.js";
@@ -59,7 +58,7 @@ fn main(
     var irradiance = get_ibl_irradiance(bent_normal);
 
     if (probes.found) {
-        irradiance = PI * resolve_irradiance_sh_to_diffuse(probes.sh.Y, probes.sh.CoCg, bent_normal);
+        irradiance = sh3_color_get_irradiance_at(bent_normal, probes.sh);
     }
 
     // AO baked in at the source, as the IBL pass does, so the resolve need not know which path ran
@@ -73,9 +72,8 @@ fn main(
     chunk_decode_g_buffer_normal,
     chunk_stbn_sample_vec2,
     chunk_probe_clipmap_pick,
-    chunk_resolve_irradiance_sh_to_diffuse,
+    chunk_sh3_color_get_irradiance_at,
     chunk_get_ibl_irradiance,
-    PI_DECLARATION,
 ]);
 
 /**

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

@@ -7,6 +7,8 @@
  * - A pixel no probe weighs anything for takes the environment's for both.
  * - The two are resolved as `shader_resolve_indirect_lighting` resolves the IBL pair: AO multiplies the
  *   diffuse, the specular is occluded along its lobe, and the result is added to the scene's colour.
+ * - `PROBE_CLIPMAP_INDIRECT_LOBE` decides what is added: both lobes by default; for the mode's indirect debug
+ *   views, one lobe's light alone, as sampled, before the surface's material and occlusion.
  *
  * @type {ImageShader}
  */

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

@@ -1 +1 @@
-{"version":3,"file":"shader_probe_clipmap_indirect_lighting.d.ts","sourceRoot":"","sources":["../../../../../../../src/shade/renderer/global_illumination/probe_clipmap/probe/shader_probe_clipmap_indirect_lighting.js"],"names":[],"mappings":"AA0IA;;;;;;;;;;;GAWG;AACH,qDAFU,WAAW,CA0BlB;4BAxJyB,gCAAgC"}
+{"version":3,"file":"shader_probe_clipmap_indirect_lighting.d.ts","sourceRoot":"","sources":["../../../../../../../src/shade/renderer/global_illumination/probe_clipmap/probe/shader_probe_clipmap_indirect_lighting.js"],"names":[],"mappings":"AAyIA;;;;;;;;;;;;;GAaG;AACH,qDAFU,WAAW,CA0BlB;4BA1JyB,gCAAgC"}

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

@@ -14,11 +14,10 @@ import { chunk_compute_indirect_specular } from "../../../shader/chunk/material/
 import { chunk_decode_g_buffer_metalness } from "../../../shader/chunk/material/chunk_decode_g_buffer_metalness.js";
 import { chunk_decode_g_buffer_roughness } from "../../../shader/chunk/material/chunk_decode_g_buffer_roughness.js";
 import { chunk_metalness_to_specular_color } from "../../../shader/chunk/material/chunk_metalness_to_specular_color.js";
-import { PI_DECLARATION } from "../../../shader/chunk/math/PI_DECLARATION.js";
 import { chunk_stbn_sample_vec2 } from "../../../shader/chunk/noise/chunk_stbn_sample_vec2.js";
 import {
-    chunk_resolve_irradiance_sh_to_diffuse
-} from "../../../shader/chunk/spherical_harmonics/l1i/chunk_resolve_irradiance_sh_to_diffuse.js";
+    chunk_sh3_color_get_irradiance_at
+} from "../../../shader/chunk/spherical_harmonics/chunk_sh3_color_get_irradiance_at.js";
 import { CodeChunk } from "../../../shader/compiler/CodeChunk.js";
 import { ImageShader } from "../../../shader/ImageShader.js";
 import { ShaderResourceSetDescriptor } from "../../../shader/resource/ShaderResourceSetDescriptor.js";
@@ -26,6 +25,7 @@ import { ShaderDescriptor } from "../../../shader/ShaderDescriptor.js";
 import { STBN_VEC2_RESOURCE } from "../../../STATIC_GRAPHICS_ENGINE_ASSET_RESOURCES.js";
 import { SAMPLER_LINEAR_UPSCALE } from "../../../texture/SAMPLER_LINEAR_UPSCALE.js";
 import { VIEW_UNIFORM_STRUCT } from "../../../view/VIEW_UNIFORM_STRUCT.js";
+import { chunk_probe_clipmap_indirect_lobe } from "./chunk_probe_clipmap_indirect_lobe.js";
 import { chunk_probe_clipmap_pick, PROBE_CLIPMAP_SAMPLING_GROUP } from "./chunk_probe_clipmap_pick.js";
 import { chunk_probe_clipmap_sample_radiance } from "./chunk_probe_clipmap_sample_radiance.js";
 
@@ -88,8 +88,7 @@ fn main(
     var radiance: vec3<f32>;
 
     if (probes.found) {
-        // the resolve gives E/π
-        irradiance = PI * resolve_irradiance_sh_to_diffuse(probes.sh.Y, probes.sh.CoCg, bent_normal);
+        irradiance = sh3_color_get_irradiance_at(bent_normal, probes.sh);
         radiance = probe_clipmap_radiance_of(pick, position, normal, view_direction, surface_roughness).radiance;
     } else {
         // a pixel no probe weighs anything for takes the environment's, as the IBL passes give it
@@ -115,7 +114,7 @@ fn main(
     let spec_direction = normalize(mix(reflect(-view_direction, normal), normal, alpha));
     let specular_occlusion = compute_specular_occlusion_bn(spec_direction, bent_normal, occlusion, roughness);
 
-    return vec4(indirect[0] * specular_occlusion + indirect[1], 1.0);
+    return vec4(probe_clipmap_indirect_lobe(indirect[0] * specular_occlusion, indirect[1], radiance, irradiance), 1.0);
 }
 `, [
     chunk_project_position_from_depth,
@@ -128,12 +127,12 @@ fn main(
     chunk_stbn_sample_vec2,
     chunk_probe_clipmap_pick,
     chunk_probe_clipmap_sample_radiance,
-    chunk_resolve_irradiance_sh_to_diffuse,
+    chunk_sh3_color_get_irradiance_at,
     chunk_get_ibl_irradiance,
     chunk_get_ibl_radiance,
     chunk_compute_indirect_specular,
     chunk_compute_specular_occlusion_bn,
-    PI_DECLARATION,
+    chunk_probe_clipmap_indirect_lobe,
 ]);
 
 /**
@@ -145,6 +144,8 @@ fn main(
  * - A pixel no probe weighs anything for takes the environment's for both.
  * - The two are resolved as `shader_resolve_indirect_lighting` resolves the IBL pair: AO multiplies the
  *   diffuse, the specular is occluded along its lobe, and the result is added to the scene's colour.
+ * - `PROBE_CLIPMAP_INDIRECT_LOBE` decides what is added: both lobes by default; for the mode's indirect debug
+ *   views, one lobe's light alone, as sampled, before the surface's material and occlusion.
  *
  * @type {ImageShader}
  */

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

@@ -2,7 +2,7 @@
  * The light a front-face hit takes from the local lights (PROBE_CLIPMAP_PROPOSAL_2026_10_27.md §8.7): a
  * thread a ray, after shade through the same launch, `PROBE_DISPATCH_RAYS`, its probe the one trace wrote
  * into its flags. It adds ρ_d·E_loc/π to the radiance shade left, ρ_d being the albedo shade left in the
- * ray's \`row\`; the next bounce, E_ind, is the bounce pass's, after it (`shader_probe_clipmap_bounce`).
+ * ray's \`albedo\`; the next bounce, E_ind, is the bounce pass's, after it (`shader_probe_clipmap_bounce`).
  *
  * - **E_loc, the local lights**: one of the point and spot lights of the hit's cell of the world light
  *   clusters, built over the bricks' cascades so that every hit has one, at most

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

@@ -71,7 +71,7 @@ resources.createGroup()
  * The light a front-face hit takes from the local lights (PROBE_CLIPMAP_PROPOSAL_2026_10_27.md §8.7): a
  * thread a ray, after shade through the same launch, `PROBE_DISPATCH_RAYS`, its probe the one trace wrote
  * into its flags. It adds ρ_d·E_loc/π to the radiance shade left, ρ_d being the albedo shade left in the
- * ray's \`row\`; the next bounce, E_ind, is the bounce pass's, after it (`shader_probe_clipmap_bounce`).
+ * ray's \`albedo\`; the next bounce, E_ind, is the bounce pass's, after it (`shader_probe_clipmap_bounce`).
  *
  * - **E_loc, the local lights**: one of the point and spot lights of the hit's cell of the world light
  *   clusters, built over the bricks' cascades so that every hit has one, at most
@@ -216,7 +216,7 @@ fn main(
 ) {
     let ray = folded_workgroup_index(workgroup_id) * PROBE_THREAD_WORKGROUP_SIZE + lane;
     let record = probe_rays[ray];
-    let albedo = unpack4x8unorm(record.row).rgb;
+    let albedo = unpack4x8unorm(record.albedo).rgb;
     let front_hit = (record.flags & PROBE_RAY_KIND_MASK) == ${BRICK_TRACE_HIT}u && (record.flags & PROBE_RAY_BACK_FACE) == 0u;
 
     // only a front-face hit that bounces anything takes more light

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

@@ -5,8 +5,8 @@ export const PROBE_PROJECT_SETTINGS: WebGPUStruct;
 /**
  * Projection, rows (PROBE_CLIPMAP_PROPOSAL_2026_10_27.md §8.8): a thread a row of each listed probe's
  * radiance map, dispatched through `PROBE_DISPATCH_ROWS`. It sums the row's texels, new and kept, as
- * irradiance SH, `convert_to_irradiance_sh(L, ω)·dω/(2π)` over each texel's solid angle, so that the
- * resolve gives E/π; the row's rays this update, resolved and back faces; and how far the update's
+ * RGB radiance SH3, `L·Y(ω)·dω` over each texel's solid angle, so that `sh3_color_get_irradiance_at` gives
+ * E; the row's rays this update, resolved and back faces; and how far the update's
  * samples fell from their means, with that sum's variance. One row of the probe's projection each, which
  * the probe's pass sums.
  *
@@ -15,7 +15,8 @@ export const PROBE_PROJECT_SETTINGS: WebGPUStruct;
 export const shader_probe_clipmap_project_rows: ComputeShader;
 /**
  * Projection, probes (PROBE_CLIPMAP_PROPOSAL_2026_10_27.md §8.4, §8.8): a thread a listed probe,
- * dispatched through `PROBE_DISPATCH_TRACED`. It sums its rows into its record's SH, and classifies it
+ * dispatched through `PROBE_DISPATCH_TRACED`. It sums its rows into its record's SH (`probe_record_sh_encode`),
+ * and classifies it
  * by the update's resolved rays: dead when every one hit a back face, else alive, its update counted and
  * its time the frame's. An update with no resolved ray keeps the probe's kind.
  *

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

@@ -1 +1 @@
-{"version":3,"file":"shader_probe_clipmap_project.d.ts","sourceRoot":"","sources":["../../../../../../../src/shade/renderer/global_illumination/probe_clipmap/probe/shader_probe_clipmap_project.js"],"names":[],"mappings":"AAoCA;;GAEG;AACH,qCAFU,YAAY,CAmBK;AAW3B;;;;;;;;;GASG;AACH,gDAFU,aAAa,CAuDpB;AAcH;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA4BG;AACH,2CAFU,aAAa,CA4FpB;6BAzP0B,sCAAsC;8BAHrC,kCAAkC"}
+{"version":3,"file":"shader_probe_clipmap_project.d.ts","sourceRoot":"","sources":["../../../../../../../src/shade/renderer/global_illumination/probe_clipmap/probe/shader_probe_clipmap_project.js"],"names":[],"mappings":"AAmCA;;GAEG;AACH,qCAFU,YAAY,CAmBK;AAW3B;;;;;;;;;GASG;AACH,gDAFU,aAAa,CAsDpB;AAcH;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA6BG;AACH,2CAFU,aAAa,CA8FpB;6BA3P0B,sCAAsC;8BAHrC,kCAAkC"}

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

@@ -5,9 +5,8 @@ import {
     chunk_uv_octahedral_unit_decode
 } from "../../../shader/chunk/geometry/octahedron/chunk_uv_octahedral_unit_decode.js";
 import { chunk_folded_workgroup_index } from "../../../shader/chunk/grid/chunk_folded_workgroup_index.js";
-import {
-    chunk_convert_to_irradiance_sh
-} from "../../../shader/chunk/spherical_harmonics/l1i/chunk_convert_to_irradiance_sh.js";
+import { chunk_sh3_basis_at } from "../../../shader/chunk/spherical_harmonics/chunk_sh3_basis_at.js";
+import { chunk_sh3_color_accumulate } from "../../../shader/chunk/spherical_harmonics/chunk_sh3_color_accumulate.js";
 import { CodeChunk } from "../../../shader/compiler/CodeChunk.js";
 import { ComputeShader } from "../../../shader/ComputeShader.js";
 import { ShaderResourceSetDescriptor } from "../../../shader/resource/ShaderResourceSetDescriptor.js";
@@ -68,8 +67,8 @@ row_resources.createGroup()
 /**
  * Projection, rows (PROBE_CLIPMAP_PROPOSAL_2026_10_27.md §8.8): a thread a row of each listed probe's
  * radiance map, dispatched through `PROBE_DISPATCH_ROWS`. It sums the row's texels, new and kept, as
- * irradiance SH, `convert_to_irradiance_sh(L, ω)·dω/(2π)` over each texel's solid angle, so that the
- * resolve gives E/π; the row's rays this update, resolved and back faces; and how far the update's
+ * RGB radiance SH3, `L·Y(ω)·dω` over each texel's solid angle, so that `sh3_color_get_irradiance_at` gives
+ * E; the row's rays this update, resolved and back faces; and how far the update's
  * samples fell from their means, with that sum's variance. One row of the probe's projection each, which
  * the probe's pass sums.
  *
@@ -105,13 +104,11 @@ fn main(
         let i = row * n + x;
         let light = vec3<f32>(unpack2x16float(probe_maps[maps + 2u * i]), unpack2x16float(probe_maps[maps + 2u * i + 1u]).x);
         let uv = (vec2<f32>(f32(x), f32(row)) + 0.5) * inverse;
-        let weight = octahedral_solid_angle(uv, inverse) * ${(0.5 / Math.PI).toPrecision(17)};
-        let sh = convert_to_irradiance_sh(light, uv_octahedral_unit_decode(uv));
+        let solid_angle = octahedral_solid_angle(uv, inverse);
         let rays = probe_maps[maps + 2u * texels + i];
         let change = unpack2x16float(probe_maps[maps + 3u * texels + settings.depth_resolution * settings.depth_resolution + i]);
 
-        row_sum.sh.CoCg += sh.CoCg * weight;
-        row_sum.sh.Y += sh.Y * weight;
+        sh3_color_accumulate(&row_sum.sh, light * solid_angle, sh3_basis_at(uv_octahedral_unit_decode(uv)));
         row_sum.resolved += rays & 0xFFFFu;
         row_sum.back_faces += rays >> 16u;
         row_sum.change += change.x;
@@ -125,7 +122,8 @@ fn main(
             chunk_folded_workgroup_index,
             chunk_octahedral_solid_angle,
             chunk_uv_octahedral_unit_decode,
-            chunk_convert_to_irradiance_sh,
+            chunk_sh3_basis_at,
+            chunk_sh3_color_accumulate,
             PROBE_PROJECTION_ROW_STRUCT.declaration_chunk,
         ]),
 });
@@ -144,7 +142,8 @@ probe_resources.createGroup()
 
 /**
  * Projection, probes (PROBE_CLIPMAP_PROPOSAL_2026_10_27.md §8.4, §8.8): a thread a listed probe,
- * dispatched through `PROBE_DISPATCH_TRACED`. It sums its rows into its record's SH, and classifies it
+ * dispatched through `PROBE_DISPATCH_TRACED`. It sums its rows into its record's SH (`probe_record_sh_encode`),
+ * and classifies it
  * by the update's resolved rays: dead when every one hit a back face, else alive, its update counted and
  * its time the frame's. An update with no resolved ray keeps the probe's kind.
  *
@@ -196,8 +195,10 @@ fn main(
     for (var row = 0u; row < n; row++) {
         let part = probe_projection[k * n + row];
 
-        sum.sh.CoCg += part.sh.CoCg;
-        sum.sh.Y += part.sh.Y;
+        for (var c = 0u; c < 9u; c++) {
+            sum.sh[c] += part.sh[c];
+        }
+
         sum.resolved += part.resolved;
         sum.back_faces += part.back_faces;
         sum.change += part.change;

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

@@ -10,13 +10,16 @@
  *   4πm²·(1 − (1 − e^(−k))/k), k = 2/m²: m = 1/n_r to 0.2% at n_r = 16, so the roughness is 1/√n_r. A sun
  *   a few texels wide at level 0 is then a lobe a texel wide, which a texel's jittered rays all see,
  *   rather than a point that only some probes' jitter ever lands on;
- * - a **front-face hit** is `emissive + ρ_d·E_dir/π` (D7), its surface from `probe_clipmap_hit_surface`
- *   at the hit's position, the probe's origin plus t along the ray, with the hit's normal, at its
- *   cascade's voxel; E_dir is what trace left in the light;
+ * - a **front-face hit** is `emissive + ρ_d·E_dir/π` (D7), its surface from
+ *   `probe_clipmap_hit_material_pick` at the hit's position, the probe's origin plus t along the ray,
+ *   with the hit's normal, in its cascade: one texel of the brick material there, drawn from the ray's
+ *   slot and direction, fresh every update and apart from the light pass's draws, in proportion to its
+ *   weight in the texels' blend, which the probe's blend of its rays so takes on average; E_dir is what
+ *   trace left in the light;
  * - an **unresolved** ray and a **back face** bring nothing back: accumulation discards the one and
  *   counts the other (§8.4, §8.8).
  *
- * A front-face hit's diffuse albedo goes over its `row`, `pack4x8unorm`, and every other ray's row to
+ * A front-face hit's diffuse albedo goes into its `albedo`, `pack4x8unorm`, and every other ray's to
  * zero: the light pass adds ρ_d·(E_loc + E_ind)/π after it (S5).
  *
  * @type {ComputeShader}

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

@@ -1 +1 @@
-{"version":3,"file":"shader_probe_clipmap_shade.d.ts","sourceRoot":"","sources":["../../../../../../../src/shade/renderer/global_illumination/probe_clipmap/probe/shader_probe_clipmap_shade.js"],"names":[],"mappings":"AAuDA;;;;;;;;;;;;;;;;;;;;;;GAsBG;AACH,yCAFU,aAAa,CAyDpB;8BAlH2B,kCAAkC"}
+{"version":3,"file":"shader_probe_clipmap_shade.d.ts","sourceRoot":"","sources":["../../../../../../../src/shade/renderer/global_illumination/probe_clipmap/probe/shader_probe_clipmap_shade.js"],"names":[],"mappings":"AAqDA;;;;;;;;;;;;;;;;;;;;;;;;;GAyBG;AACH,yCAFU,aAAa,CA4DpB;8BA7H2B,kCAAkC"}