@woosh/meep-engine 3.61.1 → 3.61.3

package/src/shade/renderer/shader/chunk/material/albedo_compress.js

@@ -0,0 +1,26 @@
+import { clamp01 } from "../../../../../core/math/clamp01.js";
+
+/**
+ * The code `albedo_compress` (`chunk_albedo_compress.js`) gives an albedo, on the host: each channel
+ * clamped to [0, 1], its square root rounded to f32 and then to unorm8, as `pack4x8unorm` rounds, the
+ * top byte 255.
+ *
+ * @param {number} r linear
+ * @param {number} g linear
+ * @param {number} b linear
+ * @returns {number} u32
+ */
+export function albedo_compress(r, g, b) {
+    return (unorm8_root(r) | (unorm8_root(g) << 8) | (unorm8_root(b) << 16) | (255 << 24)) >>> 0;
+}
+
+/**
+ * @param {number} v
+ * @returns {number}
+ */
+function unorm8_root(v) {
+    const root = Math.fround(Math.sqrt(Math.fround(clamp01(Math.fround(v)))));
+
+    // ⌊0.5 + 255·e⌋ of the f32 e, which a double holds exactly
+    return Math.floor(0.5 + 255 * root);
+}

package/src/shade/renderer/shader/chunk/material/chunk_albedo_compress.d.ts

@@ -0,0 +1,16 @@
+/**
+ * A diffuse albedo, RGB on [0, 1], in a 32-bit code, as `albedo_uncompress` reads it:
+ *
+ * ```wgsl
+ * fn albedo_compress(albedo: vec3<f32>) -> u32
+ * ```
+ *
+ * Each channel is clamped to [0, 1] and stored as its square root, unorm8, which puts more codes in the
+ * dark. The top byte is 255, so a code is never 0, black
+ * included: a reader may take 0 for no albedo at all.
+ *
+ * @type {CodeChunk}
+ */
+export const chunk_albedo_compress: CodeChunk;
+import { CodeChunk } from "../../compiler/CodeChunk.js";
+//# sourceMappingURL=chunk_albedo_compress.d.ts.map

package/src/shade/renderer/shader/chunk/material/chunk_albedo_compress.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"chunk_albedo_compress.d.ts","sourceRoot":"","sources":["../../../../../../../src/shade/renderer/shader/chunk/material/chunk_albedo_compress.js"],"names":[],"mappings":"AAEA;;;;;;;;;;;;GAYG;AACH,oCAFU,SAAS,CAQhB;0BArBuB,6BAA6B"}

package/src/shade/renderer/shader/chunk/material/chunk_albedo_compress.js

@@ -0,0 +1,22 @@
+import { CodeChunk } from "../../compiler/CodeChunk.js";
+
+/**
+ * A diffuse albedo, RGB on [0, 1], in a 32-bit code, as `albedo_uncompress` reads it:
+ *
+ * ```wgsl
+ * fn albedo_compress(albedo: vec3<f32>) -> u32
+ * ```
+ *
+ * Each channel is clamped to [0, 1] and stored as its square root, unorm8, which puts more codes in the
+ * dark. The top byte is 255, so a code is never 0, black
+ * included: a reader may take 0 for no albedo at all.
+ *
+ * @type {CodeChunk}
+ */
+export const chunk_albedo_compress = CodeChunk.from(
+    //language=WGSL
+    `
+fn albedo_compress(albedo: vec3<f32>) -> u32 {
+    return pack4x8unorm(vec4<f32>(sqrt(saturate(albedo)), 1.0));
+}
+`);

package/src/shade/renderer/shader/chunk/material/chunk_albedo_uncompress.d.ts

@@ -0,0 +1,15 @@
+/**
+ * A diffuse albedo from the code `albedo_compress` wrote:
+ *
+ * ```wgsl
+ * fn albedo_uncompress(code: u32) -> vec3<f32> // RGB on [0, 1]
+ * ```
+ *
+ * The code's low three bytes are the square roots of R, G and B, unorm8; its top byte is 255 for every
+ * albedo.
+ *
+ * @type {CodeChunk}
+ */
+export const chunk_albedo_uncompress: CodeChunk;
+import { CodeChunk } from "../../compiler/CodeChunk.js";
+//# sourceMappingURL=chunk_albedo_uncompress.d.ts.map

