@woosh/meep-engine 3.61.1 → 3.61.3

package/src/shade/renderer/geometry/sdf/surface/chunk_surface_material_fit.js

@@ -0,0 +1,67 @@
+import { CodeChunk } from "../../../shader/compiler/CodeChunk.js";
+
+/**
+ * A surface material texel fitted from weighted surface samples (`SURFACE_MATERIAL.js`):
+ *
+ * ```wgsl
+ * fn surface_material_fit_add(fit: ptr<function, SurfaceMaterialFit>, weight: f32, albedo: vec3<f32>, metal_rough: vec2<f32>, emissive: vec3<f32>)
+ * fn surface_material_fit_solve(fit: SurfaceMaterialFit) -> SurfaceMaterialFitted
+ * ```
+ *
+ * A sample is a point of the surface under the texel's tent and the material there. Every property is
+ * fitted as a constant, the least-squares one: the samples' weighted mean. The sums add in any order,
+ * so a fit can be split and joined.
+ *
+ * `covered` is false for a fit of no weight: no surface was sampled under the tent.
+ *
+ * @type {CodeChunk}
+ */
+export const chunk_surface_material_fit = CodeChunk.from(
+    //language=WGSL
+    `
+struct SurfaceMaterialFit {
+    weight: f32,
+    /** the weighted sums of the samples' albedos, metalness and roughness, and emissives */
+    albedo: vec3<f32>,
+    metal_rough: vec2<f32>,
+    emissive: vec3<f32>,
+}
+
+struct SurfaceMaterialFitted {
+    covered: bool,
+    albedo: vec3<f32>,
+    /** (metalness, roughness) */
+    metal_rough: vec2<f32>,
+    emissive: vec3<f32>,
+}
+
+fn surface_material_fit_add(
+    fit: ptr<function, SurfaceMaterialFit>,
+    weight: f32,
+    albedo: vec3<f32>,
+    metal_rough: vec2<f32>,
+    emissive: vec3<f32>,
+) {
+    (*fit).weight += weight;
+    (*fit).albedo += weight * albedo;
+    (*fit).metal_rough += weight * metal_rough;
+    (*fit).emissive += weight * emissive;
+}
+
+fn surface_material_fit_solve(fit: SurfaceMaterialFit) -> SurfaceMaterialFitted {
+    var out: SurfaceMaterialFitted;
+
+    if (!(fit.weight > 0.0)) {
+        return out;
+    }
+
+    let inverse_weight = 1.0 / fit.weight;
+
+    out.covered = true;
+    out.albedo = fit.albedo * inverse_weight;
+    out.metal_rough = fit.metal_rough * inverse_weight;
+    out.emissive = fit.emissive * inverse_weight;
+
+    return out;
+}
+`);

package/src/shade/renderer/geometry/sdf/surface/chunk_surface_material_read.d.ts

