@woosh/meep-engine 3.61.2 → 3.61.3

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

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

@@ -0,0 +1,79 @@
+import { CodeChunk } from "../../../compiler/CodeChunk.js";
+import { chunk_uv_octahedral_unit_decode } from "../../geometry/octahedron/chunk_uv_octahedral_unit_decode.js";
+import { chunk_uv_octahedral_unit_encode } from "../../geometry/octahedron/chunk_uv_octahedral_unit_encode.js";
+import { chunk_sh2_color_pivot } from "./chunk_sh2_color_pivot.js";
+import {
+    chunk_sh2_color_pivot_uncompress,
+    SH2_COLOR_PIVOT_EXPONENT_BIAS,
+    SH2_COLOR_PIVOT_OCTAHEDRAL_BITS
+} from "./chunk_sh2_color_pivot_uncompress.js";
+
+/**
+ * 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.from(
+    //language=WGSL
+    `
+fn sh2_color_pivot_compress(f: Sh2ColorPivot) -> vec4<u32> {
+    let g = f.gradient;
+    let column_largest = max(max(abs(g[0]), abs(g[1])), abs(g[2]));
+    let largest = max(max(column_largest.x, column_largest.y), column_largest.z);
+
+    // ceil(log2) rounds a component just past a power of two up or down; pack4x8snorm clamps the one
+    // that lands a rounding past 1
+    let exponent = select(1i, clamp(i32(ceil(log2(largest))) + ${SH2_COLOR_PIVOT_EXPONENT_BIAS}i, 1i, 255i), largest > 0.0);
+    // the reciprocal is taken as its own power of two: 2^-127, the scale of byte 1, is subnormal
+    let inverse = exp2(f32(${SH2_COLOR_PIVOT_EXPONENT_BIAS}i - exponent));
+
+    let a = g[0] * inverse;
+    let b = g[1] * inverse;
+    let c = g[2] * inverse;
+
+    var code: vec4<u32>;
+
+    code.y = pack4x8snorm(vec4<f32>(a, b.x));
+    code.z = pack4x8snorm(vec4<f32>(b.yz, c.xy));
+    code.x = u32(exponent) << 24u;
+
+    let octahedral = vec2<u32>(round(saturate(uv_octahedral_unit_encode(f.pivot)) * ${2 ** SH2_COLOR_PIVOT_OCTAHEDRAL_BITS - 1}.0));
+    let pivot = uv_octahedral_unit_decode(vec2<f32>(octahedral) / ${2 ** SH2_COLOR_PIVOT_OCTAHEDRAL_BITS - 1}.0);
+
+    code.w = (pack4x8snorm(vec4<f32>(c.z, 0.0, 0.0, 0.0)) & 0xffu)
+        | (octahedral.x << 8u)
+        | (octahedral.y << ${8 + SH2_COLOR_PIVOT_OCTAHEDRAL_BITS}u);
+
+    // the value at the stored pivot, through the stored gradient
+    let value = f.value + sh2_color_pivot_uncompress_gradient(code) * (pivot - f.pivot);
+
+    code.x |= pack4x8unorm(vec4<f32>(sqrt(saturate(value)), 0.0));
+
+    return code;
+}
+`, [
+        chunk_sh2_color_pivot,
+        chunk_sh2_color_pivot_uncompress,
+        chunk_uv_octahedral_unit_encode,
+        chunk_uv_octahedral_unit_decode,
+    ]);

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

@@ -0,0 +1,25 @@
+/**
+ * An {@link chunk_sh2_color_pivot} function fitted to weighted samples of it, a color at a unit normal
+ * each:
+ *
+ * ```wgsl
+ * fn sh2_color_pivot_fit_add(fit: ptr<function, Sh2ColorPivotFit>, weight: f32, normal: vec3<f32>, color: vec3<f32>)
+ * fn sh2_color_pivot_fit_solve(fit: Sh2ColorPivotFit, noise: f32) -> Sh2ColorPivot
+ * ```
+ *
+ * Weighted least squares, which written about the samples' mean normal n̄ is the regression of color on
+ * normal, G = Cov(color, n)·Cov(n)⁻¹, stored about n̄'s direction with its value there. `noise`, above
+ * 0, is the variance of the normals' error along an axis, which goes on Cov(n)'s diagonal: a spread no
+ * larger than that is the normals' noise, and a slope read from it would turn the colors' contrast into
+ * a gradient as steep as the noise is small.
+ *
+ * The sums are raw moments, so samples add in any order and a fit can be split and joined. Their
+ * cancellation in f32 is about 1e-7 of a unit normal's square: a noise under that is lost to it.
+ *
+ * A fit of no weight is the zero function about +z.
+ *
+ * @type {CodeChunk}
+ */
+export const chunk_sh2_color_pivot_fit: CodeChunk;
+import { CodeChunk } from "../../../compiler/CodeChunk.js";
+//# sourceMappingURL=chunk_sh2_color_pivot_fit.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"chunk_sh2_color_pivot_fit.d.ts","sourceRoot":"","sources":["../../../../../../../../src/shade/renderer/shader/chunk/spherical_harmonics/pivot/chunk_sh2_color_pivot_fit.js"],"names":[],"mappings":"AAIA;;;;;;;;;;;;;;;;;;;;;GAqBG;AACH,wCAFU,SAAS,CAgEZ;0BAxFmB,gCAAgC"}

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