package/src/shade/renderer/shader/chunk/material/chunk_albedo_uncompress.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"chunk_albedo_uncompress.d.ts","sourceRoot":"","sources":["../../../../../../../src/shade/renderer/shader/chunk/material/chunk_albedo_uncompress.js"],"names":[],"mappings":"AAEA;;;;;;;;;;;GAWG;AACH,sCAFU,SAAS,CAUhB;0BAtBuB,6BAA6B"}

package/src/shade/renderer/shader/chunk/material/chunk_albedo_uncompress.js

@@ -0,0 +1,23 @@
+import { CodeChunk } from "../../compiler/CodeChunk.js";
+
+/**
+ * A diffuse albedo from the code `albedo_compress` wrote:
+ *
+ * ```wgsl
+ * fn albedo_uncompress(code: u32) -> vec3<f32> // RGB on [0, 1]
+ * ```
+ *
+ * The code's low three bytes are the square roots of R, G and B, unorm8; its top byte is 255 for every
+ * albedo.
+ *
+ * @type {CodeChunk}
+ */
+export const chunk_albedo_uncompress = CodeChunk.from(
+    //language=WGSL
+    `
+fn albedo_uncompress(code: u32) -> vec3<f32> {
+    let root = unpack4x8unorm(code).rgb;
+
+    return root * root;
+}
+`);

package/src/shade/renderer/shader/chunk/material/chunk_metal_rough_compress.d.ts

@@ -0,0 +1,16 @@
+/**
+ * Metalness and roughness, each on [0, 1], in a code of `METAL_ROUGH_CODE_BITS` bits, as
+ * `metal_rough_uncompress` reads it:
+ *
+ * ```wgsl
+ * fn metal_rough_compress(metal_rough: vec2<f32>) -> u32 // (metalness, roughness)
+ * ```
+ *
+ * Each is clamped to [0, 1] and rounded to the nearest of 2^{@link METAL_ROUGH_CHANNEL_BITS} even
+ * steps, metalness in the low bits.
+ *
+ * @type {CodeChunk}
+ */
+export const chunk_metal_rough_compress: CodeChunk;
+import { CodeChunk } from "../../compiler/CodeChunk.js";
+//# sourceMappingURL=chunk_metal_rough_compress.d.ts.map

package/src/shade/renderer/shader/chunk/material/chunk_metal_rough_compress.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"chunk_metal_rough_compress.d.ts","sourceRoot":"","sources":["../../../../../../../src/shade/renderer/shader/chunk/material/chunk_metal_rough_compress.js"],"names":[],"mappings":"AAGA;;;;;;;;;;;;GAYG;AACH,yCAFU,SAAS,CAUhB;0BAxBuB,6BAA6B"}

package/src/shade/renderer/shader/chunk/material/chunk_metal_rough_compress.js

@@ -0,0 +1,25 @@
+import { CodeChunk } from "../../compiler/CodeChunk.js";
+import { METAL_ROUGH_CHANNEL_BITS } from "./chunk_metal_rough_uncompress.js";
+
+/**
+ * Metalness and roughness, each on [0, 1], in a code of `METAL_ROUGH_CODE_BITS` bits, as
+ * `metal_rough_uncompress` reads it:
+ *
+ * ```wgsl
+ * fn metal_rough_compress(metal_rough: vec2<f32>) -> u32 // (metalness, roughness)
+ * ```
+ *
+ * Each is clamped to [0, 1] and rounded to the nearest of 2^{@link METAL_ROUGH_CHANNEL_BITS} even
+ * steps, metalness in the low bits.
+ *
+ * @type {CodeChunk}
+ */
+export const chunk_metal_rough_compress = CodeChunk.from(
+    //language=WGSL
+    `
+fn metal_rough_compress(metal_rough: vec2<f32>) -> u32 {
+    let q = vec2<u32>(round(saturate(metal_rough) * ${2 ** METAL_ROUGH_CHANNEL_BITS - 1}.0));
+
+    return q.x | (q.y << ${METAL_ROUGH_CHANNEL_BITS}u);
+}
+`);

package/src/shade/renderer/shader/chunk/material/chunk_metal_rough_uncompress.d.ts

