@woosh/meep-engine 3.61.1 → 3.61.3

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

@@ -0,0 +1,109 @@
+import { rgb_to_rgbe9995 } from "../../../../../core/color/rgb_to_rgbe9995.js";
+import { NEUTRAL_SURFACE } from "../../../material/resident/NEUTRAL_SURFACE.js";
+import { albedo_compress } from "../../../shader/chunk/material/albedo_compress.js";
+import { metal_rough_compress } from "../../../shader/chunk/material/metal_rough_compress.js";
+import {
+    SURFACE_MATERIAL_ALBEDO_PLANE,
+    SURFACE_MATERIAL_EMISSIVE_PLANE,
+    SURFACE_MATERIAL_METAL_ROUGH_PLANE
+} from "./SURFACE_MATERIAL.js";
+
+/**
+ * @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 = 0;
+    /**
+     * The diffuse albedo's code (`albedo_compress`).
+     * @type {number}
+     */
+    albedo = 0;
+    /**
+     * The metalness and roughness's code (`metal_rough_compress`).
+     * @type {number}
+     */
+    metal_rough = 0;
+    /**
+     * The emissive's code (`rgbe9995_encode`).
+     * @type {number}
+     */
+    emissive = 0;
+}
+
+/**
+ * @param {*} texture
+ * @returns {boolean}
+ */
+function is_set(texture) {
+    return texture !== undefined && texture !== null;
+}
+
+/**
+ * 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, vertex_colored, out) {
+    const surface = material.isStandardShadeMaterial === true ? material : NEUTRAL_SURFACE;
+
+    const color = surface.diffuse_color;
+    const metallic = surface.metallic_factor;
+    const roughness = surface.roughness_factor;
+    const emissive = surface.emissive_factor;
+
+    const orm = is_set(material.texture_orm);
+    const metal_varies = orm && metallic !== 0;
+    const rough_varies = orm && roughness !== 0;
+
+    const diffuse_none = (color[0] === 0 && color[1] === 0 && color[2] === 0) || (!metal_varies && metallic >= 1);
+    const albedo_varies = !diffuse_none && (is_set(material.texture_albedo) || vertex_colored || metal_varies);
+
+    const emissive_varies = is_set(material.texture_emissive) && (emissive[0] !== 0 || emissive[1] !== 0 || emissive[2] !== 0);
+
+    let texels = 0;
+
+    if (albedo_varies) {
+        texels |= 1 << SURFACE_MATERIAL_ALBEDO_PLANE;
+    }
+
+    if (metal_varies || rough_varies) {
+        texels |= 1 << SURFACE_MATERIAL_METAL_ROUGH_PLANE;
+    }
+
+    if (emissive_varies) {
+        texels |= 1 << SURFACE_MATERIAL_EMISSIVE_PLANE;
+    }
+
+    // a constant diffuse albedo has a constant metalness under it, or none at all
+    const kept = diffuse_none ? 0 : 1 - metallic;
+
+    out.texels = texels;
+    out.albedo = albedo_compress(color[0] * kept, color[1] * kept, color[2] * kept);
+    out.metal_rough = metal_rough_compress(metallic, roughness);
+    out.emissive = rgb_to_rgbe9995(emissive[0], emissive[1], emissive[2]);
+
+    return out;
+}

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

@@ -0,0 +1,11 @@
+/**
+ * Model Surface Cache bake, second pass (`MESH_SURFACE_BAKE.js`): one thread, between the list pass and
+ * the trace, which runs a workgroup a listed texel. It writes how many the list holds where the trace
+ * reads its count, and the trace's folded dispatch (`folded_dispatch`). A pass never writes the command
+ * it is dispatched through.
+ *
+ * @type {ComputeShader}
+ */
+export const shader_mesh_surface_command: ComputeShader;
+import { ComputeShader } from "../../../shader/ComputeShader.js";
+//# sourceMappingURL=shader_mesh_surface_command.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"shader_mesh_surface_command.d.ts","sourceRoot":"","sources":["../../../../../../../src/shade/renderer/geometry/sdf/surface/shader_mesh_surface_command.js"],"names":[],"mappings":"AAoBA;;;;;;;GAOG;AACH,0CAFU,aAAa,CAwBpB;8BAhD2B,kCAAkC"}

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