@@ -0,0 +1,78 @@
+/**
+ * Where a reader stands among a brick's surface material texels (`SURFACE_MATERIAL.js`), and which of
+ * them hold the surface it is on:
+ *
+ * ```wgsl
+ * fn surface_material_point(local: vec3<f32>, distance: f32, normal: vec3<f32>) -> vec3<f32>
+ * fn surface_material_base(point: vec3<f32>) -> vec3<u32>
+ * fn surface_material_corners(distances: texture_3d<f32>, field: vec3<u32>, point: vec3<f32>, present: u32, normal: vec3<f32>, tolerance: f32) -> SurfaceMaterialCorners
+ * fn surface_material_corner_weight(distances: texture_3d<f32>, corners: SurfaceMaterialCorners, corner: vec3<u32>) -> f32
+ * ```
+ *
+ * `local` is a point by the surface in voxels from the brick's corner, a hit's position, `distance` the
+ * field there in voxels and `normal` its normal. `surface_material_point` moves the point onto the
+ * surface by the distance along the normal and holds it to the brick's [0, 7]; the 8 texels around it,
+ * the corners of the voxel from `surface_material_base`, are the ones read. The brick's distances are
+ * the tile of `distances` from texel `field`, the field's encoding over ±{@link MESH_SDF_BAND_VOXELS}
+ * voxels. `present` has bit `c` for each corner `(c & 1, (c >> 1) & 1, c >> 2)` that holds a material,
+ * as the reader's storage says.
+ *
+ * A texel holds the surface its own distance d puts against the normal from it, as a bake looks at
+ * it. The field joins surfaces closer than a voxel, as a banner hanging off a wall, into one; its
+ * texels keep them apart. Of the corners that hold a material and weigh anything, the one whose surface
+ * lies nearest the surface point names the surface the reader is on, and a corner's weight is its
+ * trilinear one where it holds a material and its own surface lies within `tolerance` voxels of that
+ * one, 0 elsewhere: the reader's caller says how near two surfaces may be and still be one to it. The
+ * normal stands in for each corner's own, so a corner whose surface lies off to its side, as just past
+ * a banner's edge, counts it as lying along the normal.
+ *
+ * @type {CodeChunk}
+ */
+export const chunk_surface_material_corners: CodeChunk;
+/**
+ * What a reader's surface takes from a brick's surface material texels kept in all three planes, a
+ * tile of each at the same texel, the albedo plane saying which hold a material (a written code is never
+ * 0): its diffuse albedo and its emissive, and apart its metalness and roughness:
+ *
+ * ```wgsl
+ * fn surface_material_present(albedo_codes: texture_3d<u32>, texel: vec3<u32>) -> u32
+ * fn surface_material_surface(distances: texture_3d<f32>, albedo_codes: texture_3d<u32>, emissive_codes: texture_3d<u32>, material: vec3<u32>, corners: SurfaceMaterialCorners) -> SurfaceMaterialSurface
+ * fn surface_material_metal_rough(distances: texture_3d<f32>, metal_rough_codes: texture_3d<u32>, material: vec3<u32>, corners: SurfaceMaterialCorners) -> SurfaceMaterialMetalRough
+ * ```
+ *
+ * `surface_material_present` is the `present` of the voxel whose least corner is plane texel `texel`, a
+ * tile's origin plus `surface_material_base`. `material` is the tile's origin in the planes. The voxel's
+ * 8 texels (`surface_material_corners`) are blended by their weights: trilinear over those holding the
+ * surface the reader is on, as the field itself is read. `found` is false where none of the 8 holds a
+ * material: no surface sample was near.
+ *
+ * @type {CodeChunk}
+ */
+export const chunk_surface_material_read: CodeChunk;
+/**
+ * What `surface_material_pick` draws when no texel of the voxel weighs anything.
+ * @type {number}
+ */
+export const SURFACE_MATERIAL_NO_CORNER: number;
+/**
+ * One of the voxel's 8 texels (`surface_material_corners`) drawn in proportion to its weight, and its
+ * material: on average what {@link chunk_surface_material_read} blends, from one texel, for a reader
+ * that averages its reads, as a probe averages its rays (Fajardo et al., "Stochastic Texture
+ * Filtering", 2023):
+ *
+ * ```wgsl
+ * fn surface_material_pick(distances: texture_3d<f32>, corners: SurfaceMaterialCorners, u: f32) -> u32
+ * fn surface_material_surface_at(albedo_codes: texture_3d<u32>, emissive_codes: texture_3d<u32>, material: vec3<u32>, corners: SurfaceMaterialCorners, corner: u32) -> SurfaceMaterialSurface
+ * ```
+ *
+ * `surface_material_pick` draws corner `c`, `(c & 1, (c >> 1) & 1, c >> 2)`, with the chance of its
+ * weight (`surface_material_corner_weight`) over the voxel's (`sample_discrete_wrs_mat2x4`), `u`
+ * uniform in [0, 1); a corner of weight 0 is never drawn, and where none weighs anything the draw is
+ * {@link SURFACE_MATERIAL_NO_CORNER}. `surface_material_surface_at` is that corner's diffuse albedo and
+ * emissive, `found` false for none.
+ *
+ * @type {CodeChunk}
+ */
+export const chunk_surface_material_pick: CodeChunk;
+import { CodeChunk } from "../../../shader/compiler/CodeChunk.js";
+//# sourceMappingURL=chunk_surface_material_read.d.ts.map

