@woosh/meep-engine 3.61.1 → 3.61.2

package/src/shade/renderer/shader/chunk/noise/chunk_sobol_sample_vec2.js

@@ -0,0 +1,75 @@
+import { CodeChunk } from "../../compiler/CodeChunk.js";
+import { chunk_hash_lk } from "../random/chunk_hash_lk.js";
+import { chunk_hash_to_float01 } from "../random/chunk_hash_to_float01.js";
+
+
+/**
+ * Evaluates a 2D shuffled, Owen-scrambled Sobol (0, 2)-sequence point in [0, 1)^2
+ * entirely in registers with zero lookup tables.
+ *
+ * Every power-of-two prefix of 2^m samples forms a fully stratified (0, m, 2)-net
+ * across all elementary dyadic rectangles of area 2^-m, while per-pixel seeding
+ * decorrelates sample sets across pixels and bounce dimensions:
+ *
+ * 1. **Index shuffling (MSB-to-LSB):** `sample_idx` is Owen-scrambled top-down via
+ *    `reverseBits(hash_lk(reverseBits(sample_idx), ...))`. This maps every aligned
+ *    block of 2^m contiguous indices `[k * 2^m, (k + 1) * 2^m)` bijectively onto
+ *    another aligned 2^m block, randomizing traversal order per pixel while keeping
+ *    bits `i_31..i_m` constant across the block so prefix stratification holds.
+ * 2. **Dimension 0 (Van der Corput):** Prior to radical inversion, the base-2
+ *    Van der Corput sequence is the identity on `i`. Because bit 0 of `i` (`i_0`)
+ *    already represents the geometric MSB (2^-1), `hash_lk` is applied directly
+ *    followed by a single `reverseBits`.
+ * 3. **Dimension 1 (Sobol D1):** Computed without direction-number tables by
+ *    multiplying `i` by the 32x32 upper-triangular Pascal matrix over GF(2)
+ *    (`P_{k,j} = C(j, k) mod 2`, the 5-fold Kronecker power of `[1 1; 0 1]`) using
+ *    5 logarithmic butterfly shift-XOR stages before coordinate scrambling.
+ *
+ * For multi-bounce path tracing, pass a combined hash of `(pixel_coord, bounce_dim_pair)`
+ * as `pixel_seed` to construct padded 2D (0, 2)-sequences without high-dimensional
+ * direction tables.
+ *
+ * @see Brent Burley, "Practical Hash-based Owen Scrambling", Journal of Computer
+ *      Graphics Techniques (JCGT), vol. 9, no. 4, pp. 1-20, 2020.
+ *      http://jcgt.org/published/0009/04/01/
+ * @see Nathan Vegdahl, "Building a Better LK Hash", 2021.
+ *      https://psychopath.io/post/2021_01_30_building_a_better_lk_hash
+ * @see Ilya M. Sobol', "On the distribution of points in a cube and the approximate
+ *      evaluation of integrals", USSR Computational Mathematics and Mathematical
+ *      Physics, vol. 7, no. 4, pp. 86-112, 1967.
+ *
+ * @type {CodeChunk}
+ */
+export const chunk_sobol_sample_vec2 = CodeChunk.from(
+    //language=WGSL
+    `
+fn sample_sobol_2d(sample_idx: u32, pixel_seed: u32) -> vec2<f32> {
+    // 1. Shuffle index (MSB -> LSB):
+    //    Reverse sample_idx so s_31 is at bit 0, run LSB->MSB hash,
+    //    then reverse back so i_0 is at bit 0 for Sobol generation.
+    let idx_seed = pixel_seed ^ 0x79c68e4au;
+    let i = reverseBits(hash_lk(reverseBits(sample_idx), idx_seed));
+
+    // 2. Dimension 0 (Van der Corput):
+    //    i_0 (geometric MSB) is already at bit 0. Hash LSB->MSB, then
+    //    reverse once so the geometric MSB sits at bit 31.
+    let u0 = reverseBits(hash_lk(i, pixel_seed ^ 0x9e3779b9u));
+
+    // 3. Dimension 1 (Sobol D1 via upper-triangular Pascal matrix):
+    //    Requires i_0 at bit 0 so high bits (i_31..i_m, which are constant
+    //    across 2^m-aligned blocks) shift down into low bits.
+    var b = i;
+    b ^= b >> 16u;
+    b ^= (b & 0xff00ff00u) >> 8u;
+    b ^= (b & 0xf0f0f0f0u) >> 4u;
+    b ^= (b & 0xccccccccu) >> 2u;
+    b ^= (b & 0xaaaaaaaau) >> 1u;
+    let u1 = reverseBits(hash_lk(b, pixel_seed ^ 0xbb67ae85u));
+
+    return vec2<f32>(hash_to_float01(u0), hash_to_float01(u1));
+}
+    `,[
+        chunk_hash_lk,
+        chunk_hash_to_float01
+    ]
+)

package/src/shade/renderer/shader/chunk/noise/chunk_vdc_radical_inverse.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"chunk_vdc_radical_inverse.d.ts","sourceRoot":"","sources":["../../../../../../../src/shade/renderer/shader/chunk/noise/chunk_vdc_radical_inverse.js"],"names":[],"mappings":"AAEA;;;;;GAKG;AACH,wCAFU,SAAS,CAYlB;0BAlByB,6BAA6B"}
+{"version":3,"file":"chunk_vdc_radical_inverse.d.ts","sourceRoot":"","sources":["../../../../../../../src/shade/renderer/shader/chunk/noise/chunk_vdc_radical_inverse.js"],"names":[],"mappings":"AAGA;;;;;GAKG;AACH,wCAFU,SAAS,CAalB;0BApByB,6BAA6B"}