@@ -0,0 +1,25 @@
+/**
+ * Bits of each of metalness and roughness in a `metal_rough_compress` code.
+ * @type {number}
+ */
+export const METAL_ROUGH_CHANNEL_BITS: number;
+/**
+ * Bits of a `metal_rough_compress` code: metalness, then roughness.
+ * @type {number}
+ */
+export const METAL_ROUGH_CODE_BITS: number;
+/**
+ * Metalness and roughness from the code `metal_rough_compress` wrote:
+ *
+ * ```wgsl
+ * fn metal_rough_uncompress(code: u32) -> vec2<f32> // (metalness, roughness), on [0, 1]
+ * ```
+ *
+ * The code's low {@link METAL_ROUGH_CHANNEL_BITS} bits are the metalness and the next as many the
+ * roughness, each unorm. Bits past {@link METAL_ROUGH_CODE_BITS} are ignored.
+ *
+ * @type {CodeChunk}
+ */
+export const chunk_metal_rough_uncompress: CodeChunk;
+import { CodeChunk } from "../../compiler/CodeChunk.js";
+//# sourceMappingURL=chunk_metal_rough_uncompress.d.ts.map

package/src/shade/renderer/shader/chunk/material/chunk_metal_rough_uncompress.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"chunk_metal_rough_uncompress.d.ts","sourceRoot":"","sources":["../../../../../../../src/shade/renderer/shader/chunk/material/chunk_metal_rough_uncompress.js"],"names":[],"mappings":"AAEA;;;GAGG;AACH,uCAFU,MAAM,CAE0B;AAE1C;;;GAGG;AACH,oCAFU,MAAM,CAEkD;AAElE;;;;;;;;;;;GAWG;AACH,2CAFU,SAAS,CAWhB;0BAnCuB,6BAA6B"}

package/src/shade/renderer/shader/chunk/material/chunk_metal_rough_uncompress.js

@@ -0,0 +1,36 @@
+import { CodeChunk } from "../../compiler/CodeChunk.js";
+
+/**
+ * Bits of each of metalness and roughness in a `metal_rough_compress` code.
+ * @type {number}
+ */
+export const METAL_ROUGH_CHANNEL_BITS = 4;
+
+/**
+ * Bits of a `metal_rough_compress` code: metalness, then roughness.
+ * @type {number}
+ */
+export const METAL_ROUGH_CODE_BITS = 2 * METAL_ROUGH_CHANNEL_BITS;
+
+/**
+ * Metalness and roughness from the code `metal_rough_compress` wrote:
+ *
+ * ```wgsl
+ * fn metal_rough_uncompress(code: u32) -> vec2<f32> // (metalness, roughness), on [0, 1]
+ * ```
+ *
+ * The code's low {@link METAL_ROUGH_CHANNEL_BITS} bits are the metalness and the next as many the
+ * roughness, each unorm. Bits past {@link METAL_ROUGH_CODE_BITS} are ignored.
+ *
+ * @type {CodeChunk}
+ */
+export const chunk_metal_rough_uncompress = CodeChunk.from(
+    //language=WGSL
+    `
+fn metal_rough_uncompress(code: u32) -> vec2<f32> {
+    return vec2<f32>(
+        f32(extractBits(code, 0u, ${METAL_ROUGH_CHANNEL_BITS}u)),
+        f32(extractBits(code, ${METAL_ROUGH_CHANNEL_BITS}u, ${METAL_ROUGH_CHANNEL_BITS}u))
+    ) / ${2 ** METAL_ROUGH_CHANNEL_BITS - 1}.0;
+}
+`);

package/src/shade/renderer/shader/chunk/material/metal_rough_compress.d.ts

@@ -0,0 +1,11 @@
+/**
+ * The code `metal_rough_compress` (`chunk_metal_rough_compress.js`) gives a metalness and roughness, on
+ * the host: each clamped to [0, 1], scaled to its steps in f32 and rounded half to even, as WGSL's
+ * `round` does.
+ *
+ * @param {number} metalness
+ * @param {number} roughness
+ * @returns {number} the code, {@link METAL_ROUGH_CHANNEL_BITS} bits each, metalness low
+ */
+export function metal_rough_compress(metalness: number, roughness: number): number;
+//# sourceMappingURL=metal_rough_compress.d.ts.map