@@ -0,0 +1,51 @@
+import { chunk_folded_dispatch } from "../../../gpu_primitive/indirect/chunk_folded_dispatch.js";
+import { CodeChunk } from "../../../shader/compiler/CodeChunk.js";
+import { ComputeShader } from "../../../shader/ComputeShader.js";
+import { ShaderResourceSetDescriptor } from "../../../shader/resource/ShaderResourceSetDescriptor.js";
+import {
+    MESH_SURFACE_COMMAND_RESOURCE,
+    MESH_SURFACE_COMMAND_SETTINGS,
+    MESH_SURFACE_COUNTER_LISTED,
+    MESH_SURFACE_COUNTER_RESOURCE,
+    MESH_SURFACE_COUNTER_TRACED
+} from "./MESH_SURFACE_BAKE.js";
+
+const resources = new ShaderResourceSetDescriptor();
+
+resources.setImmediate("settings", MESH_SURFACE_COMMAND_SETTINGS);
+
+resources.createGroup()
+    .add(MESH_SURFACE_COUNTER_RESOURCE)
+    .add(MESH_SURFACE_COMMAND_RESOURCE);
+
+/**
+ * Model Surface Cache bake, second pass (`MESH_SURFACE_BAKE.js`): one thread, between the list pass and
+ * the trace, which runs a workgroup a listed texel. It writes how many the list holds where the trace
+ * reads its count, and the trace's folded dispatch (`folded_dispatch`). A pass never writes the command
+ * it is dispatched through.
+ *
+ * @type {ComputeShader}
+ */
+export const shader_mesh_surface_command = ComputeShader.from({
+    label: "Mesh Surface Command",
+    resources,
+    body: CodeChunk.from(
+        //language=WGSL
+        `
+@compute @workgroup_size(1)
+fn main() {
+    let traced = min(atomicLoad(&mesh_surface_counter[${MESH_SURFACE_COUNTER_LISTED}u]), settings.capacity);
+
+    atomicStore(&mesh_surface_counter[${MESH_SURFACE_COUNTER_TRACED}u], traced);
+
+    let folded = folded_dispatch(traced);
+
+    // word by word: the emulator drops a whole-value store into a storage variable
+    mesh_surface_command[0] = folded.x;
+    mesh_surface_command[1] = folded.y;
+    mesh_surface_command[2] = folded.z;
+}
+`, [
+            chunk_folded_dispatch,
+        ]),
+});

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

@@ -0,0 +1,26 @@
+/**
+ * Model Surface Cache bake, fourth pass (`MESH_SURFACE_BAKE.js`): a workgroup a block of the frame's
+ * runs' bricks, 8 a brick, a thread a texel of it, the texel's staging that of its list pass thread. A
+ * block the brick does not keep does nothing.
+ *
+ * A texel holds surface where its staging's albedo code is not 0, and the block's presence takes a bit
+ * for each. Then each plane the cache keeps is coded over those texels (`MESH_SURFACE_BLOCK.js`):
+ *
+ * - **albedo**: two subsets of the texels, each a line through the square roots of its albedos, as
+ *   their codes hold them. The subsets start as the texels at or below the block's mean of r + g + b
+ *   and those above it; then each texel moves to the subset whose line, through the subset's mean
+ *   along its principal axis, is nearer, until none moves or {@link ALBEDO_PARTITION_PASSES} passes.
+ *   Each subset's line runs from its least projection to its greatest, the endpoints rounded to unorm8,
+ *   each texel the nearest of its 8 levels; then the endpoints are fitted again to the levels taken, at
+ *   most {@link ALBEDO_REFITS} times while the subset's error falls.
+ * - **metalness and roughness**: the same line through the (metalness, roughness) pairs, its endpoints
+ *   rounded to 4 bits, each texel the nearest of its 4 levels.
+ * - **emissive**: each texel's code as the trace wrote it, 0 where no surface was found.
+ *
+ * A block of no surface keeps its presence, all clear, and nothing else.
+ *
+ * @type {ComputeShader}
+ */
+export const shader_mesh_surface_encode: ComputeShader;
+import { ComputeShader } from "../../../shader/ComputeShader.js";
+//# sourceMappingURL=shader_mesh_surface_encode.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"shader_mesh_surface_encode.d.ts","sourceRoot":"","sources":["../../../../../../../src/shade/renderer/geometry/sdf/surface/shader_mesh_surface_encode.js"],"names":[],"mappings":"AAuEA;;;;;;;;;;;;;;;;;;;;;;GAsBG;AACH,yCAFU,aAAa,CAwWpB;8BAnc2B,kCAAkC"}

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