@@ -0,0 +1,89 @@
+import { CodeChunk } from "../../../compiler/CodeChunk.js";
+import { chunk_mat3_inverse } from "../../geometry/mat3/chunk_mat3_inverse.js";
+import { chunk_sh2_color_pivot } from "./chunk_sh2_color_pivot.js";
+
+/**
+ * An {@link chunk_sh2_color_pivot} function fitted to weighted samples of it, a color at a unit normal
+ * each:
+ *
+ * ```wgsl
+ * fn sh2_color_pivot_fit_add(fit: ptr<function, Sh2ColorPivotFit>, weight: f32, normal: vec3<f32>, color: vec3<f32>)
+ * fn sh2_color_pivot_fit_solve(fit: Sh2ColorPivotFit, noise: f32) -> Sh2ColorPivot
+ * ```
+ *
+ * Weighted least squares, which written about the samples' mean normal n̄ is the regression of color on
+ * normal, G = Cov(color, n)·Cov(n)⁻¹, stored about n̄'s direction with its value there. `noise`, above
+ * 0, is the variance of the normals' error along an axis, which goes on Cov(n)'s diagonal: a spread no
+ * larger than that is the normals' noise, and a slope read from it would turn the colors' contrast into
+ * a gradient as steep as the noise is small.
+ *
+ * The sums are raw moments, so samples add in any order and a fit can be split and joined. Their
+ * cancellation in f32 is about 1e-7 of a unit normal's square: a noise under that is lost to it.
+ *
+ * A fit of no weight is the zero function about +z.
+ *
+ * @type {CodeChunk}
+ */
+export const chunk_sh2_color_pivot_fit = CodeChunk.from(
+    //language=WGSL
+    `
+struct Sh2ColorPivotFit {
+    weight: f32,
+    /** the weighted sums of the samples' normals and colors */
+    normal: vec3<f32>,
+    color: vec3<f32>,
+    /** Σ w n nᵀ */
+    normal_normal: mat3x3<f32>,
+    /** Σ w c nᵀ: a column a normal axis, its RGB */
+    color_normal: mat3x3<f32>,
+}
+
+fn sh2_color_pivot_fit_add(fit: ptr<function, Sh2ColorPivotFit>, weight: f32, normal: vec3<f32>, color: vec3<f32>) {
+    let wn = weight * normal;
+    let wc = weight * color;
+
+    (*fit).weight += weight;
+    (*fit).normal += wn;
+    (*fit).color += wc;
+    (*fit).normal_normal += mat3x3<f32>(wn * normal.x, wn * normal.y, wn * normal.z);
+    (*fit).color_normal += mat3x3<f32>(wc * normal.x, wc * normal.y, wc * normal.z);
+}
+
+fn sh2_color_pivot_fit_solve(fit: Sh2ColorPivotFit, noise: f32) -> Sh2ColorPivot {
+    var out: Sh2ColorPivot;
+
+    out.pivot = vec3<f32>(0.0, 0.0, 1.0);
+
+    if (!(fit.weight > 0.0)) {
+        return out;
+    }
+
+    let inverse_weight = 1.0 / fit.weight;
+    let mean_normal = fit.normal * inverse_weight;
+    let mean_color = fit.color * inverse_weight;
+
+    // per unit weight, about the means; the noise on the normals' diagonal
+    let covariance = fit.normal_normal * inverse_weight
+        - mat3x3<f32>(mean_normal * mean_normal.x, mean_normal * mean_normal.y, mean_normal * mean_normal.z)
+        + mat3x3<f32>(vec3<f32>(noise, 0.0, 0.0), vec3<f32>(0.0, noise, 0.0), vec3<f32>(0.0, 0.0, noise));
+    let cross_covariance = fit.color_normal * inverse_weight
+        - mat3x3<f32>(mean_color * mean_normal.x, mean_color * mean_normal.y, mean_color * mean_normal.z);
+
+    let gradient = cross_covariance * mat3_inverse(covariance);
+    let reach = length(mean_normal);
+
+    // normals that cancel, as a thin wall's two faces do, leave no mean direction: then any unit normal
+    // is as good a pivot
+    if (reach > 0.0) {
+        out.pivot = mean_normal / reach;
+    }
+
+    out.gradient = gradient;
+    out.value = mean_color + gradient * (out.pivot - mean_normal);
+
+    return out;
+}
+`, [
+        chunk_sh2_color_pivot,
+        chunk_mat3_inverse,
+    ]);

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