package/src/shade/renderer/geometry/sdf/surface/chunk_surface_material_read.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"chunk_surface_material_read.d.ts","sourceRoot":"","sources":["../../../../../../../src/shade/renderer/geometry/sdf/surface/chunk_surface_material_read.js"],"names":[],"mappings":"AAQA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA6BG;AACH,6CAFU,SAAS,CAiGZ;AAEP;;;;;;;;;;;;;;;;;;GAkBG;AACH,0CAFU,SAAS,CA0FZ;AAEP;;;GAGG;AACH,yCAFU,MAAM,CAE4B;AAE5C;;;;;;;;;;;;;;;;;;GAkBG;AACH,0CAFU,SAAS,CAoDZ;0BA1TmB,uCAAuC"}

package/src/shade/renderer/geometry/sdf/surface/chunk_surface_material_read.js

@@ -0,0 +1,320 @@
+import { chunk_rgbe9995_decode } from "../../../shader/chunk/color/rgbe9995/chunk_rgbe9995_decode.js";
+import { F32_MAX_DEFINITION } from "../../../shader/chunk/math/F32_MAX_DEFINITION.js";
+import { chunk_albedo_uncompress } from "../../../shader/chunk/material/chunk_albedo_uncompress.js";
+import { chunk_metal_rough_uncompress } from "../../../shader/chunk/material/chunk_metal_rough_uncompress.js";
+import { chunk_sample_discrete_wrs_mat2x4 } from "../../../shader/chunk/random/reservoir/chunk_sample_discrete_wrs_mat2x4.js";
+import { CodeChunk } from "../../../shader/compiler/CodeChunk.js";
+import { MESH_SDF_BAND_VOXELS, MESH_SDF_BRICK_VOXELS } from "../MESH_SDF.js";
+
+/**
+ * Where a reader stands among a brick's surface material texels (`SURFACE_MATERIAL.js`), and which of
+ * them hold the surface it is on:
+ *
+ * ```wgsl
+ * fn surface_material_point(local: vec3<f32>, distance: f32, normal: vec3<f32>) -> vec3<f32>
+ * fn surface_material_base(point: vec3<f32>) -> vec3<u32>
+ * fn surface_material_corners(distances: texture_3d<f32>, field: vec3<u32>, point: vec3<f32>, present: u32, normal: vec3<f32>, tolerance: f32) -> SurfaceMaterialCorners
+ * fn surface_material_corner_weight(distances: texture_3d<f32>, corners: SurfaceMaterialCorners, corner: vec3<u32>) -> f32
+ * ```
+ *
+ * `local` is a point by the surface in voxels from the brick's corner, a hit's position, `distance` the
+ * field there in voxels and `normal` its normal. `surface_material_point` moves the point onto the
+ * surface by the distance along the normal and holds it to the brick's [0, 7]; the 8 texels around it,
+ * the corners of the voxel from `surface_material_base`, are the ones read. The brick's distances are
+ * the tile of `distances` from texel `field`, the field's encoding over ±{@link MESH_SDF_BAND_VOXELS}
+ * voxels. `present` has bit `c` for each corner `(c & 1, (c >> 1) & 1, c >> 2)` that holds a material,
+ * as the reader's storage says.
+ *
+ * A texel holds the surface its own distance d puts against the normal from it, as a bake looks at
+ * it. The field joins surfaces closer than a voxel, as a banner hanging off a wall, into one; its
+ * texels keep them apart. Of the corners that hold a material and weigh anything, the one whose surface
+ * lies nearest the surface point names the surface the reader is on, and a corner's weight is its
+ * trilinear one where it holds a material and its own surface lies within `tolerance` voxels of that
+ * one, 0 elsewhere: the reader's caller says how near two surfaces may be and still be one to it. The
+ * normal stands in for each corner's own, so a corner whose surface lies off to its side, as just past
+ * a banner's edge, counts it as lying along the normal.
+ *
+ * @type {CodeChunk}
+ */
+export const chunk_surface_material_corners = CodeChunk.from(
+    //language=WGSL
+    `
+struct SurfaceMaterialCorners {
+    /** the voxel's least corner, a texel of the brick */
+    base: vec3<u32>,
+    /** the voxel's least corner, a texel of the distances */
+    field: vec3<u32>,
+    /** the surface point within the voxel: the trilinear weights' fraction */
+    fraction: vec3<f32>,
+    normal: vec3<f32>,
+    /** bit c for each corner (c & 1, (c >> 1) & 1, c >> 2) that holds a material */
+    present: u32,
+    /** the surface the reader is on, along the normal from the surface point, voxels */
+    layer: f32,
+    /** how far from it a corner's surface may lie and be the same surface, voxels */
+    tolerance: f32,
+}
+
+fn surface_material_point(local: vec3<f32>, distance: f32, normal: vec3<f32>) -> vec3<f32> {
+    return clamp(local - distance * normal, vec3<f32>(0.0), vec3<f32>(${MESH_SDF_BRICK_VOXELS}.0));
+}
+
+fn surface_material_base(point: vec3<f32>) -> vec3<u32> {
+    return vec3<u32>(min(floor(point), vec3<f32>(${MESH_SDF_BRICK_VOXELS - 1}.0)));
+}
+
+fn surface_material_corner_trilinear(corners: SurfaceMaterialCorners, corner: vec3<u32>) -> f32 {
+    let w = select(1.0 - corners.fraction, corners.fraction, corner == vec3<u32>(1u));
+
+    return w.x * w.y * w.z;
+}
+
+fn surface_material_corner_present(corners: SurfaceMaterialCorners, corner: vec3<u32>) -> bool {
+    return (corners.present & (1u << (corner.x | (corner.y << 1u) | (corner.z << 2u)))) != 0u;
+}
+
+/** the corner's own surface, along the normal from the surface point, voxels */
+fn surface_material_corner_surface(distances: texture_3d<f32>, corners: SurfaceMaterialCorners, corner: vec3<u32>) -> f32 {
+    const band = ${MESH_SDF_BAND_VOXELS}.0;
+
+    let d = fma(textureLoad(distances, corners.field + corner, 0).r, 2.0 * band, -band);
+
+    return -d - dot(corners.normal, corners.fraction - vec3<f32>(corner));
+}
+
+fn surface_material_corners(
+    distances: texture_3d<f32>,
+    field: vec3<u32>,
+    point: vec3<f32>,
+    present: u32,
+    normal: vec3<f32>,
+    tolerance: f32,
+) -> SurfaceMaterialCorners {
+    let base = surface_material_base(point);
+
+    var out: SurfaceMaterialCorners;
+
+    out.base = base;
+    out.field = field + base;
+    out.fraction = point - vec3<f32>(base);
+    out.normal = normal;
+    out.present = present;
+    out.tolerance = tolerance;
+
+    var layer = F32_MAX;
+
+    for (var c = 0u; c < 8u; c++) {
+        let corner = vec3<u32>(c & 1u, (c >> 1u) & 1u, c >> 2u);
+
+        if (surface_material_corner_trilinear(out, corner) > 0.0 && surface_material_corner_present(out, corner)) {
+            let held = surface_material_corner_surface(distances, out, corner);
+
+            if (abs(held) < abs(layer)) {
+                layer = held;
+            }
+        }
+    }
+
+    out.layer = layer;
+
+    return out;
+}
+
+fn surface_material_corner_weight(distances: texture_3d<f32>, corners: SurfaceMaterialCorners, corner: vec3<u32>) -> f32 {
+    if (!surface_material_corner_present(corners, corner)) {
+        return 0.0;
+    }
+
+    let on_layer = abs(surface_material_corner_surface(distances, corners, corner) - corners.layer) <= corners.tolerance;
+
+    return select(0.0, surface_material_corner_trilinear(corners, corner), on_layer);
+}
+`, [
+        F32_MAX_DEFINITION,
+    ]);
+
+/**
+ * What a reader's surface takes from a brick's surface material texels kept in all three planes, a
+ * tile of each at the same texel, the albedo plane saying which hold a material (a written code is never
+ * 0): its diffuse albedo and its emissive, and apart its metalness and roughness:
+ *
+ * ```wgsl
+ * fn surface_material_present(albedo_codes: texture_3d<u32>, texel: vec3<u32>) -> u32
+ * fn surface_material_surface(distances: texture_3d<f32>, albedo_codes: texture_3d<u32>, emissive_codes: texture_3d<u32>, material: vec3<u32>, corners: SurfaceMaterialCorners) -> SurfaceMaterialSurface
+ * fn surface_material_metal_rough(distances: texture_3d<f32>, metal_rough_codes: texture_3d<u32>, material: vec3<u32>, corners: SurfaceMaterialCorners) -> SurfaceMaterialMetalRough
+ * ```
+ *
+ * `surface_material_present` is the `present` of the voxel whose least corner is plane texel `texel`, a
+ * tile's origin plus `surface_material_base`. `material` is the tile's origin in the planes. The voxel's
+ * 8 texels (`surface_material_corners`) are blended by their weights: trilinear over those holding the
+ * surface the reader is on, as the field itself is read. `found` is false where none of the 8 holds a
+ * material: no surface sample was near.
+ *
+ * @type {CodeChunk}
+ */
+export const chunk_surface_material_read = CodeChunk.from(
+    //language=WGSL
+    `
+struct SurfaceMaterialSurface {
+    found: bool,
+    albedo: vec3<f32>,
+    emissive: vec3<f32>,
+}
+
+struct SurfaceMaterialMetalRough {
+    found: bool,
+    /** (metalness, roughness) */
+    metal_rough: vec2<f32>,
+}
+
+fn surface_material_present(albedo_codes: texture_3d<u32>, texel: vec3<u32>) -> u32 {
+    var present = 0u;
+
+    for (var c = 0u; c < 8u; c++) {
+        let corner = vec3<u32>(c & 1u, (c >> 1u) & 1u, c >> 2u);
+
+        if (textureLoad(albedo_codes, texel + corner, 0).x != 0u) {
+            present |= 1u << c;
+        }
+    }
+
+    return present;
+}
+
+fn surface_material_surface(distances: texture_3d<f32>, albedo_codes: texture_3d<u32>, emissive_codes: texture_3d<u32>, material: vec3<u32>, corners: SurfaceMaterialCorners) -> SurfaceMaterialSurface {
+    var albedo = vec3<f32>(0.0);
+    var emissive = vec3<f32>(0.0);
+    var weight = 0.0;
+
+    for (var c = 0u; c < 8u; c++) {
+        let corner = vec3<u32>(c & 1u, (c >> 1u) & 1u, c >> 2u);
+        let w = surface_material_corner_weight(distances, corners, corner);
+
+        if (w > 0.0) {
+            let texel = material + corners.base + corner;
+
+            albedo += w * albedo_uncompress(textureLoad(albedo_codes, texel, 0).x);
+            emissive += w * rgbe9995_decode(textureLoad(emissive_codes, texel, 0).x);
+            weight += w;
+        }
+    }
+
+    var out: SurfaceMaterialSurface;
+
+    out.found = weight > 0.0;
+
+    if (out.found) {
+        out.albedo = albedo / weight;
+        out.emissive = emissive / weight;
+    }
+
+    return out;
+}
+
+fn surface_material_metal_rough(distances: texture_3d<f32>, metal_rough_codes: texture_3d<u32>, material: vec3<u32>, corners: SurfaceMaterialCorners) -> SurfaceMaterialMetalRough {
+    var sum = vec2<f32>(0.0);
+    var weight = 0.0;
+
+    for (var c = 0u; c < 8u; c++) {
+        let corner = vec3<u32>(c & 1u, (c >> 1u) & 1u, c >> 2u);
+        let w = surface_material_corner_weight(distances, corners, corner);
+
+        if (w > 0.0) {
+            sum += w * metal_rough_uncompress(textureLoad(metal_rough_codes, material + corners.base + corner, 0).x);
+            weight += w;
+        }
+    }
+
+    var out: SurfaceMaterialMetalRough;
+
+    out.found = weight > 0.0;
+
+    if (out.found) {
+        out.metal_rough = sum / weight;
+    }
+
+    return out;
+}
+`, [
+        chunk_surface_material_corners,
+        chunk_albedo_uncompress,
+        chunk_rgbe9995_decode,
+        chunk_metal_rough_uncompress,
+    ]);
+
+/**
+ * What `surface_material_pick` draws when no texel of the voxel weighs anything.
+ * @type {number}
+ */
+export const SURFACE_MATERIAL_NO_CORNER = 8;
+
+/**
+ * One of the voxel's 8 texels (`surface_material_corners`) drawn in proportion to its weight, and its
+ * material: on average what {@link chunk_surface_material_read} blends, from one texel, for a reader
+ * that averages its reads, as a probe averages its rays (Fajardo et al., "Stochastic Texture
+ * Filtering", 2023):
+ *
+ * ```wgsl
+ * fn surface_material_pick(distances: texture_3d<f32>, corners: SurfaceMaterialCorners, u: f32) -> u32
+ * fn surface_material_surface_at(albedo_codes: texture_3d<u32>, emissive_codes: texture_3d<u32>, material: vec3<u32>, corners: SurfaceMaterialCorners, corner: u32) -> SurfaceMaterialSurface
+ * ```
+ *
+ * `surface_material_pick` draws corner `c`, `(c & 1, (c >> 1) & 1, c >> 2)`, with the chance of its
+ * weight (`surface_material_corner_weight`) over the voxel's (`sample_discrete_wrs_mat2x4`), `u`
+ * uniform in [0, 1); a corner of weight 0 is never drawn, and where none weighs anything the draw is
+ * {@link SURFACE_MATERIAL_NO_CORNER}. `surface_material_surface_at` is that corner's diffuse albedo and
+ * emissive, `found` false for none.
+ *
+ * @type {CodeChunk}
+ */
+export const chunk_surface_material_pick = CodeChunk.from(
+    //language=WGSL
+    `
+fn surface_material_weight_of(distances: texture_3d<f32>, corners: SurfaceMaterialCorners, c: u32) -> f32 {
+    return surface_material_corner_weight(distances, corners, vec3<u32>(c & 1u, (c >> 1u) & 1u, c >> 2u));
+}
+
+fn surface_material_pick(distances: texture_3d<f32>, corners: SurfaceMaterialCorners, u: f32) -> u32 {
+    // corner c at column c >> 2, row c & 3
+    let weights = mat2x4<f32>(
+        vec4<f32>(
+            surface_material_weight_of(distances, corners, 0u),
+            surface_material_weight_of(distances, corners, 1u),
+            surface_material_weight_of(distances, corners, 2u),
+            surface_material_weight_of(distances, corners, 3u),
+        ),
+        vec4<f32>(
+            surface_material_weight_of(distances, corners, 4u),
+            surface_material_weight_of(distances, corners, 5u),
+            surface_material_weight_of(distances, corners, 6u),
+            surface_material_weight_of(distances, corners, 7u),
+        ),
+    );
+
+    if (all(weights[0] == vec4<f32>(0.0)) && all(weights[1] == vec4<f32>(0.0))) {
+        return ${SURFACE_MATERIAL_NO_CORNER}u;
+    }
+
+    var draw = u;
+
+    return u32(sample_discrete_wrs_mat2x4(weights, &draw));
+}
+
+fn surface_material_surface_at(albedo_codes: texture_3d<u32>, emissive_codes: texture_3d<u32>, material: vec3<u32>, corners: SurfaceMaterialCorners, corner: u32) -> SurfaceMaterialSurface {
+    var out: SurfaceMaterialSurface;
+
+    out.found = corner < ${SURFACE_MATERIAL_NO_CORNER}u;
+
+    if (out.found) {
+        let texel = material + corners.base + vec3<u32>(corner & 1u, (corner >> 1u) & 1u, corner >> 2u);
+
+        out.albedo = albedo_uncompress(textureLoad(albedo_codes, texel, 0).x);
+        out.emissive = rgbe9995_decode(textureLoad(emissive_codes, texel, 0).x);
+    }
+
+    return out;
+}
+`, [
+        chunk_surface_material_read,
+        chunk_sample_discrete_wrs_mat2x4,
+    ]);