package/src/shade/renderer/shader/chunk/material/metal_rough_compress.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"metal_rough_compress.d.ts","sourceRoot":"","sources":["../../../../../../../src/shade/renderer/shader/chunk/material/metal_rough_compress.js"],"names":[],"mappings":"AAKA;;;;;;;;GAQG;AACH,gDAJW,MAAM,aACN,MAAM,GACJ,MAAM,CAIlB"}

package/src/shade/renderer/shader/chunk/material/metal_rough_compress.js

@@ -0,0 +1,38 @@
+import { clamp01 } from "../../../../../core/math/clamp01.js";
+import { METAL_ROUGH_CHANNEL_BITS } from "./chunk_metal_rough_uncompress.js";
+
+const STEPS = 2 ** METAL_ROUGH_CHANNEL_BITS - 1;
+
+/**
+ * The code `metal_rough_compress` (`chunk_metal_rough_compress.js`) gives a metalness and roughness, on
+ * the host: each clamped to [0, 1], scaled to its steps in f32 and rounded half to even, as WGSL's
+ * `round` does.
+ *
+ * @param {number} metalness
+ * @param {number} roughness
+ * @returns {number} the code, {@link METAL_ROUGH_CHANNEL_BITS} bits each, metalness low
+ */
+export function metal_rough_compress(metalness, roughness) {
+    return step(metalness) | (step(roughness) << METAL_ROUGH_CHANNEL_BITS);
+}
+
+/**
+ * @param {number} v
+ * @returns {number}
+ */
+function step(v) {
+    const scaled = Math.fround(Math.fround(clamp01(Math.fround(v))) * STEPS);
+    const floor = Math.floor(scaled);
+    const fraction = scaled - floor;
+
+    if (fraction > 0.5) {
+        return floor + 1;
+    }
+
+    if (fraction < 0.5) {
+        return floor;
+    }
+
+    // halfway: to the even one
+    return floor % 2 === 0 ? floor : floor + 1;
+}

package/src/shade/renderer/shader/chunk/noise/chunk_sobol_sample_vec2.d.ts

@@ -0,0 +1,40 @@
+/**
+ * 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;
+import { CodeChunk } from "../../compiler/CodeChunk.js";
+//# sourceMappingURL=chunk_sobol_sample_vec2.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"chunk_sobol_sample_vec2.d.ts","sourceRoot":"","sources":["../../../../../../../src/shade/renderer/shader/chunk/noise/chunk_sobol_sample_vec2.js"],"names":[],"mappings":"AAKA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAoCG;AACH,sCAFU,SAAS,CAkClB;0BA1EyB,6BAA6B"}

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/shader/chunk/spherical_harmonics/pivot/chunk_sh2_color_pivot.d.ts

@@ -0,0 +1,20 @@
+/**
+ * An RGB SH2 (L1) function of a unit normal written about a pivot normal, and its evaluation:
+ *
+ * ```wgsl
+ * struct Sh2ColorPivot { value: vec3<f32>, gradient: mat3x3<f32>, pivot: vec3<f32> }
+ * fn sh2_color_pivot_evaluate(f: Sh2ColorPivot, n: vec3<f32>) -> vec3<f32> // value + gradient · (n − pivot)
+ * ```
+ *
+ * Any L1 function on the sphere is affine in the normal, c₀ + c·n, so this is the same function space as
+ * band 0 and band 1 of SH. Writing it about a pivot near the normals it was fitted on puts a real value
+ * in `value`, the function at the pivot, where band 0 is the function's mean over the whole sphere. A
+ * one-sided fit's mean can lie far outside the range its values take on the fitted side.
+ *
+ * `gradient`'s column `a` is the RGB derivative along normal axis `a`.
+ *
+ * @type {CodeChunk}
+ */
+export const chunk_sh2_color_pivot: CodeChunk;
+import { CodeChunk } from "../../../compiler/CodeChunk.js";
+//# sourceMappingURL=chunk_sh2_color_pivot.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"chunk_sh2_color_pivot.d.ts","sourceRoot":"","sources":["../../../../../../../../src/shade/renderer/shader/chunk/spherical_harmonics/pivot/chunk_sh2_color_pivot.js"],"names":[],"mappings":"AAEA;;;;;;;;;;;;;;;;GAgBG;AACH,oCAFU,SAAS,CAiBhB;0BAlCuB,gCAAgC"}