@@ -0,0 +1,31 @@
+/**
+ * What the gradient's exponent byte is offset by: the gradient's scale is 2^(e − bias).
+ * @type {number}
+ */
+export const SH2_COLOR_PIVOT_EXPONENT_BIAS: number;
+/**
+ * Bits of each of the pivot's two octahedral coordinates.
+ * @type {number}
+ */
+export const SH2_COLOR_PIVOT_OCTAHEDRAL_BITS: number;
+/**
+ * An {@link chunk_sh2_color_pivot} function from the 128 bits `sh2_color_pivot_compress` wrote:
+ *
+ * ```wgsl
+ * fn sh2_color_pivot_uncompress(code: vec4<u32>) -> Sh2ColorPivot
+ * fn sh2_color_pivot_uncompress_gradient(code: vec4<u32>) -> mat3x3<f32>
+ * ```
+ *
+ * The layout, a `vec4<u32>`:
+ * - `x`: the value at the pivot, its square root per channel as unorm8 in R, G, B; then the gradient's
+ *   exponent byte e, never 0, its scale 2^(e − {@link SH2_COLOR_PIVOT_EXPONENT_BIAS}).
+ * - `y`, `z` and the low byte of `w`: nine snorm8 codes of the gradient over its scale, column by
+ *   column: ∂/∂n_x as R, G, B, then ∂/∂n_y, then ∂/∂n_z.
+ * - `w` bits 8–31: the pivot, octahedral (`uv_octahedral_unit_encode`), {@link SH2_COLOR_PIVOT_OCTAHEDRAL_BITS}
+ *   bits a coordinate, x then y.
+ *
+ * @type {CodeChunk}
+ */
+export const chunk_sh2_color_pivot_uncompress: CodeChunk;
+import { CodeChunk } from "../../../compiler/CodeChunk.js";
+//# sourceMappingURL=chunk_sh2_color_pivot_uncompress.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"chunk_sh2_color_pivot_uncompress.d.ts","sourceRoot":"","sources":["../../../../../../../../src/shade/renderer/shader/chunk/spherical_harmonics/pivot/chunk_sh2_color_pivot_uncompress.js"],"names":[],"mappings":"AAIA;;;GAGG;AACH,4CAFU,MAAM,CAEiC;AAEjD;;;GAGG;AACH,8CAFU,MAAM,CAEkC;AAElD;;;;;;;;;;;;;;;;;GAiBG;AACH,+CAFU,SAAS,CAiCZ;0BAjEmB,gCAAgC"}

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