package/src/shade/renderer/geometry/sdf/surface/chunk_surface_material_store.d.ts

@@ -0,0 +1,15 @@
+/**
+ * A surface material texel written into its planes (`SURFACE_MATERIAL.js`), each through its own codec:
+ *
+ * ```wgsl
+ * fn surface_material_store(albedo: texture_storage_3d<r32uint, write>, metal_rough: texture_storage_3d<r8uint, write>, emissive: texture_storage_3d<r32uint, write>, at: vec3<u32>, fitted: SurfaceMaterialFitted)
+ * fn surface_material_clear(albedo: texture_storage_3d<r32uint, write>, metal_rough: texture_storage_3d<r8uint, write>, emissive: texture_storage_3d<r32uint, write>, at: vec3<u32>)
+ * ```
+ *
+ * `at` is the texel in the planes' atlas. A fit that covered nothing clears: 0 in every plane, no material.
+ *
+ * @type {CodeChunk}
+ */
+export const chunk_surface_material_store: CodeChunk;
+import { CodeChunk } from "../../../shader/compiler/CodeChunk.js";
+//# sourceMappingURL=chunk_surface_material_store.d.ts.map

package/src/shade/renderer/geometry/sdf/surface/chunk_surface_material_store.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"chunk_surface_material_store.d.ts","sourceRoot":"","sources":["../../../../../../../src/shade/renderer/geometry/sdf/surface/chunk_surface_material_store.js"],"names":[],"mappings":"AAWA;;;;;;;;;;;GAWG;AACH,2CAFU,SAAS,CA0BZ;0BA5CmB,uCAAuC"}