package/src/shade/renderer/shader/chunk/noise/chunk_vdc_radical_inverse.js

@@ -1,4 +1,5 @@
 import { CodeChunk } from "../../compiler/CodeChunk.js";
+import { chunk_hash_to_float01 } from "../random/chunk_hash_to_float01.js";
 
 /**
  *
@@ -12,8 +13,9 @@ export const chunk_vdc_radical_inverse = CodeChunk.from(
 fn vdc_radical_inverse(bits:u32) -> f32{
     let b = reverseBits(bits);
     
-    return f32(b) * 2.3283064365386963e-10;
+    return hash_to_float01(b);
 }
     `, [
+        chunk_hash_to_float01
     ]
 )

package/src/shade/renderer/shader/chunk/random/chunk_hash_lk.d.ts

@@ -0,0 +1,28 @@
+/**
+ * Applies Brent Burley's improved seeded Laine-Karras permutation hash for fast
+ * hash-based Owen scrambling of low-discrepancy sequences.
+ *
+ * Every operation in the sequence — integer addition, multiplication by an odd
+ * integer, and XOR-multiplication by an even constant — is a bijection modulo 2^k
+ * for all k in [1, 32]. Consequently, bit `i` of the output depends exclusively
+ * on bits `0..=i` of `x_in`, propagating entropy strictly from least-significant
+ * bit (LSB) to most-significant bit (MSB) while preserving prefix stratification.
+ *
+ * True Owen scrambling randomizes binary radical inverses from MSB to LSB. Unless
+ * your input sequence is already evaluated in bit-reversed order, wrap the call
+ * with `reverseBits`: `reverseBits(hash_lk(reverseBits(x), seed))`.
+ *
+ * @see Nathan Vegdahl, "Building a Better LK Hash", 2021.
+ *      https://psychopath.io/post/2021_01_30_building_a_better_lk_hash
+ * @see Brent Burley, "Practical Hash-based Owen Scrambling", Journal of Computer
+ *      Graphics Techniques (JCGT), vol. 9, no. 4, pp. 1-20, 2020.
+ *      http://jcgt.org/published/0009/04/01/
+ * @see Samuli Laine and Tero Karras, "Stratified Sampling for Stochastic
+ *      Transparency", Computer Graphics Forum (Proceedings of EGSR), vol. 30,
+ *      no. 4, pp. 1197-1204, 2011. https://doi.org/10.1111/j.1467-8659.2011.01978.x
+ *
+ * @type {CodeChunk}
+ */
+export const chunk_hash_lk: CodeChunk;
+import { CodeChunk } from "../../compiler/CodeChunk.js";
+//# sourceMappingURL=chunk_hash_lk.d.ts.map

package/src/shade/renderer/shader/chunk/random/chunk_hash_lk.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"chunk_hash_lk.d.ts","sourceRoot":"","sources":["../../../../../../../src/shade/renderer/shader/chunk/random/chunk_hash_lk.js"],"names":[],"mappings":"AAEA;;;;;;;;;;;;;;;;;;;;;;;;GAwBG;AACH,4BAFU,SAAS,CAejB;0BAxCwB,6BAA6B"}

package/src/shade/renderer/shader/chunk/random/chunk_hash_lk.js

@@ -0,0 +1,41 @@
+import { CodeChunk } from "../../compiler/CodeChunk.js";
+
+/**
+ * Applies Brent Burley's improved seeded Laine-Karras permutation hash for fast
+ * hash-based Owen scrambling of low-discrepancy sequences.
+ *
+ * Every operation in the sequence — integer addition, multiplication by an odd
+ * integer, and XOR-multiplication by an even constant — is a bijection modulo 2^k
+ * for all k in [1, 32]. Consequently, bit `i` of the output depends exclusively
+ * on bits `0..=i` of `x_in`, propagating entropy strictly from least-significant
+ * bit (LSB) to most-significant bit (MSB) while preserving prefix stratification.
+ *
+ * True Owen scrambling randomizes binary radical inverses from MSB to LSB. Unless
+ * your input sequence is already evaluated in bit-reversed order, wrap the call
+ * with `reverseBits`: `reverseBits(hash_lk(reverseBits(x), seed))`.
+ *
+ * @see Nathan Vegdahl, "Building a Better LK Hash", 2021.
+ *      https://psychopath.io/post/2021_01_30_building_a_better_lk_hash
+ * @see Brent Burley, "Practical Hash-based Owen Scrambling", Journal of Computer
+ *      Graphics Techniques (JCGT), vol. 9, no. 4, pp. 1-20, 2020.
+ *      http://jcgt.org/published/0009/04/01/
+ * @see Samuli Laine and Tero Karras, "Stratified Sampling for Stochastic
+ *      Transparency", Computer Graphics Forum (Proceedings of EGSR), vol. 30,
+ *      no. 4, pp. 1197-1204, 2011. https://doi.org/10.1111/j.1467-8659.2011.01978.x
+ *
+ * @type {CodeChunk}
+ */
+export const chunk_hash_lk = CodeChunk.from(
+    //language=WGSL
+    `
+fn hash_lk(x_in: u32, seed: u32) -> u32 {
+    var x = x_in;
+    x ^= x * 0x3d20adeau;
+    x += seed;
+    x *= (seed >> 16u) | 1u;
+    x ^= x * 0x05526c56u;
+    x ^= x * 0x53a22864u;
+    return x;
+}
+    `
+);

package/src/shade/renderer/shader/chunk/spherical_harmonics/chunk_sh3_color_add_scaled.d.ts

