@woosh/meep-engine 3.61.2 → 3.62.0

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/shader/pass/RenderPassDescriptor.d.ts

@@ -28,6 +28,14 @@ export class RenderPassDescriptor {
      * @type {RenderPassDepthStencilAttachmentDescriptor}
      */
     depthStencilAttachment: RenderPassDepthStencilAttachmentDescriptor;
+    /**
+     * Whether the pipeline writes each draw's `instance_index` as a slot of the frame's visible-meshlet
+     * table, as the visibility raster does: a draw under it must take its meshlets from that table — see
+     * `graph_meshlets_rasterize`.
+     *
+     * @type {boolean}
+     */
+    visible_meshlet_slots: boolean;
     /**
      * @param {Object} options
      * @param {GPUTextureContext[]} [options.colorTargets]

package/src/shade/renderer/shader/pass/RenderPassDescriptor.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"RenderPassDescriptor.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/shader/pass/RenderPassDescriptor.js"],"names":[],"mappings":"AAIA;;GAEG;AACH;IACI;;;;;;OAMG;IACH,OAFU,MAAM,GAAC,SAAS,CAER;IAElB;;OAEG;IACH,mCAAQ;IAER;;OAEG;IACH,uCAAS;IAET;;;OAGG;IACH,kBAFU,qCAAqC,CAEzB;IAEtB;;;OAGG;IACH,wBAFU,0CAA0C,CAEsB;IAG1E;;;;;;;;;;;OAWG;IACH;QAVyC,YAAY,GAA1C,mBAAmB;QACS,WAAW;QACnB,MAAM;QACL,OAAO;QACR,WAAW;QACV,YAAY;QACb,WAAW;QACV,YAAY;gCAwE3C;IAED;;;;;;;;;;;OAWG;IACH;QAT2C,OAAO;QACT,YAAY,GAA1C,mBAAmB;QACS,WAAW;QACtB,QAAQ;QACA,eAAe;QACpB,MAAM;QACL,OAAO;kCAuCtC;IAED;;;;;;;;OAQG;IACH;QAN2C,OAAO;QACpB,OAAO;QACT,cAAc,GAA/B,MAAM;QACW,QAAQ;QACH,aAAa;aAgB7C;IAGL;;;OAGG;IACH,iCAFU,OAAO,CAEoC;CANpD;2DAnM0D,iDAAiD"}
+{"version":3,"file":"RenderPassDescriptor.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/shader/pass/RenderPassDescriptor.js"],"names":[],"mappings":"AAIA;;GAEG;AACH;IACI;;;;;;OAMG;IACH,OAFU,MAAM,GAAC,SAAS,CAER;IAElB;;OAEG;IACH,mCAAQ;IAER;;OAEG;IACH,uCAAS;IAET;;;OAGG;IACH,kBAFU,qCAAqC,CAEzB;IAEtB;;;OAGG;IACH,wBAFU,0CAA0C,CAEsB;IAE1E;;;;;;OAMG;IACH,uBAFU,OAAO,CAEa;IAG9B;;;;;;;;;;;OAWG;IACH;QAVyC,YAAY,GAA1C,mBAAmB;QACS,WAAW;QACnB,MAAM;QACL,OAAO;QACR,WAAW;QACV,YAAY;QACb,WAAW;QACV,YAAY;gCAwE3C;IAED;;;;;;;;;;;OAWG;IACH;QAT2C,OAAO;QACT,YAAY,GAA1C,mBAAmB;QACS,WAAW;QACtB,QAAQ;QACA,eAAe;QACpB,MAAM;QACL,OAAO;kCAuCtC;IAED;;;;;;;;OAQG;IACH;QAN2C,OAAO;QACpB,OAAO;QACT,cAAc,GAA/B,MAAM;QACW,QAAQ;QACH,aAAa;aAgB7C;IAGL;;;OAGG;IACH,iCAFU,OAAO,CAEoC;CANpD;2DA5M0D,iDAAiD"}

package/src/shade/renderer/shader/pass/RenderPassDescriptor.js

@@ -37,6 +37,15 @@ export class RenderPassDescriptor {
      */
     depthStencilAttachment = new RenderPassDepthStencilAttachmentDescriptor();
 
+    /**
+     * Whether the pipeline writes each draw's `instance_index` as a slot of the frame's visible-meshlet
+     * table, as the visibility raster does: a draw under it must take its meshlets from that table — see
+     * `graph_meshlets_rasterize`.
+     *
+     * @type {boolean}
+     */
+    visible_meshlet_slots = false;
+
 
     /**
      * @param {Object} options

package/src/shade/renderer/shader/util/shader_decode_octahedral_normal.js

@@ -18,7 +18,7 @@ fn main(
 ) -> @location(0) vec4<f32>{
     let texel = textureLoad(tInput, vec2u(coord.xy), 0);
 
-    let normal = decode_g_buffer_normal(texel.xy);
+    let normal = decode_g_buffer_normal(texel.x);
     
     return vec4(normal, 1.0);   
 }

package/src/shade/renderer/shadow/contact/graph_contact_shadow_linear.d.ts

@@ -5,17 +5,17 @@
  * @param {Object} options
  * @param {FrameGraph} options.graph
  * @param {number} options.depth the depth buffer
- * @param {number} options.normal the G-buffer normals
+ * @param {number} options.pbr the G-buffer's PBR target, for its face normal
  * @param {GPUBuffer} options.camera the view's camera uniforms, whose projection drew `depth`
  * @param {ArrayLike<number>} options.resolution of `depth`
  * @param {{to_light: ArrayLike<number>, length: number, steps: number, thickness: number, jitter_frame: number}} options.settings
  *        see {@link CONTACT_SHADOW_LINEAR_SETTINGS_STRUCT}
  * @returns {number} the visibility texture
  */
-export function graph_contact_shadow_linear({ graph, depth, normal, camera, resolution, settings }: {
+export function graph_contact_shadow_linear({ graph, depth, pbr, camera, resolution, settings }: {
     graph: FrameGraph;
     depth: number;
-    normal: number;
+    pbr: number;
     camera: GPUBuffer;
     resolution: ArrayLike<number>;
     settings: {

package/src/shade/renderer/shadow/contact/graph_contact_shadow_linear.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"graph_contact_shadow_linear.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/shadow/contact/graph_contact_shadow_linear.js"],"names":[],"mappings":"AAIA;;;;;;;;;;;;;GAaG;AACH;IAT+B,KAAK;IACT,KAAK,EAArB,MAAM;IACU,MAAM,EAAtB,MAAM;IACa,MAAM;IACE,UAAU,EAArC,UAAU,MAAM,CAAC;IAC8F,QAAQ,EAAvH;QAAC,QAAQ,EAAE,UAAU,MAAM,CAAC,CAAC;QAAC,MAAM,EAAE,MAAM,CAAC;QAAC,KAAK,EAAE,MAAM,CAAC;QAAC,SAAS,EAAE,MAAM,CAAC;QAAC,YAAY,EAAE,MAAM,CAAA;KAAC;IAEnG,MAAM,CAsBlB"}
+{"version":3,"file":"graph_contact_shadow_linear.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/shadow/contact/graph_contact_shadow_linear.js"],"names":[],"mappings":"AAIA;;;;;;;;;;;;;GAaG;AACH;IAT+B,KAAK;IACT,KAAK,EAArB,MAAM;IACU,GAAG,EAAnB,MAAM;IACa,MAAM;IACE,UAAU,EAArC,UAAU,MAAM,CAAC;IAC8F,QAAQ,EAAvH;QAAC,QAAQ,EAAE,UAAU,MAAM,CAAC,CAAC;QAAC,MAAM,EAAE,MAAM,CAAC;QAAC,KAAK,EAAE,MAAM,CAAC;QAAC,SAAS,EAAE,MAAM,CAAC;QAAC,YAAY,EAAE,MAAM,CAAA;KAAC;IAEnG,MAAM,CAsBlB"}

package/src/shade/renderer/shadow/contact/graph_contact_shadow_linear.js

@@ -9,14 +9,14 @@ import { shader_contact_shadow_linear } from "./shader_contact_shadow_linear.js"
  * @param {Object} options
  * @param {FrameGraph} options.graph
  * @param {number} options.depth the depth buffer
- * @param {number} options.normal the G-buffer normals
+ * @param {number} options.pbr the G-buffer's PBR target, for its face normal
  * @param {GPUBuffer} options.camera the view's camera uniforms, whose projection drew `depth`
  * @param {ArrayLike<number>} options.resolution of `depth`
  * @param {{to_light: ArrayLike<number>, length: number, steps: number, thickness: number, jitter_frame: number}} options.settings
  *        see {@link CONTACT_SHADOW_LINEAR_SETTINGS_STRUCT}
  * @returns {number} the visibility texture
  */
-export function graph_contact_shadow_linear({ graph, depth, normal, camera, resolution, settings }) {
+export function graph_contact_shadow_linear({ graph, depth, pbr, camera, resolution, settings }) {
     const width = resolution[0];
     const height = resolution[1];
 
@@ -27,7 +27,7 @@ export function graph_contact_shadow_linear({ graph, depth, normal, camera, reso
         bindings: {
             settings,
             gBufferDepth: depth,
-            gBufferNormal: normal,
+            gBufferPBR: pbr,
             camera,
             tContactShadow: TextureResourceDescriptor.from({
                 resolution: [width, height],

package/src/shade/renderer/shadow/contact/shader_contact_shadow_linear.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"shader_contact_shadow_linear.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/shadow/contact/shader_contact_shadow_linear.js"],"names":[],"mappings":"AAcA;;;;;;;;;;;;;GAaG;AACH,oDAFU,YAAY,CAQY;AA+ElC;;;;;;;;;GASG;AACH,2CAFU,aAAa,CAMpB;6BAnH0B,mCAAmC;8BAHlC,+BAA+B"}
+{"version":3,"file":"shader_contact_shadow_linear.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/shadow/contact/shader_contact_shadow_linear.js"],"names":[],"mappings":"AAgBA;;;;;;;;;;;;;GAaG;AACH,oDAFU,YAAY,CAQY;AA+ElC;;;;;;;;;GASG;AACH,2CAFU,aAAa,CAMpB;6BAnH0B,mCAAmC;8BAHlC,+BAA+B"}

package/src/shade/renderer/shadow/contact/shader_contact_shadow_linear.js

@@ -1,7 +1,9 @@
 import { CAMERA_UNIFORM_STRUCT } from "../../camera/CAMERA_UNIFORM_STRUCT.js";
 import { chunk_project_position_from_depth } from "../../shader/chunk/camera/chunk_project_position_from_depth.js";
 import { chunk_is_background } from "../../shader/chunk/depth/chunk_is_background.js";
-import { chunk_decode_g_buffer_normal } from "../../shader/chunk/geometry/normal/chunk_decode_g_buffer_normal.js";
+import {
+    chunk_decode_g_buffer_face_normal
+} from "../../shader/chunk/geometry/normal/chunk_decode_g_buffer_face_normal.js";
 import { chunk_interleaved_gradient_noise } from "../../shader/chunk/noise/chunk_interleaved_gradient_noise.js";
 import { chunk_screen_space_linear_ray } from "../../shader/chunk/screen_space/chunk_screen_space_linear_ray.js";
 import { chunk_texel_coordinate_to_uv } from "../../shader/chunk/texture/chunk_texel_coordinate_to_uv.js";
@@ -40,7 +42,7 @@ resources.setImmediate("settings", CONTACT_SHADOW_LINEAR_SETTINGS_STRUCT);
 
 resources.createGroup()
     .addTexture("gBufferDepth")
-    .addTexture("gBufferNormal", "uint")
+    .addTexture("gBufferPBR")
     .addUniform("camera", CAMERA_UNIFORM_STRUCT)
     .addStorageTexture("tContactShadow", "r32float", "2d", "write-only");
 
@@ -63,7 +65,7 @@ fn main(@builtin(global_invocation_id) id: vec3<u32>) {
     }
 
     let to_light = settings.to_light;
-    let geometric_normal = decode_g_buffer_normal(textureLoad(gBufferNormal, id.xy, 0).zw);
+    let geometric_normal = decode_g_buffer_face_normal(textureLoad(gBufferPBR, id.xy, 0));
 
     if (dot(geometric_normal, to_light) <= 0.0) {
         // facing away: the shadow map's term is already 0, nothing to add to it
@@ -102,7 +104,7 @@ fn main(@builtin(global_invocation_id) id: vec3<u32>) {
 `, [
         CONTACT_SHADOW_LINEAR_SETTINGS_STRUCT.declaration_chunk,
         chunk_is_background,
-        chunk_decode_g_buffer_normal,
+        chunk_decode_g_buffer_face_normal,
         chunk_texel_coordinate_to_uv,
         chunk_uv_to_ndc,
         chunk_project_position_from_depth,

package/src/shade/renderer/shadow/ray/RTXShadows.d.ts

@@ -13,7 +13,8 @@ export class RTXShadows {
      * [02/05/2025] tested on Sponza, inline approach is 1.66ms, staged is 2.40 so it's slower
      * @param {FrameGraph} graph
      * @param {number} input_position
-     * @param {number} input_normal
+     * @param {number} input_normal the G-buffer's shading normal
+     * @param {number} input_pbr the G-buffer's PBR target, for its face normal
      * @param {number} input_depth
      * @param {number} input_depth_previous
      * @param {number} input_velocity
@@ -22,12 +23,13 @@ export class RTXShadows {
      * @param {number[]} jitter
      * @returns {number} output texture
      */
-    execute2({ graph, input_normal, input_depth, input_depth_previous, input_velocity, input_occlusion, view, jitter }: FrameGraph): number;
+    execute2({ graph, input_normal, input_pbr, input_depth, input_depth_previous, input_velocity, input_occlusion, view, jitter }: FrameGraph): number;
     /**
      *
      * @param {FrameGraph} graph
      * @param {number} input_position
-     * @param {number} input_normal
+     * @param {number} input_normal the G-buffer's shading normal
+     * @param {number} input_pbr the G-buffer's PBR target, for its face normal
      * @param {number} input_depth
      * @param {number} input_depth_previous
      * @param {number} input_velocity
@@ -36,7 +38,7 @@ export class RTXShadows {
      * @param {number[]} jitter
      * @returns {number} output texture
      */
-    execute({ graph, input_normal, input_depth, input_depth_previous, input_velocity, input_occlusion, view, jitter }: FrameGraph): number;
+    execute({ graph, input_normal, input_pbr, input_depth, input_depth_previous, input_velocity, input_occlusion, view, jitter }: FrameGraph): number;
     #private;
 }
 import { LigmaDenoiser } from "../../postprocess/denoise/LigmaDenoiser.js";

package/src/shade/renderer/shadow/ray/RTXShadows.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"RTXShadows.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/shadow/ray/RTXShadows.js"],"names":[],"mappings":"AAeA;IAkBI;;;OAGG;IACH,uCAKC;IAzBD;;OAEG;IACH,UAFU,aAAa,CAEf;IAwBR;;;;;;;;;;;;;OAaG;IACH,iIAFa,MAAM,CA4BlB;IAED;;;;;;;;;;;;OAYG;IACH,gIAFa,MAAM,CAmJlB;;CACJ;8BAhP6B,4CAA4C"}
+{"version":3,"file":"RTXShadows.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/shadow/ray/RTXShadows.js"],"names":[],"mappings":"AAcA;IAkBI;;;OAGG;IACH,uCAKC;IAzBD;;OAEG;IACH,UAFU,aAAa,CAEf;IAwBR;;;;;;;;;;;;;;OAcG;IACH,4IAFa,MAAM,CA8BlB;IAED;;;;;;;;;;;;;OAaG;IACH,2IAFa,MAAM,CA2JlB;;CACJ;8BA5P6B,4CAA4C"}