@woosh/meep-engine 3.61.1 → 3.61.3

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

package/src/shade/renderer/volumetrics/chunk_frustum_unit_box_coverage_multisample.js

@@ -1,39 +1,48 @@
 import { chunk_frustum_sample_point } from "../shader/chunk/geometry/frustum/chunk_frustum_sample_point.js";
-import { chunk_random } from "../shader/chunk/random/chunk_random.js";
+import { chunk_sobol_sample_vec2 } from "../shader/chunk/noise/chunk_sobol_sample_vec2.js";
 import { CodeChunk } from "../shader/compiler/CodeChunk.js";
 
+/**
+ * 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.from(
     //language=WGSL
     `
 fn frustum_unit_box_coverage(
     frustum: array< vec4f, 6>,
+    round: u32,
+    seed: u32,
 ) -> f32 {
-    
-    // 4 Samples is usually the "Sweet Spot" for volumetrics.
-    // 1 = Hard Edges
-    // 4 = Smooth with slight noise (cleaned up by TAA)
-    // 16 = High quality but expensive
     const SAMPLE_COUNT = 4u;
-    
+
     var total_coverage = 0.0;
 
     for(var i = 0u; i < SAMPLE_COUNT; i++){
-    
-        // 1. Generate Random UVs
-        // This distributes rays across the face of the froxel.
-        let u = random();
-        let v = random();
-        
-        // 2. Construct Ray
-        // Note: We must re-calculate direction per-sample because 
-        // perspective frustums diverge (rays are not parallel).
-        let start = frustum_sample_point(frustum, vec3f(u, v, 0.0));
-        let end   = frustum_sample_point(frustum, vec3f(u, v, 1.0));
+        let uv = sample_sobol_2d(round * SAMPLE_COUNT + i, seed);
+
+        // perspective frustums diverge, so each ray takes its own direction
+        let start = frustum_sample_point(frustum, vec3f(uv, 0.0));
+        let end   = frustum_sample_point(frustum, vec3f(uv, 1.0));
 
         let dir = end - start;
         let inv_dir = 1.0 / (dir + vec3f(1e-5));
-        
-        // 3. Slab Method (Intersection with Unit Box -0.5 to 0.5)
+
+        // slab test against the unit box
         let t0 = (vec3f(-0.5) - start) * inv_dir;
         let t1 = (vec3f( 0.5) - start) * inv_dir;
 
@@ -43,7 +52,6 @@ fn frustum_unit_box_coverage(
         let enter = max(max(tmin.x, tmin.y), tmin.z);
         let exit  = min(min(tmax.x, tmax.y), tmax.z);
 
-        // 4. Accumulate Ratio
         let t_start = max(0.0, enter);
         let t_end   = min(1.0, exit);
 
@@ -54,6 +62,6 @@ fn frustum_unit_box_coverage(
 }
     `, [
         chunk_frustum_sample_point,
-        chunk_random
+        chunk_sobol_sample_vec2,
     ]
-);
+);

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/volumetrics/shader_volumetrics_build_participating_media.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"shader_volumetrics_build_participating_media.d.ts","sourceRoot":"","sources":["../../../../../src/shade/renderer/volumetrics/shader_volumetrics_build_participating_media.js"],"names":[],"mappings":"AA8QA,yEAIE;8BA3P4B,4BAA4B"}
+{"version":3,"file":"shader_volumetrics_build_participating_media.d.ts","sourceRoot":"","sources":["../../../../../src/shade/renderer/volumetrics/shader_volumetrics_build_participating_media.js"],"names":[],"mappings":"AA6QA,yEAIE;8BA3P4B,4BAA4B"}

package/src/shade/renderer/volumetrics/shader_volumetrics_build_participating_media.js

@@ -18,8 +18,7 @@ import {
 } from "../shader/chunk/geometry/frustum/chunk_frustum_transform_plane_matrix.js";
 import { chunk_mat4_extract_scale } from "../shader/chunk/geometry/mat4/chunk_mat4_extract_scale.js";
 import { chunk_stbn_sample_vec3 } from "../shader/chunk/noise/chunk_stbn_sample_vec3.js";
-import { chunk_random } from "../shader/chunk/random/chunk_random.js";
-import { chunk_random_initialize } from "../shader/chunk/random/chunk_random_initialize.js";
+import { chunk_pcg4d } from "../shader/chunk/random/pcg/chunk_pcg4d.js";
 import { CodeChunk } from "../shader/compiler/CodeChunk.js";
 import { ComputeShader } from "../shader/ComputeShader.js";
 import { ShaderResourceSetDescriptor } from "../shader/resource/ShaderResourceSetDescriptor.js";
@@ -69,7 +68,8 @@ fn main(
         return;
     }
     
-    random_initialize(voxel_coord, vec3(view.frame_index, 0xCAFEBEEF, 1337));
+    // the froxel's coverage points: a sequence of its own, a round of it a frame, the same points for every volume
+    let coverage_seed = pcg4d(vec4<u32>(voxel_coord, 0x1F83D9ABu)).x;
     
     let uv = vec2f(voxel_coord.xy) / vec2f(resolution.xy);
     
@@ -187,7 +187,7 @@ fn main(
         // volumetrics_froxel_containment.spec.js keeps the geometry proven if the balance changes.
 
         // estimate volume coverage to avoid aliasing and get a better overlap test
-        var volume_coverage = frustum_unit_box_coverage(local_frustum);
+        var volume_coverage = frustum_unit_box_coverage(local_frustum, view.frame_index, coverage_seed);
 
         if(volume_coverage == 0.0){
             // skip
@@ -252,8 +252,7 @@ fn main(
         chunk_frustum_transform_plane_matrix,
         chunk_aabb3_intersects_frustum,
         chunk_compute_near_far_from_projection,
-        chunk_random_initialize,
-        chunk_random,
+        chunk_pcg4d,
         chunk_rgb_to_luminance,
         chunk_frustum_unit_box_coverage_multisample,
         chunk_compute_volume_fade_factor,