package/src/shade/renderer/shader/chunk/spherical_harmonics/pivot/chunk_sh2_color_pivot.js

@@ -0,0 +1,35 @@
+import { CodeChunk } from "../../../compiler/CodeChunk.js";
+
+/**
+ * An RGB SH2 (L1) function of a unit normal written about a pivot normal, and its evaluation:
+ *
+ * ```wgsl
+ * struct Sh2ColorPivot { value: vec3<f32>, gradient: mat3x3<f32>, pivot: vec3<f32> }
+ * fn sh2_color_pivot_evaluate(f: Sh2ColorPivot, n: vec3<f32>) -> vec3<f32> // value + gradient · (n − pivot)
+ * ```
+ *
+ * Any L1 function on the sphere is affine in the normal, c₀ + c·n, so this is the same function space as
+ * band 0 and band 1 of SH. Writing it about a pivot near the normals it was fitted on puts a real value
+ * in `value`, the function at the pivot, where band 0 is the function's mean over the whole sphere. A
+ * one-sided fit's mean can lie far outside the range its values take on the fitted side.
+ *
+ * `gradient`'s column `a` is the RGB derivative along normal axis `a`.
+ *
+ * @type {CodeChunk}
+ */
+export const chunk_sh2_color_pivot = CodeChunk.from(
+    //language=WGSL
+    `
+struct Sh2ColorPivot {
+    /** the function at the pivot */
+    value: vec3<f32>,
+    /** a column an axis of the normal: the RGB change per unit of that axis */
+    gradient: mat3x3<f32>,
+    /** unit length */
+    pivot: vec3<f32>,
+}
+
+fn sh2_color_pivot_evaluate(f: Sh2ColorPivot, n: vec3<f32>) -> vec3<f32> {
+    return f.value + f.gradient * (n - f.pivot);
+}
+`);

package/src/shade/renderer/shader/chunk/spherical_harmonics/pivot/chunk_sh2_color_pivot_compress.d.ts

@@ -0,0 +1,28 @@
+/**
+ * An {@link chunk_sh2_color_pivot} function whose value at the pivot is in [0, 1] per channel, an
+ * albedo, in 128 bits, laid out as `sh2_color_pivot_uncompress` reads them:
+ *
+ * ```wgsl
+ * fn sh2_color_pivot_compress(f: Sh2ColorPivot) -> vec4<u32>
+ * ```
+ *
+ * - **The gradient** goes first: nine snorm8 codes over the least power of two at or above its largest
+ *   component, so every code lies within ±127 and the largest one at or past 64.
+ * - **The pivot** goes next, octahedral, 12 bits a coordinate.
+ * - **The value** is then taken at the stored pivot, through the stored gradient: f(pivot′) =
+ *   value + G′·(pivot′ − pivot). The function keeps its value at the given pivot up to the value's own
+ *   code, whatever the pivot's quantization and however steep the gradient. The value is clamped to
+ *   [0, 1] and stored as its square root, unorm8 a channel, which puts more codes in the dark, as
+ *   `albedo_compress` stores an albedo.
+ *
+ * A code is never all zero: the exponent byte is at least 1, 1 for a zero gradient. A reader may take
+ * an all-zero `vec4<u32>` for no function at all.
+ *
+ * Nothing is deringed. A function fitted to one side of the sphere takes whatever values its other
+ * side gives, and a reader evaluates it near its pivot.
+ *
+ * @type {CodeChunk}
+ */
+export const chunk_sh2_color_pivot_compress: CodeChunk;
+import { CodeChunk } from "../../../compiler/CodeChunk.js";
+//# sourceMappingURL=chunk_sh2_color_pivot_compress.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"chunk_sh2_color_pivot_compress.d.ts","sourceRoot":"","sources":["../../../../../../../../src/shade/renderer/shader/chunk/spherical_harmonics/pivot/chunk_sh2_color_pivot_compress.js"],"names":[],"mappings":"AAUA;;;;;;;;;;;;;;;;;;;;;;;;GAwBG;AACH,6CAFU,SAAS,CA6CZ;0BA9EmB,gCAAgC"}