@woosh/meep-engine 3.61.0 → 3.61.2

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
@@ -75,7 +73,8 @@ resources.createGroup()
  * `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.
@@ -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,
@@ -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.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":"AAuIA;;;;;;;;;;;GAWG;AACH,qDAFU,WAAW,CA0BlB;4BAtJyB,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";
@@ -88,8 +87,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
@@ -128,12 +126,11 @@ 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,
 ]);
 
 /**

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_trace.d.ts

@@ -12,10 +12,9 @@ export const PROBE_TRACE_SETTINGS: WebGPUStruct;
  *   or a spread subset below R = n_r². On a guided one, the walk position whose rays the ray is among
  *   in the probe's guide (`chunk_probe_clipmap_guide`), found by bisecting the first rays. A texel's rays
  *   then follow one another, in the walk's order.
- * - **Direction**: the texel's octahedral square, jittered by STBN at the texel, moved by the slot's
- *   hash so that neighbouring probes do not jitter alike, and at the update count: one stratified,
- *   jittered ray a texel, LPV's own pattern. A guided texel's later rays rotate that jitter by R2
- *   (`probe_clipmap_guided_ray_jitter`).
+ * - **Direction**: the texel's octahedral square, jittered by white noise of the probe's slot, its update
+ *   count and the ray's place in the update (`probe_clipmap_ray_noise`, `PROBE_RAY_NOISE_JITTER`), on
+ *   uniform and guided updates alike. Nothing stratifies the jitter inside a texel.
  * - **Origin**: a point of a small ball around the probe where relocation left it, `probe_origins`, one a
  *   ray (`probe_clipmap_ray_origin`); t_min one voxel of the brick cascade there.
  * - **Direct light**: a hit off a front face takes E_dir = Σ colour·max(0, n·l)·visibility over the

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

@@ -1 +1 @@
-{"version":3,"file":"shader_probe_clipmap_trace.d.ts","sourceRoot":"","sources":["../../../../../../../src/shade/renderer/global_illumination/probe_clipmap/probe/shader_probe_clipmap_trace.js"],"names":[],"mappings":"AAqDA;;GAEG;AACH,mCAFU,YAAY,CAeG;AAwBzB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA+BG;AACH,yCAFU,aAAa,CAoJpB;6BAzP0B,sCAAsC;8BAHrC,kCAAkC"}
+{"version":3,"file":"shader_probe_clipmap_trace.d.ts","sourceRoot":"","sources":["../../../../../../../src/shade/renderer/global_illumination/probe_clipmap/probe/shader_probe_clipmap_trace.js"],"names":[],"mappings":"AAmDA;;GAEG;AACH,mCAFU,YAAY,CAeG;AAuBzB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA8BG;AACH,yCAFU,aAAa,CAgJpB;6BAjP0B,sCAAsC;8BAHrC,kCAAkC"}

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

@@ -21,7 +21,6 @@ import { ComputeShader } from "../../../shader/ComputeShader.js";
 import { ShaderResourceSetDescriptor } from "../../../shader/resource/ShaderResourceSetDescriptor.js";
 import { f32, u32 } from "../../../shader/type/WEBGPU_WGSL_PRIMITIVE_TYPES.js";
 import { WebGPUStruct } from "../../../shader/type/WebGPUStruct.js";
-import { STBN_VEC2_RESOURCE } from "../../../STATIC_GRAPHICS_ENGINE_ASSET_RESOURCES.js";
 import {
     BRICK_ATLAS_TEXTURE_RESOURCE,
     BRICK_LEVELS_RESOURCE,
@@ -35,9 +34,8 @@ import {
 import {
     chunk_probe_clipmap,
     chunk_probe_clipmap_guide,
-    chunk_probe_clipmap_guided_ray_jitter,
-    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_GUIDE_READ_RESOURCE,
@@ -80,7 +78,6 @@ resources.createGroup()
     .add(PROBE_RAYS_WRITE_RESOURCE)
     .add(PROBE_RAY_SUMS_READ_RESOURCE)
     .add(PROBE_GUIDE_READ_RESOURCE)
-    .add(STBN_VEC2_RESOURCE)
     .add(LIGHT_DATA_RESOURCE);
 
 resources.createGroup()
@@ -101,10 +98,9 @@ resources.createGroup()
  *   or a spread subset below R = n_r². On a guided one, the walk position whose rays the ray is among
  *   in the probe's guide (`chunk_probe_clipmap_guide`), found by bisecting the first rays. A texel's rays
  *   then follow one another, in the walk's order.
- * - **Direction**: the texel's octahedral square, jittered by STBN at the texel, moved by the slot's
- *   hash so that neighbouring probes do not jitter alike, and at the update count: one stratified,
- *   jittered ray a texel, LPV's own pattern. A guided texel's later rays rotate that jitter by R2
- *   (`probe_clipmap_guided_ray_jitter`).
+ * - **Direction**: the texel's octahedral square, jittered by white noise of the probe's slot, its update
+ *   count and the ray's place in the update (`probe_clipmap_ray_noise`, `PROBE_RAY_NOISE_JITTER`), on
+ *   uniform and guided updates alike. Nothing stratifies the jitter inside a texel.
  * - **Origin**: a point of a small ball around the probe where relocation left it, `probe_origins`, one a
  *   ray (`probe_clipmap_ray_origin`); t_min one voxel of the brick cascade there.
  * - **Direct light**: a hit off a front face takes E_dir = Σ colour·max(0, n·l)·visibility over the
@@ -177,19 +173,16 @@ fn main(
     let updates = probe_state_updates(state.x);
 
     var texel: u32;
-    var jitter: vec2<f32>;
 
     if (probe_clipmap_guided(state.x, settings.uniform_period, settings.rays_per_probe, texels)) {
         let base = k * probe_clipmap_guide_words(n);
-        let position = probe_trace_guided_position(base, i, texels);
 
-        texel = probe_clipmap_guide_texel(position, updates, n);
-        jitter = probe_clipmap_guided_ray_jitter(slot, texel, i - probe_guide[base + position], updates, rays, n);
+        texel = probe_clipmap_guide_texel(probe_trace_guided_position(base, i, texels), updates, n);
     } else {
         texel = probe_clipmap_ray_texel(i, updates, rays, texels);
-        jitter = probe_clipmap_ray_jitter(slot, texel, i, updates, rays, n);
     }
 
+    let jitter = probe_clipmap_ray_noise(slot, updates, i, PROBE_RAY_NOISE_JITTER);
     let direction = uv_octahedral_unit_decode((vec2<f32>(f32(texel % n), f32(texel / n)) + jitter) / f32(n));
     let packed = pack2x16unorm(uv_octahedral_unit_encode(direction));
 
@@ -253,10 +246,9 @@ 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_probe_clipmap_guide,
-            chunk_probe_clipmap_guided_ray_jitter,
             chunk_folded_workgroup_index,
             chunk_uv_octahedral_unit_decode,
             chunk_uv_octahedral_unit_encode,

package/src/shade/renderer/light/environment/shader_downsample_environment_map.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"shader_downsample_environment_map.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/light/environment/shader_downsample_environment_map.js"],"names":[],"mappings":"AAmGA,8DAII;8BAhG0B,+BAA+B"}
+{"version":3,"file":"shader_downsample_environment_map.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/light/environment/shader_downsample_environment_map.js"],"names":[],"mappings":"AAuGA,8DAII;8BApG0B,+BAA+B"}

package/src/shade/renderer/light/environment/shader_downsample_environment_map.js

@@ -64,11 +64,15 @@ fn main(
         let texel_y = first.y + f32(y);
         let overlap_y = min(texel_y + 1.0, lo.y + span) - max(texel_y, lo.y);
 
+        if (overlap_y <= 0.0) {
+            continue;
+        }
+
         for (var x = 0u; x < 4u; x++) {
             let texel_x = first.x + f32(x);
             let overlap_x = min(texel_x + 1.0, lo.x + span) - max(texel_x, lo.x);
 
-            if (overlap_x <= 0.0 || overlap_y <= 0.0) {
+            if (overlap_x <= 0.0) {
                 continue;
             }
 

package/src/shade/renderer/particles/GPUParticleSystem.d.ts.map

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

package/src/shade/renderer/particles/GPUParticleSystem.js

@@ -68,13 +68,7 @@ const STORAGE_GROWABLE = GPUBufferUsage.STORAGE | GPUBufferUsage.COPY_DST | GPUB
  */
 const INDIRECT = GPUBufferUsage.STORAGE | GPUBufferUsage.INDIRECT | GPUBufferUsage.COPY_SRC;
 
-/**
- * Particles a scene holds at once unless the constructor is told otherwise — and the renderer never
- * tells it ({@link ../Renderer.js Renderer#particles}), so this is every scene's pool. 2^17: about
- * 18 MB of pool, free list, alive list and coherence scratch at a 128-byte record, which a game with
- * dense bursts (a body dissolving into thousands of motes) fills before 65,536 does.
- */
-const DEFAULT_CAPACITY = 131072;
+const DEFAULT_CAPACITY = 65536;
 
 /**
  * What {@link GPUParticleSystem#read_stats} decodes: the counts the GPU keeps between frames, named.

package/src/shade/renderer/postprocess/eye/GPUCameraExposureManager.d.ts

@@ -1,8 +1,10 @@
 /**
- * @typedef {import("../../../device/pipeline/PipelineEnquiry.js").PipelineEnquiry} PipelineEnquiry
- */
-/**
- * Calculates exposure for eye adaptation
+ * The exposure: the factor the tonemapper multiplies the scene's linear radiance by ahead of its curve, metered from
+ * the frame and adapted to it ({@link update}), or set by {@link exposure_compensation} alone ({@link unadapted}).
+ *
+ * The factor lives in one buffer for the manager's life, {@link multiplier}, which a frame's {@link update} or
+ * {@link unadapted} writes over. A pass recorded ahead of that write in the frame reads the factor the last frame was
+ * shown with: the exposure of the image on screen, Unreal Engine's `View.PreExposure`.
  */
 export class GPUCameraExposureManager {
     /**
@@ -37,6 +39,14 @@ export class GPUCameraExposureManager {
      */
     exposure_compensation: number;
     destroy(): void;
+    /**
+     * The factor, {@link F32_CONTAINER_STRUCT}, as the last {@link update} or {@link unadapted} wrote it. A frame
+     * imports it into its graph once, and hands the handle both to the passes that read it ahead of the exposure,
+     * which take the last frame's factor, and to {@link update} or {@link unadapted}, which write this frame's.
+     *
+     * @returns {GPUBuffer} usable as a uniform or read-only storage
+     */
+    get multiplier(): GPUBuffer;
     /**
      * Offer the pipelines {@link update} meters and adapts with — see {@link PipelineEnquiry}.
      * {@link unadapted} dispatches none.
@@ -45,26 +55,34 @@ export class GPUCameraExposureManager {
      */
     enquirePipelines(enquiry: PipelineEnquiry): void;
     /**
+     * This frame's factor from {@link exposure_compensation} alone: 2^compensation.
      *
      * @param {Object} options
      * @param {FrameGraph} options.graph
-     * @return {number}
+     * @param {number} options.multiplier the graph handle of {@link multiplier}, imported into `graph`
+     * @return {number} the handle of {@link multiplier} with this frame's factor written
      */
-    unadapted({ graph, }: {
+    unadapted({ graph, multiplier, }: {
         graph: FrameGraph;
+        multiplier: number;
     }): number;
     /**
+     * This frame's factor metered from `input_color`: the luminance adapted toward the frame's, from the last
+     * frame's, by the adaptation speeds; its factor is middle grey over it, times 2^{@link exposure_compensation}.
      *
      * @param {Object} options
      * @param {FrameGraph} options.graph
      * @param {number} options.input_color
+     * @param {number} options.multiplier the graph handle of {@link multiplier}, imported into `graph`
      * @param {number} [options.time_delta_seconds]
+     * @return {number} the handle of {@link multiplier} with this frame's factor written
      */
-    update({ input_color, graph, time_delta_seconds, }: {
+    update({ input_color, graph, multiplier, time_delta_seconds, }: {
         graph: FrameGraph;
         input_color: number;
+        multiplier: number;
         time_delta_seconds?: number;
-    }): any;
+    }): number;
     #private;
 }
 export type PipelineEnquiry = import("../../../device/pipeline/PipelineEnquiry.js").PipelineEnquiry;

package/src/shade/renderer/postprocess/eye/GPUCameraExposureManager.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"GPUCameraExposureManager.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/postprocess/eye/GPUCameraExposureManager.js"],"names":[],"mappings":"AAUA;;GAEG;AAEH;;GAEG;AACH;IAuCI;;;OAGG;IACH,+BAcC;IAhDD;;;;OAIG;IACH,qBAFU,MAAM,CAEU;IAE1B;;;;OAIG;IACH,uBAFU,MAAM,CAEY;IAE5B;;;;;OAKG;IACH,yBAFU,MAAM,CAEc;IAE9B;;;;;OAKG;IACH,uBAFU,MAAM,CAEY;IAsB5B,gBAIC;IAED;;;;;OAKG;IACH,0BAFW,eAAe,QAMzB;IAED;;;;;OAKG;IACH;QAH+B,KAAK;QACxB,MAAM,CAyCjB;IAED;;;;;;OAMG;IACH;QAJ+B,KAAK;QACT,WAAW,EAA3B,MAAM;QACW,kBAAkB,GAAnC,MAAM;YAwJhB;;CAEJ;8BAjSY,OAAO,6CAA6C,EAAE,eAAe"}
+{"version":3,"file":"GPUCameraExposureManager.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/postprocess/eye/GPUCameraExposureManager.js"],"names":[],"mappings":"AAwBA;;;;;;;GAOG;AACH;IA0DI;;;OAGG;IACH,+BAyBC;IAtED;;;;OAIG;IACH,qBAFU,MAAM,CAEU;IAE1B;;;;OAIG;IACH,uBAFU,MAAM,CAEY;IAE5B;;;;;OAKG;IACH,yBAFU,MAAM,CAEc;IAE9B;;;;;OAKG;IACH,uBAFU,MAAM,CAEY;IA4C5B,gBAMC;IAED;;;;;;OAMG;IACH,4BAEC;IAED;;;;;OAKG;IACH,0BAFW,eAAe,QAMzB;IAED;;;;;;;OAOG;IACH;QAJ+B,KAAK;QACT,UAAU,EAA1B,MAAM;QACL,MAAM,CAejB;IAoBD;;;;;;;;;;OAUG;IACH;QAN+B,KAAK;QACT,WAAW,EAA3B,MAAM;QACU,UAAU,EAA1B,MAAM;QACW,kBAAkB,GAAnC,MAAM;QACL,MAAM,CAmDjB;;CA2EJ;8BA7TY,OAAO,6CAA6C,EAAE,eAAe"}