package/src/shade/renderer/geometry/sdf/surface/chunk_surface_material_store.js

@@ -0,0 +1,48 @@
+import { chunk_rgbe9995_encode } from "../../../shader/chunk/color/rgbe9995/chunk_rgbe9995_encode.js";
+import { chunk_albedo_compress } from "../../../shader/chunk/material/chunk_albedo_compress.js";
+import { chunk_metal_rough_compress } from "../../../shader/chunk/material/chunk_metal_rough_compress.js";
+import { CodeChunk } from "../../../shader/compiler/CodeChunk.js";
+import { chunk_surface_material_fit } from "./chunk_surface_material_fit.js";
+import { SURFACE_MATERIAL_ALBEDO_PLANE, SURFACE_MATERIAL_EMISSIVE_PLANE, SURFACE_MATERIAL_FORMATS, SURFACE_MATERIAL_METAL_ROUGH_PLANE } from "./SURFACE_MATERIAL.js";
+
+const ALBEDO = `texture_storage_3d<${SURFACE_MATERIAL_FORMATS[SURFACE_MATERIAL_ALBEDO_PLANE]}, write>`;
+const METAL_ROUGH = `texture_storage_3d<${SURFACE_MATERIAL_FORMATS[SURFACE_MATERIAL_METAL_ROUGH_PLANE]}, write>`;
+const EMISSIVE = `texture_storage_3d<${SURFACE_MATERIAL_FORMATS[SURFACE_MATERIAL_EMISSIVE_PLANE]}, write>`;
+
+/**
+ * A surface material texel written into its planes (`SURFACE_MATERIAL.js`), each through its own codec:
+ *
+ * ```wgsl
+ * fn surface_material_store(albedo: texture_storage_3d<r32uint, write>, metal_rough: texture_storage_3d<r8uint, write>, emissive: texture_storage_3d<r32uint, write>, at: vec3<u32>, fitted: SurfaceMaterialFitted)
+ * fn surface_material_clear(albedo: texture_storage_3d<r32uint, write>, metal_rough: texture_storage_3d<r8uint, write>, emissive: texture_storage_3d<r32uint, write>, at: vec3<u32>)
+ * ```
+ *
+ * `at` is the texel in the planes' atlas. A fit that covered nothing clears: 0 in every plane, no material.
+ *
+ * @type {CodeChunk}
+ */
+export const chunk_surface_material_store = CodeChunk.from(
+    //language=WGSL
+    `
+fn surface_material_clear(albedo: ${ALBEDO}, metal_rough: ${METAL_ROUGH}, emissive: ${EMISSIVE}, at: vec3<u32>) {
+    textureStore(albedo, at, vec4<u32>(0u));
+    textureStore(metal_rough, at, vec4<u32>(0u));
+    textureStore(emissive, at, vec4<u32>(0u));
+}
+
+fn surface_material_store(albedo: ${ALBEDO}, metal_rough: ${METAL_ROUGH}, emissive: ${EMISSIVE}, at: vec3<u32>, fitted: SurfaceMaterialFitted) {
+    if (!fitted.covered) {
+        surface_material_clear(albedo, metal_rough, emissive, at);
+        return;
+    }
+
+    textureStore(albedo, at, vec4<u32>(albedo_compress(fitted.albedo), 0u, 0u, 0u));
+    textureStore(metal_rough, at, vec4<u32>(metal_rough_compress(fitted.metal_rough), 0u, 0u, 0u));
+    textureStore(emissive, at, vec4<u32>(rgbe9995_encode(fitted.emissive), 0u, 0u, 0u));
+}
+`, [
+        chunk_surface_material_fit,
+        chunk_albedo_compress,
+        chunk_metal_rough_compress,
+        chunk_rgbe9995_encode,
+    ]);