@@ -0,0 +1,66 @@
+import { CodeChunk } from "../../../compiler/CodeChunk.js";
+import { chunk_uv_octahedral_unit_decode } from "../../geometry/octahedron/chunk_uv_octahedral_unit_decode.js";
+import { chunk_sh2_color_pivot } from "./chunk_sh2_color_pivot.js";
+
+/**
+ * What the gradient's exponent byte is offset by: the gradient's scale is 2^(e − bias).
+ * @type {number}
+ */
+export const SH2_COLOR_PIVOT_EXPONENT_BIAS = 128;
+
+/**
+ * Bits of each of the pivot's two octahedral coordinates.
+ * @type {number}
+ */
+export const SH2_COLOR_PIVOT_OCTAHEDRAL_BITS = 12;
+
+/**
+ * An {@link chunk_sh2_color_pivot} function from the 128 bits `sh2_color_pivot_compress` wrote:
+ *
+ * ```wgsl
+ * fn sh2_color_pivot_uncompress(code: vec4<u32>) -> Sh2ColorPivot
+ * fn sh2_color_pivot_uncompress_gradient(code: vec4<u32>) -> mat3x3<f32>
+ * ```
+ *
+ * The layout, a `vec4<u32>`:
+ * - `x`: the value at the pivot, its square root per channel as unorm8 in R, G, B; then the gradient's
+ *   exponent byte e, never 0, its scale 2^(e − {@link SH2_COLOR_PIVOT_EXPONENT_BIAS}).
+ * - `y`, `z` and the low byte of `w`: nine snorm8 codes of the gradient over its scale, column by
+ *   column: ∂/∂n_x as R, G, B, then ∂/∂n_y, then ∂/∂n_z.
+ * - `w` bits 8–31: the pivot, octahedral (`uv_octahedral_unit_encode`), {@link SH2_COLOR_PIVOT_OCTAHEDRAL_BITS}
+ *   bits a coordinate, x then y.
+ *
+ * @type {CodeChunk}
+ */
+export const chunk_sh2_color_pivot_uncompress = CodeChunk.from(
+    //language=WGSL
+    `
+fn sh2_color_pivot_uncompress_gradient(code: vec4<u32>) -> mat3x3<f32> {
+    let scale = exp2(f32(code.x >> 24u) - ${SH2_COLOR_PIVOT_EXPONENT_BIAS}.0);
+
+    let a = unpack4x8snorm(code.y) * scale;
+    let b = unpack4x8snorm(code.z) * scale;
+    let c = unpack4x8snorm(code.w & 0xffu).x * scale;
+
+    return mat3x3<f32>(a.xyz, vec3<f32>(a.w, b.xy), vec3<f32>(b.zw, c));
+}
+
+fn sh2_color_pivot_uncompress(code: vec4<u32>) -> Sh2ColorPivot {
+    var f: Sh2ColorPivot;
+
+    let root = unpack4x8unorm(code.x).rgb;
+    let octahedral = vec2<u32>(
+        extractBits(code.w, 8u, ${SH2_COLOR_PIVOT_OCTAHEDRAL_BITS}u),
+        extractBits(code.w, ${8 + SH2_COLOR_PIVOT_OCTAHEDRAL_BITS}u, ${SH2_COLOR_PIVOT_OCTAHEDRAL_BITS}u)
+    );
+
+    f.value = root * root;
+    f.gradient = sh2_color_pivot_uncompress_gradient(code);
+    f.pivot = uv_octahedral_unit_decode(vec2<f32>(octahedral) / ${2 ** SH2_COLOR_PIVOT_OCTAHEDRAL_BITS - 1}.0);
+
+    return f;
+}
+`, [
+        chunk_sh2_color_pivot,
+        chunk_uv_octahedral_unit_decode,
+    ]);