@@ -0,0 +1,453 @@
+import { CodeChunk } from "../../../shader/compiler/CodeChunk.js";
+import { ComputeShader } from "../../../shader/ComputeShader.js";
+import { ShaderResourceSetDescriptor } from "../../../shader/resource/ShaderResourceSetDescriptor.js";
+import { MESH_SDF_BRICK_TEXEL_COUNT, MESH_SDF_BRICK_TEXELS } from "../MESH_SDF.js";
+import { chunk_mesh_surface_block_index } from "./chunk_mesh_surface_block.js";
+import { chunk_mesh_surface_run_find } from "./chunk_mesh_surface_run_find.js";
+import {
+    MESH_SURFACE_ENCODE_SETTINGS,
+    MESH_SURFACE_RUNS_RESOURCE,
+    MESH_SURFACE_STAGING_READ_RESOURCE,
+    MESH_SURFACE_STAGING_WORDS,
+    MESH_SURFACE_DATA_WRITE_RESOURCE
+} from "./MESH_SURFACE_BAKE.js";
+import {
+    MESH_SURFACE_ALBEDO_BLOCK_WORDS,
+    MESH_SURFACE_ALBEDO_ENDPOINT_WORDS,
+    MESH_SURFACE_ALBEDO_LEVELS,
+    MESH_SURFACE_BLOCK_TEXEL_COUNT,
+    MESH_SURFACE_BRICK_BLOCKS,
+    MESH_SURFACE_EMISSIVE_BLOCK_WORDS,
+    MESH_SURFACE_METAL_ROUGH_BLOCK_WORDS,
+    MESH_SURFACE_METAL_ROUGH_LEVELS,
+    MESH_SURFACE_NO_BLOCK,
+    MESH_SURFACE_PRESENCE_BLOCK_WORDS
+} from "./MESH_SURFACE_BLOCK.js";
+import { MESH_SURFACE_RECORDS_RESOURCE } from "./MESH_SURFACE_RESOURCES.js";
+import { MESH_SURFACE_STRUCT } from "./MESH_SURFACE_STRUCT.js";
+import {
+    SURFACE_MATERIAL_ALBEDO_PLANE,
+    SURFACE_MATERIAL_EMISSIVE_PLANE,
+    SURFACE_MATERIAL_METAL_ROUGH_PLANE
+} from "./SURFACE_MATERIAL.js";
+
+/**
+ * Times an albedo subset's endpoints are fitted again to the indices they gave, at most: each fit the
+ * least squares of the square roots over the subset's texels, kept while it lowers the error. The
+ * error stops falling after three on Sponza's caches.
+ * @type {number}
+ */
+const ALBEDO_REFITS = 3;
+
+/**
+ * Passes of the albedo's partition into its two subsets, at most: each moves every texel to the subset
+ * whose line is nearer, and the partition is done when no texel moves. The bound stops a block whose
+ * texels keep trading places between the two lines.
+ * @type {number}
+ */
+const ALBEDO_PARTITION_PASSES = 16;
+
+const resources = new ShaderResourceSetDescriptor();
+
+resources.setImmediate("settings", MESH_SURFACE_ENCODE_SETTINGS);
+
+resources.createGroup()
+    .add(MESH_SURFACE_RECORDS_RESOURCE)
+    .add(MESH_SURFACE_RUNS_RESOURCE)
+    .add(MESH_SURFACE_STAGING_READ_RESOURCE)
+    .add(MESH_SURFACE_DATA_WRITE_RESOURCE);
+
+const T = MESH_SDF_BRICK_TEXELS;
+const N = MESH_SURFACE_BLOCK_TEXEL_COUNT;
+const A = MESH_SURFACE_ALBEDO_LEVELS;
+const M = MESH_SURFACE_METAL_ROUGH_LEVELS;
+
+// the workgroup's words: presence, then the albedo's fields, then the metalness and roughness's indices
+const ALBEDO_FIELD_WORDS = MESH_SURFACE_ALBEDO_BLOCK_WORDS - MESH_SURFACE_ALBEDO_ENDPOINT_WORDS;
+const BITS_PRESENCE = 0;
+const BITS_ALBEDO = MESH_SURFACE_PRESENCE_BLOCK_WORDS;
+const BITS_METAL_ROUGH = BITS_ALBEDO + ALBEDO_FIELD_WORDS;
+const BITS = BITS_METAL_ROUGH + MESH_SURFACE_METAL_ROUGH_BLOCK_WORDS - 1;
+
+/**
+ * Model Surface Cache bake, fourth pass (`MESH_SURFACE_BAKE.js`): a workgroup a block of the frame's
+ * runs' bricks, 8 a brick, a thread a texel of it, the texel's staging that of its list pass thread. A
+ * block the brick does not keep does nothing.
+ *
+ * A texel holds surface where its staging's albedo code is not 0, and the block's presence takes a bit
+ * for each. Then each plane the cache keeps is coded over those texels (`MESH_SURFACE_BLOCK.js`):
+ *
+ * - **albedo**: two subsets of the texels, each a line through the square roots of its albedos, as
+ *   their codes hold them. The subsets start as the texels at or below the block's mean of r + g + b
+ *   and those above it; then each texel moves to the subset whose line, through the subset's mean
+ *   along its principal axis, is nearer, until none moves or {@link ALBEDO_PARTITION_PASSES} passes.
+ *   Each subset's line runs from its least projection to its greatest, the endpoints rounded to unorm8,
+ *   each texel the nearest of its 8 levels; then the endpoints are fitted again to the levels taken, at
+ *   most {@link ALBEDO_REFITS} times while the subset's error falls.
+ * - **metalness and roughness**: the same line through the (metalness, roughness) pairs, its endpoints
+ *   rounded to 4 bits, each texel the nearest of its 4 levels.
+ * - **emissive**: each texel's code as the trace wrote it, 0 where no surface was found.
+ *
+ * A block of no surface keeps its presence, all clear, and nothing else.
+ *
+ * @type {ComputeShader}
+ */
+export const shader_mesh_surface_encode = ComputeShader.from({
+    label: "Mesh Surface Encode",
+    resources,
+    body: CodeChunk.from(
+        //language=WGSL
+        `
+/** (block number, the cache's texels, the cache, 0) */
+var<workgroup> encode_job: vec4<u32>;
+var<workgroup> encode_sum: array<vec4<f32>, ${N}>;
+var<workgroup> encode_bits: array<atomic<u32>, ${BITS}>;
+
+fn encode_reduce_sum(local: u32, v: vec4<f32>) -> vec4<f32> {
+    workgroupBarrier();
+    encode_sum[local] = v;
+
+    for (var s = ${N / 2}u; s > 0u; s >>= 1u) {
+        workgroupBarrier();
+
+        if (local < s) {
+            encode_sum[local] += encode_sum[local + s];
+        }
+    }
+
+    return workgroupUniformLoad(&encode_sum[0]);
+}
+
+fn encode_reduce_max(local: u32, v: vec4<f32>) -> vec4<f32> {
+    workgroupBarrier();
+    encode_sum[local] = v;
+
+    for (var s = ${N / 2}u; s > 0u; s >>= 1u) {
+        workgroupBarrier();
+
+        if (local < s) {
+            encode_sum[local] = max(encode_sum[local], encode_sum[local + s]);
+        }
+    }
+
+    return workgroupUniformLoad(&encode_sum[0]);
+}
+
+/** the principal axis of a covariance (xx, xy, xz, yy), (yz, zz) */
+fn encode_axis3(c0: vec4<f32>, c1: vec4<f32>) -> vec3<f32> {
+    var axis = vec3<f32>(0.57735027);
+
+    for (var i = 0u; i < 16u; i++) {
+        let next = vec3<f32>(
+            c0.x * axis.x + c0.y * axis.y + c0.z * axis.z,
+            c0.y * axis.x + c0.w * axis.y + c1.x * axis.z,
+            c0.z * axis.x + c1.x * axis.y + c1.y * axis.z,
+        );
+        let l = length(next);
+
+        if (!(l > 1e-30)) {
+            break;
+        }
+
+        axis = next / l;
+    }
+
+    return axis;
+}
+
+/** the principal axis of a covariance (xx, xy, yy) */
+fn encode_axis2(c: vec4<f32>) -> vec2<f32> {
+    var axis = vec2<f32>(0.70710678);
+
+    for (var i = 0u; i < 16u; i++) {
+        let next = vec2<f32>(c.x * axis.x + c.y * axis.y, c.y * axis.x + c.z * axis.y);
+        let l = length(next);
+
+        if (!(l > 1e-30)) {
+            break;
+        }
+
+        axis = next / l;
+    }
+
+    return axis;
+}
+
+fn encode_unorm8(e: vec3<f32>) -> vec3<f32> {
+    return round(saturate(e) * 255.0) / 255.0;
+}
+
+/** the nearest of the line's levels to a square root */
+fn encode_albedo_level(q: vec3<f32>, e0: vec3<f32>, e1: vec3<f32>) -> u32 {
+    var best = 1e30;
+    var level = 0u;
+
+    for (var k = 0u; k < ${A}u; k++) {
+        let p = mix(e0, e1, f32(k) / ${A - 1}.0);
+        let d = dot(p - q, p - q);
+
+        if (d < best) {
+            best = d;
+            level = k;
+        }
+    }
+
+    return level;
+}
+
+/** a level's error against the texel's albedo, linear, the mean over its channels */
+fn encode_albedo_error(albedo: vec3<f32>, e0: vec3<f32>, e1: vec3<f32>, level: u32) -> f32 {
+    let p = mix(e0, e1, f32(level) / ${A - 1}.0);
+
+    return dot(abs(p * p - albedo), vec3<f32>(1.0 / 3.0));
+}
+
+/** the principal axis of the square roots q of the texels of weight w, 0 or 1, about their mean */
+fn encode_albedo_axis(local: u32, q: vec3<f32>, mean: vec3<f32>, w: f32) -> vec3<f32> {
+    let d = (q - mean) * w;
+    let c0 = encode_reduce_sum(local, vec4<f32>(d.x * d.x, d.x * d.y, d.x * d.z, d.y * d.y));
+    let c1 = encode_reduce_sum(local, vec4<f32>(d.y * d.z, d.z * d.z, 0.0, 0.0));
+
+    return encode_axis3(c0, c1);
+}
+
+struct EncodeAlbedoLine {
+    e0: vec3<f32>,
+    e1: vec3<f32>,
+    /** the texel's level on the line */
+    level: u32,
+}
+
+/** the line of the texels of weight w, 0 or 1, of which there are count, more than 0 */
+fn encode_albedo_line(local: u32, q: vec3<f32>, albedo: vec3<f32>, w: f32, count: f32) -> EncodeAlbedoLine {
+    let mean = encode_reduce_sum(local, vec4<f32>(q * w, 0.0)).xyz / count;
+    let axis = encode_albedo_axis(local, q, mean, w);
+
+    // the least projection as the greatest of its negation
+    let p = dot(q - mean, axis);
+    let ends = encode_reduce_max(local, vec4<f32>(select(-1e30, p, w > 0.0), select(-1e30, -p, w > 0.0), 0.0, 0.0));
+
+    var e0 = encode_unorm8(mean - ends.y * axis);
+    var e1 = encode_unorm8(mean + ends.x * axis);
+    var level = encode_albedo_level(q, e0, e1);
+    var error = encode_reduce_sum(local, vec4<f32>(w * encode_albedo_error(albedo, e0, e1, level), 0.0, 0.0, 0.0)).x;
+
+    for (var refit = 0u; refit < ${ALBEDO_REFITS}u; refit++) {
+        let t = f32(level) / ${A - 1}.0;
+        let s = 1.0 - t;
+        let m = encode_reduce_sum(local, vec4<f32>(w * s * s, w * s * t, w * t * t, 0.0));
+        let x0 = encode_reduce_sum(local, vec4<f32>(w * s * q, 0.0)).xyz;
+        let x1 = encode_reduce_sum(local, vec4<f32>(w * t * q, 0.0)).xyz;
+        let det = m.x * m.z - m.y * m.y;
+
+        if (!(abs(det) > 1e-12)) {
+            break;
+        }
+
+        let f0 = encode_unorm8((m.z * x0 - m.y * x1) / det);
+        let f1 = encode_unorm8((m.x * x1 - m.y * x0) / det);
+        let next = encode_albedo_level(q, f0, f1);
+        let next_error = encode_reduce_sum(local, vec4<f32>(w * encode_albedo_error(albedo, f0, f1, next), 0.0, 0.0, 0.0)).x;
+
+        if (!(next_error < error)) {
+            break;
+        }
+
+        e0 = f0;
+        e1 = f1;
+        level = next;
+        error = next_error;
+    }
+
+    return EncodeAlbedoLine(e0, e1, level);
+}
+
+@compute @workgroup_size(${N})
+fn main(
+    @builtin(workgroup_id) workgroup_id: vec3<u32>,
+    @builtin(local_invocation_index) local: u32,
+) {
+    let job = workgroup_id.y * settings.groups_x + workgroup_id.x;
+    let frame_brick = job / ${MESH_SURFACE_BRICK_BLOCKS}u;
+    let b = job % ${MESH_SURFACE_BRICK_BLOCKS}u;
+
+    if (frame_brick >= settings.brick_count) {
+        return;
+    }
+
+    // the brick's first texel's thread of the list pass
+    let first = frame_brick * ${MESH_SDF_BRICK_TEXEL_COUNT}u;
+
+    if (local == 0u) {
+        let run = mesh_surface_runs[mesh_surface_run_find(settings.run_count, first)];
+        let record = mesh_surface_records[run.y];
+        let number = run.z + (first - run.x) / ${MESH_SDF_BRICK_TEXEL_COUNT}u;
+
+        encode_job = vec4<u32>(mesh_surface_block_number(mesh_surface_data[record.table + number], b), record.texels, run.y, 0u);
+    }
+
+    let taken = workgroupUniformLoad(&encode_job);
+    let block = taken.x;
+
+    if (block == ${MESH_SURFACE_NO_BLOCK}u) {
+        return;
+    }
+
+    let record = mesh_surface_records[taken.z];
+
+    // the texel: local = l.x + 4 (l.y + 4 l.z) of the block, its block's corner in the brick
+    let l = vec3<u32>(local & 3u, (local >> 2u) & 3u, local >> 4u);
+    let t = vec3<u32>(b & 1u, (b >> 1u) & 1u, b >> 2u) * 4u + l;
+    let staged = ${MESH_SURFACE_STAGING_WORDS}u * (first + t.x + ${T}u * (t.y + ${T}u * t.z));
+
+    let albedo_code = mesh_surface_staging[staged];
+    let present = albedo_code != 0u;
+    let pw = select(0.0, 1.0, present);
+
+    if (present) {
+        atomicOr(&encode_bits[${BITS_PRESENCE}u + (local >> 5u)], 1u << (local & 31u));
+    }
+
+    let count = encode_reduce_sum(local, vec4<f32>(pw, 0.0, 0.0, 0.0)).x;
+
+    if (local < ${MESH_SURFACE_PRESENCE_BLOCK_WORDS}u) {
+        mesh_surface_data[record.presence_blocks + block * ${MESH_SURFACE_PRESENCE_BLOCK_WORDS}u + local] = atomicLoad(&encode_bits[${BITS_PRESENCE}u + local]);
+    }
+
+    if (count == 0.0) {
+        return;
+    }
+
+    if ((taken.y & ${1 << SURFACE_MATERIAL_ALBEDO_PLANE}u) != 0u) {
+        let q = unpack4x8unorm(albedo_code).rgb;
+        let albedo = q * q;
+
+        // the subsets: those above the block's mean of r + g + b in 1, then each texel to the nearer line
+        let luma = q.r + q.g + q.b;
+        let luma_mean = encode_reduce_sum(local, vec4<f32>(pw * luma, 0.0, 0.0, 0.0)).x / count;
+        var subset = select(0u, 1u, luma > luma_mean);
+
+        for (var sweep = 0u; sweep < ${ALBEDO_PARTITION_PASSES}u; sweep++) {
+            let in1 = select(0.0, pw, subset == 1u);
+            let in0 = pw - in1;
+            let s0 = encode_reduce_sum(local, vec4<f32>(q * in0, in0));
+            let s1 = encode_reduce_sum(local, vec4<f32>(q * in1, in1));
+
+            if (!(s0.w > 0.0 && s1.w > 0.0)) {
+                break;
+            }
+
+            let m0 = s0.xyz / s0.w;
+            let m1 = s1.xyz / s1.w;
+            let a0 = encode_albedo_axis(local, q, m0, in0);
+            let a1 = encode_albedo_axis(local, q, m1, in1);
+
+            // the squared distance to each line, a tie to subset 0
+            let d0 = q - m0;
+            let d1 = q - m1;
+            let t0 = dot(d0, a0);
+            let t1 = dot(d1, a1);
+            let nearer = select(0u, 1u, dot(d1, d1) - t1 * t1 < dot(d0, d0) - t0 * t0);
+            let moved = encode_reduce_sum(local, vec4<f32>(select(0.0, pw, nearer != subset), 0.0, 0.0, 0.0)).x;
+
+            subset = nearer;
+
+            if (moved == 0.0) {
+                break;
+            }
+        }
+
+        let in1 = select(0.0, pw, subset == 1u);
+        let in0 = pw - in1;
+        let counts = encode_reduce_sum(local, vec4<f32>(in0, in1, 0.0, 0.0));
+        var line0 = EncodeAlbedoLine(vec3<f32>(0.0), vec3<f32>(0.0), 0u);
+        var line1 = EncodeAlbedoLine(vec3<f32>(0.0), vec3<f32>(0.0), 0u);
+
+        if (counts.x > 0.0) {
+            line0 = encode_albedo_line(local, q, albedo, in0, counts.x);
+        }
+
+        if (counts.y > 0.0) {
+            line1 = encode_albedo_line(local, q, albedo, in1, counts.y);
+        }
+
+        // 4 bits a texel after the endpoints, its subset above its level
+        if (present) {
+            let field = select(line0.level, 8u | line1.level, subset == 1u);
+
+            atomicOr(&encode_bits[${BITS_ALBEDO}u + (local >> 3u)], field << (4u * (local & 7u)));
+        }
+
+        workgroupBarrier();
+
+        let at = record.albedo_blocks + block * ${MESH_SURFACE_ALBEDO_BLOCK_WORDS}u;
+
+        if (local == 0u) {
+            mesh_surface_data[at] = pack4x8unorm(vec4<f32>(line0.e0, 0.0));
+            mesh_surface_data[at + 1u] = pack4x8unorm(vec4<f32>(line0.e1, 0.0));
+            mesh_surface_data[at + 2u] = pack4x8unorm(vec4<f32>(line1.e0, 0.0));
+            mesh_surface_data[at + 3u] = pack4x8unorm(vec4<f32>(line1.e1, 0.0));
+        }
+
+        if (local < ${ALBEDO_FIELD_WORDS}u) {
+            mesh_surface_data[at + ${MESH_SURFACE_ALBEDO_ENDPOINT_WORDS}u + local] = atomicLoad(&encode_bits[${BITS_ALBEDO}u + local]);
+        }
+    }
+
+    if ((taken.y & ${1 << SURFACE_MATERIAL_METAL_ROUGH_PLANE}u) != 0u) {
+        let code = mesh_surface_staging[staged + 1u];
+        let mr = vec2<f32>(f32(code & 15u), f32((code >> 4u) & 15u)) / 15.0;
+
+        let mean = encode_reduce_sum(local, vec4<f32>(mr * pw, 0.0, 0.0)).xy / count;
+        let d = (mr - mean) * pw;
+        let axis = encode_axis2(encode_reduce_sum(local, vec4<f32>(d.x * d.x, d.x * d.y, d.y * d.y, 0.0)));
+
+        let p = dot(mr - mean, axis);
+        let ends = encode_reduce_max(local, vec4<f32>(select(-1e30, p, present), select(-1e30, -p, present), 0.0, 0.0));
+
+        // 4 bits each
+        let n0 = round(saturate(mean - ends.y * axis) * 15.0);
+        let n1 = round(saturate(mean + ends.x * axis) * 15.0);
+
+        var best = 1e30;
+        var level = 0u;
+
+        for (var k = 0u; k < ${M}u; k++) {
+            let q = mix(n0, n1, f32(k) / ${M - 1}.0) / 15.0;
+            let e = dot(q - mr, q - mr);
+
+            if (e < best) {
+                best = e;
+                level = k;
+            }
+        }
+
+        if (present) {
+            let bit = 2u * local;
+
+            atomicOr(&encode_bits[${BITS_METAL_ROUGH}u + (bit >> 5u)], level << (bit & 31u));
+        }
+
+        workgroupBarrier();
+
+        let at = record.metal_rough_blocks + block * ${MESH_SURFACE_METAL_ROUGH_BLOCK_WORDS}u;
+
+        if (local == 0u) {
+            mesh_surface_data[at] = u32(n0.x) | (u32(n0.y) << 4u) | (u32(n1.x) << 8u) | (u32(n1.y) << 12u);
+        }
+
+        if (local < ${MESH_SURFACE_METAL_ROUGH_BLOCK_WORDS - 1}u) {
+            mesh_surface_data[at + 1u + local] = atomicLoad(&encode_bits[${BITS_METAL_ROUGH}u + local]);
+        }
+    }
+
+    if ((taken.y & ${1 << SURFACE_MATERIAL_EMISSIVE_PLANE}u) != 0u) {
+        mesh_surface_data[record.emissive_blocks + block * ${MESH_SURFACE_EMISSIVE_BLOCK_WORDS}u + local] = select(0u, mesh_surface_staging[staged + 2u], present);
+    }
+}
+`, [
+            MESH_SURFACE_STRUCT.declaration_chunk,
+            chunk_mesh_surface_block_index,
+            chunk_mesh_surface_run_find,
+        ]),
+});

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

@@ -0,0 +1,12 @@
+/**
+ * Model Surface Cache bake, first pass (`MESH_SURFACE_BAKE.js`): a thread a texel of the frame's runs'
+ * bricks, the bricks a run's cache's field numbered from the run's first number on.
+ *
+ * Every texel's staging, the slot of its thread, is cleared to no surface. A texel that can hold surface
+ * (`mesh_surface_listed`) is listed for the trace, with what it resolved.
+ *
+ * @type {ComputeShader}
+ */
+export const shader_mesh_surface_list: ComputeShader;
+import { ComputeShader } from "../../../shader/ComputeShader.js";
+//# sourceMappingURL=shader_mesh_surface_list.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"shader_mesh_surface_list.d.ts","sourceRoot":"","sources":["../../../../../../../src/shade/renderer/geometry/sdf/surface/shader_mesh_surface_list.js"],"names":[],"mappings":"AA0CA;;;;;;;;GAQG;AACH,uCAFU,aAAa,CAiDpB;8BAjG2B,kCAAkC"}