@@ -0,0 +1,12 @@
+/**
+ * `a + b × scale`, coefficient by coefficient: a weighted SH added to a sum.
+ *
+ * ```wgsl
+ * fn sh3_color_add_scaled(a: array<vec3<f32>, 9>, b: array<vec3<f32>, 9>, scale: f32) -> array<vec3<f32>, 9>
+ * ```
+ *
+ * @type {CodeChunk}
+ */
+export const chunk_sh3_color_add_scaled: CodeChunk;
+import { CodeChunk } from "../../compiler/CodeChunk.js";
+//# sourceMappingURL=chunk_sh3_color_add_scaled.d.ts.map

package/src/shade/renderer/shader/chunk/spherical_harmonics/chunk_sh3_color_add_scaled.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"chunk_sh3_color_add_scaled.d.ts","sourceRoot":"","sources":["../../../../../../../src/shade/renderer/shader/chunk/spherical_harmonics/chunk_sh3_color_add_scaled.js"],"names":[],"mappings":"AAEA;;;;;;;;GAQG;AACH,yCAFU,SAAS,CAchB;0BAvBuB,6BAA6B"}

package/src/shade/renderer/shader/chunk/spherical_harmonics/chunk_sh3_color_add_scaled.js

@@ -0,0 +1,24 @@
+import { CodeChunk } from "../../compiler/CodeChunk.js";
+
+/**
+ * `a + b × scale`, coefficient by coefficient: a weighted SH added to a sum.
+ *
+ * ```wgsl
+ * fn sh3_color_add_scaled(a: array<vec3<f32>, 9>, b: array<vec3<f32>, 9>, scale: f32) -> array<vec3<f32>, 9>
+ * ```
+ *
+ * @type {CodeChunk}
+ */
+export const chunk_sh3_color_add_scaled = CodeChunk.from(
+    //language=WGSL
+    `
+fn sh3_color_add_scaled(a: array<vec3<f32>, 9>, b: array<vec3<f32>, 9>, scale: f32) -> array<vec3<f32>, 9> {
+    var out: array<vec3<f32>, 9>;
+
+    for (var i = 0; i < 9; i++) {
+        out[i] = a[i] + b[i] * scale;
+    }
+
+    return out;
+}
+`);

package/src/shade/renderer/volumetrics/irradiance_clipmap/GPUIrradianceClipmap.d.ts

@@ -34,11 +34,11 @@ export class GPUIrradianceClipmap {
     /**
      * @returns {GPUTextureContext}
      */
-    get texture_y(): GPUTextureContext;
+    get texture_y(): import("../../texture/GPUTextureContext.js").GPUTextureContext;
     /**
      * @returns {GPUTextureContext}
      */
-    get texture_cocg(): GPUTextureContext;
+    get texture_cocg(): import("../../texture/GPUTextureContext.js").GPUTextureContext;
     /**
      * @returns {GPUBuffer}
      */
@@ -112,6 +112,7 @@ export class GPUIrradianceClipmap {
     destroy(): void;
     #private;
 }
+export type GPUTextureContext = import("../../texture/GPUTextureContext.js").GPUTextureContext;
 import { GPUTileAtlas3D } from "../../texture/atlas/GPUTileAtlas3D.js";
 import { IrradianceCascadePlacement } from "./IrradianceCascadePlacement.js";
 import { ShaderSwitchSet } from "../../shader/compiler/ShaderSwitchSet.js";

package/src/shade/renderer/volumetrics/irradiance_clipmap/GPUIrradianceClipmap.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"GPUIrradianceClipmap.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/volumetrics/irradiance_clipmap/GPUIrradianceClipmap.js"],"names":[],"mappings":"AA6CA;;;;;;;;;;;;;GAaG;AACH;IA2CI;;;;;;;OAOG;IACH;QAL4B,aAAa,GAA9B,MAAM;QAC6B,UAAU,GAA7C,MAAM,GAAC,UAAU,MAAM,CAAC;QACP,SAAS,GAA1B,MAAM;QACW,WAAW,GAA5B,MAAM;OA+DhB;IAED;;OAEG;IACH,4BAEC;IAED;;OAEG;IACH,mCAEC;IAED;;OAEG;IACH,sCAEC;IAED;;OAEG;IACH,yBAEC;IAED;;OAEG;IACH,4BAEC;IAED;;;OAGG;IACH,0BAEC;IAED;;OAEG;IACH,4CAEC;IAED;;OAEG;IACH,uBAEC;IAED;;;;;;;;OAQG;IACH,oBALW,MAAM,KACN,MAAM,KACN,MAAM,oBACN,eAAe,QAgFzB;IAED;;;;;;;;;;;;;;;;;;;;OAoBG;IACH;QAZsG,KAAK,EAAhG,OAAO,8DAA8D,EAAE,UAAU;QACZ,MAAM,EAA3E,OAAO,kCAAkC,EAAE,gBAAgB;QACO,SAAS,EAA3E,OAAO,gCAAgC,EAAE,eAAe;QACxC,eAAe,EAA/B,MAAM;QACoB,eAAe,GAAzC,eAAe;QACuE,MAAM,GAA5F,OAAO,oDAAoD,EAAE,cAAc;QACkB,GAAG,GAAhG,OAAO,sDAAsD,EAAE,mBAAmB;QACgB,MAAM,EAAxG,OAAO,8DAA8D,EAAE,iBAAiB;QAErE,YAAY;QAC7B;QAAC,CAAC,EAAE,MAAM,CAAC;QAAC,IAAI,EAAE,MAAM,CAAC;QAAC,OAAO,EAAE,MAAM,CAAA;KAAC,CAkJtD;IAED;;OAEG;IACH,gBAQC;;CACJ;+BAxe8B,uCAAuC;2CAe3B,iCAAiC;gCApB5C,0CAA0C"}
+{"version":3,"file":"GPUIrradianceClipmap.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/volumetrics/irradiance_clipmap/GPUIrradianceClipmap.js"],"names":[],"mappings":"AAiDA;;;;;;;;;;;;;GAaG;AACH;IA2CI;;;;;;;OAOG;IACH;QAL4B,aAAa,GAA9B,MAAM;QAC6B,UAAU,GAA7C,MAAM,GAAC,UAAU,MAAM,CAAC;QACP,SAAS,GAA1B,MAAM;QACW,WAAW,GAA5B,MAAM;OA+DhB;IAED;;OAEG;IACH,4BAEC;IAED;;OAEG;IACH,gFAEC;IAED;;OAEG;IACH,mFAEC;IAED;;OAEG;IACH,yBAEC;IAED;;OAEG;IACH,4BAEC;IAED;;;OAGG;IACH,0BAEC;IAED;;OAEG;IACH,4CAEC;IAED;;OAEG;IACH,uBAEC;IAED;;;;;;;;OAQG;IACH,oBALW,MAAM,KACN,MAAM,KACN,MAAM,oBACN,eAAe,QAgFzB;IAED;;;;;;;;;;;;;;;;;;;;OAoBG;IACH;QAZsG,KAAK,EAAhG,OAAO,8DAA8D,EAAE,UAAU;QACZ,MAAM,EAA3E,OAAO,kCAAkC,EAAE,gBAAgB;QACO,SAAS,EAA3E,OAAO,gCAAgC,EAAE,eAAe;QACxC,eAAe,EAA/B,MAAM;QACoB,eAAe,GAAzC,eAAe;QACuE,MAAM,GAA5F,OAAO,oDAAoD,EAAE,cAAc;QACkB,GAAG,GAAhG,OAAO,sDAAsD,EAAE,mBAAmB;QACgB,MAAM,EAAxG,OAAO,8DAA8D,EAAE,iBAAiB;QAErE,YAAY;QAC7B;QAAC,CAAC,EAAE,MAAM,CAAC;QAAC,IAAI,EAAE,MAAM,CAAC;QAAC,OAAO,EAAE,MAAM,CAAA;KAAC,CAkJtD;IAED;;OAEG;IACH,gBAQC;;CACJ;gCAxeY,OAAO,oCAAoC,EAAE,iBAAiB;+BAJ5C,uCAAuC;2CAmB3B,iCAAiC;gCAxB5C,0CAA0C"}