package/src/shade/renderer/geometry/sdf/surface/mesh_surface_channels.d.ts

@@ -0,0 +1,51 @@
+/**
+ * Which planes of a pair's surface material vary, and the codes of every plane at the material's own
+ * values, as the bake's material sample makes them (`sample_material_data`, `shader_mesh_surface_trace`):
+ *
+ * - the diffuse albedo, base × (1 − metalness), the base the albedo texture × the diffuse color × the
+ *   vertex color;
+ * - the metalness and the roughness, the ORM texture's blue and green × their factors;
+ * - the emissive, the emissive texture × its factor.
+ *
+ * A material's missing texture is a white texel, its missing ORM texture too, as its resident row reads
+ * it; a material that is not standard is {@link NEUTRAL_SURFACE} over its textures. A product varies
+ * where one of its terms does and none of them is 0 throughout: a metalness of 1 throughout leaves no
+ * diffuse albedo to vary. The codes are taken without the bake's dither.
+ *
+ * @param {ShadeMaterial} material
+ * @param {boolean} vertex_colored whether the geometry's vertices carry a color other than white
+ * @param {MeshSurfaceChannels} out
+ * @returns {MeshSurfaceChannels} out
+ */
+export function mesh_surface_channels(material: ShadeMaterial, vertex_colored: boolean, out: MeshSurfaceChannels): MeshSurfaceChannels;
+/**
+ * @typedef {import("../../../material/ShadeMaterial.js").ShadeMaterial} ShadeMaterial
+ */
+/**
+ * What a (geometry, material) pair's surface material is made of: which planes vary over its surface,
+ * and the code each plane takes everywhere when it does not.
+ */
+export class MeshSurfaceChannels {
+    /**
+     * Bit `1 << plane` for each plane (`SURFACE_MATERIAL.js`) that varies over the surface.
+     * @type {number}
+     */
+    texels: number;
+    /**
+     * The diffuse albedo's code (`albedo_compress`).
+     * @type {number}
+     */
+    albedo: number;
+    /**
+     * The metalness and roughness's code (`metal_rough_compress`).
+     * @type {number}
+     */
+    metal_rough: number;
+    /**
+     * The emissive's code (`rgbe9995_encode`).
+     * @type {number}
+     */
+    emissive: number;
+}
+export type ShadeMaterial = import("../../../material/ShadeMaterial.js").ShadeMaterial;
+//# sourceMappingURL=mesh_surface_channels.d.ts.map

package/src/shade/renderer/geometry/sdf/surface/mesh_surface_channels.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"mesh_surface_channels.d.ts","sourceRoot":"","sources":["../../../../../../../src/shade/renderer/geometry/sdf/surface/mesh_surface_channels.js"],"names":[],"mappings":"AAiDA;;;;;;;;;;;;;;;;;;GAkBG;AACH,gDALW,aAAa,kBACb,OAAO,OACP,mBAAmB,GACjB,mBAAmB,CA0C/B;AAlGD;;GAEG;AAEH;;;GAGG;AACH;IACI;;;OAGG;IACH,QAFU,MAAM,CAEL;IACX;;;OAGG;IACH,QAFU,MAAM,CAEL;IACX;;;OAGG;IACH,aAFU,MAAM,CAEA;IAChB;;;OAGG;IACH,UAFU,MAAM,CAEH;CAChB;4BA5BY,OAAO,oCAAoC,EAAE,aAAa"}