package/src/shade/renderer/shader/chunk/subgroup/chunk_subgroup_atomic_add.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"chunk_subgroup_atomic_add.d.ts","sourceRoot":"","sources":["../../../../../../../src/shade/renderer/shader/chunk/subgroup/chunk_subgroup_atomic_add.js"],"names":[],"mappings":"AAGA;;;;;;;;;;;GAWG;AACH,wCAFU,SAAS,CAahB;0BAzBuB,6BAA6B"}
+{"version":3,"file":"chunk_subgroup_atomic_add.d.ts","sourceRoot":"","sources":["../../../../../../../src/shade/renderer/shader/chunk/subgroup/chunk_subgroup_atomic_add.js"],"names":[],"mappings":"AAGA;;;;;;;;;;;GAWG;AACH,wCAFU,SAAS,CAehB;0BA3BuB,6BAA6B"}

package/src/shade/renderer/shader/chunk/subgroup/chunk_subgroup_atomic_add.js

@@ -16,6 +16,8 @@ import { CodeChunk } from "../../compiler/CodeChunk.js";
 export const chunk_subgroup_atomic_add = CodeChunk.from(
     //language=WGSL
     `
+// uniform in the subgroup by the caller's counter, which the analysis cannot see behind its returns
+@diagnostic(off, subgroup_uniformity)
 fn subgroup_atomic_add_u32(counter: ptr<storage, atomic<u32>, read_write>, value: u32) {
     let total = subgroupAdd(value);
     let elected = subgroupElect();

package/src/shade/renderer/shader/chunk/subgroup/chunk_subgroup_atomic_load.d.ts

@@ -0,0 +1,17 @@
+/**
+ * Load an atomic every lane of the subgroup reads alike, once a subgroup: its first active lane
+ * loads it, and the subgroup hands every lane what that lane read. Lanes that each load the same
+ * atomic serialize where `atomicLoad` is a read-modify-write, as it is on D3D12
+ * (`InterlockedOr(x, 0)`); one load a subgroup does not.
+ *
+ * `fn subgroup_atomic_load_u32(word: ptr<storage, atomic<u32>, read_write>) -> u32`
+ *
+ * Every lane of the subgroup calls it with the same `word`, from subgroup-uniform control flow: a
+ * lane passing another word reads the first lane's.
+ *
+ * @see chunk_subgroup_atomic_add for the writing twin
+ * @type {CodeChunk}
+ */
+export const chunk_subgroup_atomic_load: CodeChunk;
+import { CodeChunk } from "../../compiler/CodeChunk.js";
+//# sourceMappingURL=chunk_subgroup_atomic_load.d.ts.map

package/src/shade/renderer/shader/chunk/subgroup/chunk_subgroup_atomic_load.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"chunk_subgroup_atomic_load.d.ts","sourceRoot":"","sources":["../../../../../../../src/shade/renderer/shader/chunk/subgroup/chunk_subgroup_atomic_load.js"],"names":[],"mappings":"AAGA;;;;;;;;;;;;;GAaG;AACH,yCAFU,SAAS,CAgBhB;0BA9BuB,6BAA6B"}

package/src/shade/renderer/shader/chunk/subgroup/chunk_subgroup_atomic_load.js

@@ -0,0 +1,34 @@
+import { WebGPUExtensionType } from "../../../../descriptor/WebGPUExtensionType.js";
+import { CodeChunk } from "../../compiler/CodeChunk.js";
+
+/**
+ * Load an atomic every lane of the subgroup reads alike, once a subgroup: its first active lane
+ * loads it, and the subgroup hands every lane what that lane read. Lanes that each load the same
+ * atomic serialize where `atomicLoad` is a read-modify-write, as it is on D3D12
+ * (`InterlockedOr(x, 0)`); one load a subgroup does not.
+ *
+ * `fn subgroup_atomic_load_u32(word: ptr<storage, atomic<u32>, read_write>) -> u32`
+ *
+ * Every lane of the subgroup calls it with the same `word`, from subgroup-uniform control flow: a
+ * lane passing another word reads the first lane's.
+ *
+ * @see chunk_subgroup_atomic_add for the writing twin
+ * @type {CodeChunk}
+ */
+export const chunk_subgroup_atomic_load = CodeChunk.from(
+    //language=WGSL
+    `
+// uniform in the subgroup by the caller's word, which the analysis cannot see behind its returns
+@diagnostic(off, subgroup_uniformity)
+fn subgroup_atomic_load_u32(word: ptr<storage, atomic<u32>, read_write>) -> u32 {
+    var value = 0u;
+
+    if (subgroupElect()) {
+        value = atomicLoad(word);
+    }
+
+    return subgroupBroadcastFirst(value);
+}
+`);
+
+chunk_subgroup_atomic_load.addExtension(WebGPUExtensionType.Subgroups);

package/src/shade/renderer/volumetrics/chunk_frustum_unit_box_coverage_multisample.d.ts

@@ -1,3 +1,21 @@
+/**
+ * The share of a frustum's volume inside the unit box [-0.5, 0.5]³, estimated along 4 rays from its near
+ * face to its far face: the mean of the fraction of each ray inside the box.
+ *
+ * The rays cross the face at points `4 · round` to `4 · round + 3` of the shuffled, Owen-scrambled Sobol
+ * sequence of `seed` (`sample_sobol_2d`), in the face's (u, v), u from the left plane to the right and v
+ * from the bottom to the top. Each call's 4 points are one per quarter of the face along either axis, and one
+ * per quadrant. The 2^m calls of an aligned run of rounds put one point in each dyadic cell of area
+ * 2^-(m+2). The points depend only on the seed and the round, and a ray is the planes' blend at its point:
+ * the same frustum's planes carried into another space by a rigid or uniformly scaled map, each plane
+ * renormalized, cast the same rays there.
+ *
+ * ```wgsl
+ * fn frustum_unit_box_coverage(frustum: array<vec4f, 6>, round: u32, seed: u32) -> f32 // frustum planes [LEFT, RIGHT, BOTTOM, TOP, NEAR, FAR]
+ * ```
+ *
+ * @type {CodeChunk}
+ */
 export const chunk_frustum_unit_box_coverage_multisample: CodeChunk;
 import { CodeChunk } from "../shader/compiler/CodeChunk.js";
 //# sourceMappingURL=chunk_frustum_unit_box_coverage_multisample.d.ts.map

package/src/shade/renderer/volumetrics/chunk_frustum_unit_box_coverage_multisample.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"chunk_frustum_unit_box_coverage_multisample.d.ts","sourceRoot":"","sources":["../../../../../src/shade/renderer/volumetrics/chunk_frustum_unit_box_coverage_multisample.js"],"names":[],"mappings":"AAIA,oEAsDE;0BAxDwB,iCAAiC"}
+{"version":3,"file":"chunk_frustum_unit_box_coverage_multisample.d.ts","sourceRoot":"","sources":["../../../../../src/shade/renderer/volumetrics/chunk_frustum_unit_box_coverage_multisample.js"],"names":[],"mappings":"AAIA;;;;;;;;;;;;;;;;;GAiBG;AACH,0DAFU,SAAS,CA8CjB;0BAhEwB,iCAAiC"}