package/src/shade/renderer/volumetrics/irradiance_clipmap/GPUIrradianceClipmap.js

@@ -10,6 +10,10 @@ import { encoder_prepare_shader_bindings_defaults } from "../../shader/resource/
 import { SHADOWMAP_COMPARE_SAMPLER_DESCRIPTOR } from "../../shadow/map/SHADOWMAP_COMPARE_SAMPLER_DESCRIPTOR.js";
 import { GPUTileAtlas3D } from "../../texture/atlas/GPUTileAtlas3D.js";
 import { DEFAULT_RENDER_TARGET_VIEW_DESCRIPTOR } from "../../texture/DEFAULT_RENDER_TARGET_VIEW_DESCRIPTOR.js";
+
+/**
+ * @typedef {import("../../texture/GPUTextureContext.js").GPUTextureContext} GPUTextureContext
+ */
 import {
     IRRADIANCE_CLIPMAP_CASCADE_LIMIT,
     IRRADIANCE_CLIPMAP_DEFAULT_BLEND_SKIRT,

package/src/shade/renderer/volumetrics/irradiance_clipmap/chunk_irradiance_clipmap_gi_sample.d.ts

@@ -20,11 +20,8 @@ export const chunk_irradiance_clipmap_gi_sample_lpv: CodeChunk;
  * voxel is no surface, so there is no normal to bias the point by or to weigh back faces with, nor a view.
  * Where no probe weighs anything, the environment SH, as under IBL.
  *
- * The probes' SH is what the volume accumulates, Metro L1 in the scale under which
- * `resolve_irradiance_sh_to_diffuse` gives E/π. It is handed over as the radiance SH2 that
- * `volumetrics_irradiance_sh_add_radiance` turns back into it: 2π × the luma, band 1 in the basis order
- * (y, z, x), and the chroma, which only the constant band has, over band 0's basis constant. Reads the probes'
- * group, `view` and `environment_sh`.
+ * The probes' SH is radiance SH3, as Brick4's: its bands 0 and 1 are the radiance SH2. Reads the probes' group,
+ * `view` and `environment_sh`.
  * @type {CodeChunk}
  */
 export const chunk_irradiance_clipmap_gi_sample_probe_clipmap: CodeChunk;

package/src/shade/renderer/volumetrics/irradiance_clipmap/chunk_irradiance_clipmap_gi_sample.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"chunk_irradiance_clipmap_gi_sample.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/volumetrics/irradiance_clipmap/chunk_irradiance_clipmap_gi_sample.js"],"names":[],"mappings":"AAaA;;;GAGG;AACH,qDAFU,SAAS,CAcjB;AAIF;;;;GAIG;AACH,wDAFU,SAAS,CAYjB;AAEF;;;GAGG;AACH,qDAFU,SAAS,CAqBjB;AAEF;;;;;;;;;;;;GAYG;AACH,+DAFU,SAAS,CAqCjB;AAIF;;;;;GAKG;AACH,iDAFU,eAAe,CAEiE;0BA3HhE,oCAAoC;gCAC9B,0CAA0C"}
+{"version":3,"file":"chunk_irradiance_clipmap_gi_sample.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/volumetrics/irradiance_clipmap/chunk_irradiance_clipmap_gi_sample.js"],"names":[],"mappings":"AAYA;;;GAGG;AACH,qDAFU,SAAS,CAcjB;AAIF;;;;GAIG;AACH,wDAFU,SAAS,CAYjB;AAEF;;;GAGG;AACH,qDAFU,SAAS,CAqBjB;AAEF;;;;;;;;;GASG;AACH,+DAFU,SAAS,CAwBjB;AAIF;;;;;GAKG;AACH,iDAFU,eAAe,CAEiE;0BA3GhE,oCAAoC;gCAC9B,0CAA0C"}

package/src/shade/renderer/volumetrics/irradiance_clipmap/chunk_irradiance_clipmap_gi_sample.js

@@ -1,7 +1,6 @@
 import { chunk_brick4_sample_sh } from "../../global_illumination/brick4/gpu/draw/chunk_brick4_sample_sh.js";
 import { chunk_probe_clipmap_pick } from "../../global_illumination/probe_clipmap/probe/chunk_probe_clipmap_pick.js";
 import { INDIRECT_LIGHTING } from "../../INDIRECT_LIGHTING.js";
-import { chunk_YCoCg_to_rgb } from "../../shader/chunk/color/YCoCg/chunk_YCoCg_to_rgb.js";
 import { chunk_jitter_from_vectors } from "../../shader/chunk/random/chunk_jitter_from_vectors.js";
 import { ENVIRONMENT_SH_RESOURCE } from "../../light/environment/ENVIRONMENT_SH_RESOURCE.js";
 import { ShadeIndirectLightingMode } from "../../ShadeIndirectLightingMode.js";
@@ -79,11 +78,8 @@ fn irradiance_clipmap_gi_sample(position_ws: vec3<f32>) -> array<vec3<f32>, 4> {
  * voxel is no surface, so there is no normal to bias the point by or to weigh back faces with, nor a view.
  * Where no probe weighs anything, the environment SH, as under IBL.
  *
- * The probes' SH is what the volume accumulates, Metro L1 in the scale under which
- * `resolve_irradiance_sh_to_diffuse` gives E/π. It is handed over as the radiance SH2 that
- * `volumetrics_irradiance_sh_add_radiance` turns back into it: 2π × the luma, band 1 in the basis order
- * (y, z, x), and the chroma, which only the constant band has, over band 0's basis constant. Reads the probes'
- * group, `view` and `environment_sh`.
+ * The probes' SH is radiance SH3, as Brick4's: its bands 0 and 1 are the radiance SH2. Reads the probes' group,
+ * `view` and `environment_sh`.
  * @type {CodeChunk}
  */
 export const chunk_irradiance_clipmap_gi_sample_probe_clipmap = CodeChunk.from(
@@ -102,24 +98,11 @@ fn irradiance_clipmap_gi_sample(position_ws: vec3<f32>) -> array<vec3<f32>, 4> {
         );
     }
 
-    // the inverse of volumetrics_irradiance_sh_add_radiance's 1 / (2 pi) and of its chroma's 1 / band 0
-    const TWO_PI: f32 = 6.283185307179586;
-    const BAND_0_BASIS: f32 = 0.28209479177387814;
-
-    let Y = probes.sh.Y * TWO_PI;
-
-    // the Metro layout is (x, y, z, constant); the basis order is (constant, y, z, x)
-    return array<vec3<f32>, 4>(
-        YCoCg_to_rgb(vec3<f32>(Y.w, probes.sh.CoCg * (BAND_0_BASIS * TWO_PI))),
-        vec3<f32>(Y.y),
-        vec3<f32>(Y.z),
-        vec3<f32>(Y.x),
-    );
+    return array<vec3<f32>, 4>(probes.sh[0], probes.sh[1], probes.sh[2], probes.sh[3]);
 }
 `, [
         chunk_probe_clipmap_pick,
         chunk_jitter_from_vectors,
-        chunk_YCoCg_to_rgb,
     ]
 );
 

package/src/shade/renderer/water/chunk_water_gi.d.ts

@@ -12,7 +12,7 @@ export const chunk_water_gi_ibl: CodeChunk;
 export const chunk_water_gi_brick4: CodeChunk;
 /**
  * The probe clipmap (PROBE_CLIPMAP_PROPOSAL_2026_10_27.md §9.5): each call one pick at the point, jittered by a
- * hash of the point and the normal, as Brick4's is. The irradiance is π × the picked SH resolved at the normal,
+ * hash of the point and the normal, as Brick4's is. The irradiance is the picked SH resolved at the normal,
  * the normal standing in for the view, which the irradiance call has none of. The specular is the probes'
  * radiance picked by the normal and the view (§9.3). Where no probe weighs anything, each is the environment's.
  * Reads the probes' group, `view` and `tEnvironment`.

package/src/shade/renderer/water/chunk_water_gi.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"chunk_water_gi.d.ts","sourceRoot":"","sources":["../../../../../src/shade/renderer/water/chunk_water_gi.js"],"names":[],"mappings":"AAiCA;;;;GAIG;AACH,iCAFU,SAAS,CAUoC;AAEvD;;;;GAIG;AACH,oCAFU,SAAS,CAgBwB;AAE3C;;;;;;;GAOG;AACH,2CAFU,SAAS,CAwB+E;AAElG;;;;;;GAMG;AACH,6BAFU,eAAe,CAE6C;0BA5F5C,iCAAiC;gCAC3B,uCAAuC"}
+{"version":3,"file":"chunk_water_gi.d.ts","sourceRoot":"","sources":["../../../../../src/shade/renderer/water/chunk_water_gi.js"],"names":[],"mappings":"AAgCA;;;;GAIG;AACH,iCAFU,SAAS,CAUoC;AAEvD;;;;GAIG;AACH,oCAFU,SAAS,CAgBwB;AAE3C;;;;;;;GAOG;AACH,2CAFU,SAAS,CAuB+D;AAElF;;;;;;GAMG;AACH,6BAFU,eAAe,CAE6C;0BA3F5C,iCAAiC;gCAC3B,uCAAuC"}

package/src/shade/renderer/water/chunk_water_gi.js

@@ -9,11 +9,10 @@ import {
 } from "../global_illumination/probe_clipmap/probe/chunk_probe_clipmap_sample_radiance.js";
 import { INDIRECT_LIGHTING } from "../INDIRECT_LIGHTING.js";
 import { ShadeIndirectLightingMode } from "../ShadeIndirectLightingMode.js";
-import { PI_DECLARATION } from "../shader/chunk/math/PI_DECLARATION.js";
 import { chunk_jitter_from_vectors } from "../shader/chunk/random/chunk_jitter_from_vectors.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 { CodeChunkChoice } from "../shader/compiler/CodeChunkChoice.js";
 
@@ -69,7 +68,7 @@ fn water_gi_specular(position: vec3<f32>, normal: vec3<f32>, view_direction: vec
 
 /**
  * The probe clipmap (PROBE_CLIPMAP_PROPOSAL_2026_10_27.md §9.5): each call one pick at the point, jittered by a
- * hash of the point and the normal, as Brick4's is. The irradiance is π × the picked SH resolved at the normal,
+ * hash of the point and the normal, as Brick4's is. The irradiance is the picked SH resolved at the normal,
  * the normal standing in for the view, which the irradiance call has none of. The specular is the probes'
  * radiance picked by the normal and the view (§9.3). Where no probe weighs anything, each is the environment's.
  * Reads the probes' group, `view` and `tEnvironment`.
@@ -80,8 +79,7 @@ fn water_gi_irradiance(position: vec3<f32>, normal: vec3<f32>) -> vec3<f32> {
     let probes = probe_clipmap_sample_sh(position, normal, normal, jitter_from_vectors(position, normal));
 
     if (probes.found) {
-        // the resolve gives E/π
-        return PI * resolve_irradiance_sh_to_diffuse(probes.sh.Y, probes.sh.CoCg, normal);
+        return sh3_color_get_irradiance_at(normal, probes.sh);
     }
 
     return get_ibl_irradiance(normal);
@@ -96,8 +94,8 @@ fn water_gi_specular(position: vec3<f32>, normal: vec3<f32>, view_direction: vec
 
     return get_ibl_radiance(view_direction, normal, roughness);
 }
-`, [chunk_probe_clipmap_pick, chunk_probe_clipmap_sample_radiance, chunk_resolve_irradiance_sh_to_diffuse,
-    chunk_jitter_from_vectors, PI_DECLARATION, chunk_get_ibl_irradiance, chunk_get_ibl_radiance]);
+`, [chunk_probe_clipmap_pick, chunk_probe_clipmap_sample_radiance, chunk_sh3_color_get_irradiance_at,
+    chunk_jitter_from_vectors, chunk_get_ibl_irradiance, chunk_get_ibl_radiance]);
 
 /**
  * The water's indirect lighting by the renderer's mode ({@link INDIRECT_LIGHTING}): IBL and LPV

package/src/shade/wgsl/emulator/WGSLLanguageCore.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"WGSLLanguageCore.d.ts","sourceRoot":"","sources":["../../../../../src/shade/wgsl/emulator/WGSLLanguageCore.js"],"names":[],"mappings":";IAs3DA;;;;;;;;;;;;;OAaG;IACH,+DAyFC"}
+{"version":3,"file":"WGSLLanguageCore.d.ts","sourceRoot":"","sources":["../../../../../src/shade/wgsl/emulator/WGSLLanguageCore.js"],"names":[],"mappings":";IAk6DA;;;;;;;;;;;;;OAaG;IACH,+DAyFC"}

package/src/shade/wgsl/emulator/WGSLLanguageCore.js

@@ -99,11 +99,26 @@ const BITCAST_F16 = new Float16Array(BITCAST_BUFFER);
  * @returns {*}
  */
 function makeVec(TypedArrayCtor, size, args) {
-    if (args.length === 0) {
+    const n = args.length;
+    if (n === 0) {
         return new TypedArrayCtor(size);
     }
+    if (n === size && typeof args[0] === 'number') {
+        let all_num = true;
+        for (let k = 1; k < n; k++) {
+            if (typeof args[k] !== 'number') {
+                all_num = false;
+                break;
+            }
+        }
+        if (all_num) {
+            const out = new TypedArrayCtor(size);
+            for (let k = 0; k < size; k++) out[k] = args[k];
+            return out;
+        }
+    }
     // Single scalar → broadcast.
-    if (args.length === 1 && typeof args[0] === 'number') {
+    if (n === 1 && typeof args[0] === 'number') {
         const v = args[0];
         const out = new TypedArrayCtor(size);
         for (let i = 0; i < size; i++) out[i] = v;
@@ -112,7 +127,8 @@ function makeVec(TypedArrayCtor, size, args) {
     // Otherwise flatten.
     const out = new TypedArrayCtor(size);
     let i = 0;
-    for (const a of args) {
+    for (let k = 0; k < n; k++) {
+        const a = args[k];
         if (typeof a === 'number' || typeof a === 'boolean') {
             out[i++] = +a;
         } else if (a != null && typeof a.length === 'number') {
@@ -213,7 +229,31 @@ function is_vec(v) {
  * @param {function(number, number): number} op
  * @returns {*}
  */
+const op_add = (x, y) => x + y;
+const op_sub = (x, y) => x - y;
+const op_mul = (x, y) => x * y;
+const op_div = (x, y) => x / y;
+const op_add_f32 = (x, y) => Math.fround(x + y);
+const op_sub_f32 = (x, y) => Math.fround(x - y);
+const op_mul_f32 = (x, y) => Math.fround(x * y);
+const op_div_f32 = (x, y) => Math.fround(x / y);
+const op_add_f16 = (x, y) => round_f16(x + y);
+const op_sub_f16 = (x, y) => round_f16(x - y);
+const op_mul_f16 = (x, y) => round_f16(x * y);
+const op_div_f16 = (x, y) => round_f16(x / y);
+const op_rem = (x, y) => x % y;
+const op_idiv = (x, y) => Math.trunc(x / y);
+const op_add_u32 = (x, y) => (x + y) >>> 0;
+const op_sub_u32 = (x, y) => (x - y) >>> 0;
+const op_mul_u32 = (x, y) => Math.imul(x, y) >>> 0;
+const op_add_i32 = (x, y) => (x + y) | 0;
+const op_sub_i32 = (x, y) => (x - y) | 0;
+const op_mul_i32 = (x, y) => Math.imul(x, y) | 0;
+
 function binop(a, b, op) {
+    if (typeof a === "number" && typeof b === "number") {
+        return op(a, b);
+    }
     const a_vec = is_vec(a);
     const b_vec = is_vec(b);
 
@@ -302,7 +342,7 @@ function round_ties_to_even(x) {
 }
 
 function unop(a, op) {
-    if (!is_vec(a)) {
+    if (typeof a === "number" || !is_vec(a)) {
         return op(a);
     }
     const out = new a.constructor(a.length);
@@ -321,15 +361,15 @@ function unop(a, op) {
  * @returns {*}
  */
 function ternop(a, b, c, op) {
-    if (is_vec(a) || is_vec(b) || is_vec(c)) {
-        const length = (is_vec(a) ? a.length : (is_vec(b) ? b.length : c.length));
-        const ctor = (is_vec(a) ? a.constructor : (is_vec(b) ? b.constructor : c.constructor));
-        const out = new ctor(length);
+    const a_vec = is_vec(a);
+    const b_vec = is_vec(b);
+    const c_vec = is_vec(c);
+    if (a_vec || b_vec || c_vec) {
+        const ref = a_vec ? a : (b_vec ? b : c);
+        const length = ref.length;
+        const out = new ref.constructor(length);
         for (let i = 0; i < length; i++) {
-            const ai = is_vec(a) ? a[i] : a;
-            const bi = is_vec(b) ? b[i] : b;
-            const ci = is_vec(c) ? c[i] : c;
-            out[i] = op(ai, bi, ci);
+            out[i] = op(a_vec ? a[i] : a, b_vec ? b[i] : b, c_vec ? c[i] : c);
         }
         return out;
     }
@@ -358,6 +398,10 @@ function ternop(a, b, c, op) {
  * @returns {*}
  */
 function copy_value(value) {
+    if (typeof value !== "object" || value === null) {
+        return value;
+    }
+
     if (ArrayBuffer.isView(value)) {
         return value.slice();
     }
@@ -606,10 +650,10 @@ export const WGSLLanguageCore = {
     // Arithmetic helpers (work on scalars and vectors element-wise)
     // ---------------------------------------------------------------------
 
-    add: (a, b) => binop(a, b, (x, y) => x + y),
-    sub: (a, b) => binop(a, b, (x, y) => x - y),
-    mul: (a, b) => binop(a, b, (x, y) => x * y),
-    div: (a, b) => binop(a, b, (x, y) => x / y),
+    add: (a, b) => typeof a === "number" && typeof b === "number" ? a + b : binop(a, b, op_add),
+    sub: (a, b) => typeof a === "number" && typeof b === "number" ? a - b : binop(a, b, op_sub),
+    mul: (a, b) => typeof a === "number" && typeof b === "number" ? a * b : binop(a, b, op_mul),
+    div: (a, b) => typeof a === "number" && typeof b === "number" ? a / b : binop(a, b, op_div),
 
     /*
      The same four at f32, for a SCALAR whose type the compiler knows is f32.
@@ -632,23 +676,23 @@ export const WGSLLanguageCore = {
      runtime. `Math.fround` of a vector is NaN, and binop is already idempotent here: a vec lane is
      rounded and then stored into the Float32Array that would have rounded it anyway.
     */
-    add_f32: (a, b) => binop(a, b, (x, y) => Math.fround(x + y)),
-    sub_f32: (a, b) => binop(a, b, (x, y) => Math.fround(x - y)),
-    mul_f32: (a, b) => binop(a, b, (x, y) => Math.fround(x * y)),
-    div_f32: (a, b) => binop(a, b, (x, y) => Math.fround(x / y)),
+    add_f32: (a, b) => typeof a === "number" && typeof b === "number" ? Math.fround(a + b) : binop(a, b, op_add_f32),
+    sub_f32: (a, b) => typeof a === "number" && typeof b === "number" ? Math.fround(a - b) : binop(a, b, op_sub_f32),
+    mul_f32: (a, b) => typeof a === "number" && typeof b === "number" ? Math.fround(a * b) : binop(a, b, op_mul_f32),
+    div_f32: (a, b) => typeof a === "number" && typeof b === "number" ? Math.fround(a / b) : binop(a, b, op_div_f32),
 
     // The same four at f16, for a SCALAR whose type the compiler knows is f16. Without these,
     // scalar f16 arithmetic ran in f64 (`16000.0h * 8.0h` evaluated to 128000 instead of +Infinity,
     // and `1e-3h * 1e-3h` evaluated to 1e-6 instead of underflowing in binary16).
-    add_f16: (a, b) => binop(a, b, (x, y) => round_f16(x + y)),
-    sub_f16: (a, b) => binop(a, b, (x, y) => round_f16(x - y)),
-    mul_f16: (a, b) => binop(a, b, (x, y) => round_f16(x * y)),
-    div_f16: (a, b) => binop(a, b, (x, y) => round_f16(x / y)),
-    rem: (a, b) => binop(a, b, (x, y) => x % y),
+    add_f16: (a, b) => typeof a === "number" && typeof b === "number" ? round_f16(a + b) : binop(a, b, op_add_f16),
+    sub_f16: (a, b) => typeof a === "number" && typeof b === "number" ? round_f16(a - b) : binop(a, b, op_sub_f16),
+    mul_f16: (a, b) => typeof a === "number" && typeof b === "number" ? round_f16(a * b) : binop(a, b, op_mul_f16),
+    div_f16: (a, b) => typeof a === "number" && typeof b === "number" ? round_f16(a / b) : binop(a, b, op_div_f16),
+    rem: (a, b) => typeof a === "number" && typeof b === "number" ? a % b : binop(a, b, op_rem),
 
     // Integer division — truncates toward zero, matching WGSL `/` semantics on integer types.
     // The compiler routes `/` through `idiv` when both operands' tracked types are integer.
-    idiv: (a, b) => binop(a, b, (x, y) => Math.trunc(x / y)),
+    idiv: (a, b) => typeof a === "number" && typeof b === "number" ? Math.trunc(a / b) : binop(a, b, op_idiv),
 
     // WGSL integer arithmetic wraps at 32 bits; JS numbers grow instead. Without wrapping, any
     // hash or PRNG that multiplies by a large odd constant leaves the u32 range within a step or
@@ -658,13 +702,13 @@ export const WGSLLanguageCore = {
     //
     // The compiler routes `+` / `-` / `*` here only when the result type is known to be an integer,
     // so float math never reaches these.
-    add_u32: (a, b) => binop(a, b, (x, y) => (x + y) >>> 0),
-    sub_u32: (a, b) => binop(a, b, (x, y) => (x - y) >>> 0),
-    mul_u32: (a, b) => binop(a, b, (x, y) => Math.imul(x, y) >>> 0),
+    add_u32: (a, b) => typeof a === "number" && typeof b === "number" ? (a + b) >>> 0 : binop(a, b, op_add_u32),
+    sub_u32: (a, b) => typeof a === "number" && typeof b === "number" ? (a - b) >>> 0 : binop(a, b, op_sub_u32),
+    mul_u32: (a, b) => typeof a === "number" && typeof b === "number" ? Math.imul(a, b) >>> 0 : binop(a, b, op_mul_u32),
 
-    add_i32: (a, b) => binop(a, b, (x, y) => (x + y) | 0),
-    sub_i32: (a, b) => binop(a, b, (x, y) => (x - y) | 0),
-    mul_i32: (a, b) => binop(a, b, (x, y) => Math.imul(x, y) | 0),
+    add_i32: (a, b) => typeof a === "number" && typeof b === "number" ? (a + b) | 0 : binop(a, b, op_add_i32),
+    sub_i32: (a, b) => typeof a === "number" && typeof b === "number" ? (a - b) | 0 : binop(a, b, op_sub_i32),
+    mul_i32: (a, b) => typeof a === "number" && typeof b === "number" ? Math.imul(a, b) | 0 : binop(a, b, op_mul_i32),
 
     // Element-wise bitwise / shift helpers. JS's raw `&` / `|` / `^` / `<<` / `>>` work on
     // scalars but not typed arrays (they coerce the array to a number → NaN), so the compiler

package/src/core/math/hash/squirrel3.d.ts

@@ -1,17 +0,0 @@
-/**
- * Based on Squirrel3 hash function by Squirrel Eiserloh
- *
- * NOTE: every step is wrapping u32 arithmetic, matching the WGSL twin `chunk_hash_squirrel3` bit
- * for bit. This used to multiply with plain `*`, which is a double multiply - `hash * 0x1B56C4E9`
- * exceeds 2^53 for any int32-sized hash, so the low bits the following `hash ^= hash >> 8` mixes
- * were rounded away before they were used. The result set bit 31 in exactly zero of 200,000
- * outputs, half the codomain unreachable, and disagreed with the GPU on every value. An in-file
- * comment used to blame the algorithm for the resulting low entropy; it was this port.
- *
- * @deprecated prefer {@link lowbias32}, as the WGSL chunk already says of its own twin
- * @see GDC 2017 presentation on "Math for Game Programmers: Noise-Based RNG"
- * @param {number} value expected to be an integer, if not - it will be truncated to such
- * @returns {number} unsigned 32-bit integer
- */
-export function squirrel3(value: number): number;
-//# sourceMappingURL=squirrel3.d.ts.map

package/src/core/math/hash/squirrel3.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"squirrel3.d.ts","sourceRoot":"","sources":["../../../../../src/core/math/hash/squirrel3.js"],"names":[],"mappings":"AAIA;;;;;;;;;;;;;;GAcG;AACH,iCAHW,MAAM,GACJ,MAAM,CAYlB"}