@woosh/meep-engine 3.57.0 → 3.58.0

package/src/shade/renderer/geometry/sdf/bake/MESH_SDF_BAKE.js

@@ -0,0 +1,110 @@
+import { MESH_SDF_BRICK_TEXEL_COUNT, MESH_SDF_BRICK_VOXELS } from "../MESH_SDF.js";
+
+/*
+ The bake's device state (PROBE_CLIPMAP_PROPOSAL_2026_10_27.md §6.4), shared by its passes:
+
+   classify: one thread a brick of the geometries admitted this frame. A brick no texel of which can
+             be within the band is EMPTY; the rest go onto the ring.
+   take:     one thread. Up to the budget off the ring, and no more than the stack has free slots, so
+             that no pop below can fail.
+   evaluate: a thread a texel of each brick taken, MESH_SDF_GROUPS_PER_BRICK workgroups a brick, into
+             staging. The brick's last thread to finish gives it a slot or EMPTY.
+   store:    a thread a texel of each brick taken, from staging into the brick's slot.
+
+ A geometry's bricks are counted down in its pending word from its brick count, one as classify drops
+ a brick and one as evaluate settles it, and the one that reaches zero logs the geometry complete.
+
+ The passes bind few buffers, so that evaluate stays within the ten storage buffers a stage has on
+ SHADE_DEVICE_FLOOR beside the five a BLAS query reads. Two of them carry more than their name:
+
+   mesh_sdf_indirection, the arena of every brick's entry, which the bake views as atomics, holds at
+     word 0 the counters (MESH_SDF_COUNTER_*); at `log_offset` the frame's log (MESH_SDF_LOG_*), and
+     at `tally_offset` the frame's tallies, a word a brick taken; and a geometry's pending word just
+     before its first entry, `header.indirection - 1`;
+   mesh_sdf_ring holds the ring's entries, then from `ring_capacity` on the frame's staging,
+     MESH_SDF_STAGING_VEC4S a brick taken.
+*/
+
+/**
+ * Lanes of every bake workgroup: a block of a brick's texels in evaluate and store, and a run of
+ * classify or free threads.
+ * @type {number}
+ */
+export const MESH_SDF_BAKE_WORKGROUP_SIZE = 64;
+
+/**
+ * Evaluate and store workgroups per brick: its texels, one a thread.
+ * @type {number}
+ */
+export const MESH_SDF_GROUPS_PER_BRICK = MESH_SDF_BRICK_TEXEL_COUNT / MESH_SDF_BAKE_WORKGROUP_SIZE;
+
+/**
+ * A brick's texels as staged between evaluate and store, a word a texel, so that no two threads
+ * write one word.
+ * @type {number}
+ */
+export const MESH_SDF_STAGING_WORDS = MESH_SDF_BRICK_TEXEL_COUNT;
+
+/**
+ * The same, in the ring's `vec4<u32>` entries.
+ * @type {number}
+ */
+export const MESH_SDF_STAGING_VEC4S = MESH_SDF_STAGING_WORDS / 4;
+
+/**
+ * The distance from a brick's centre to its farthest texel, in the level's voxels: 3.5·√3 = 6.0622,
+ * rounded up to a sixteenth, so that float rounding never brings a texel in reach of the band past
+ * what classify allowed for.
+ * @type {number}
+ */
+export const MESH_SDF_BRICK_HALF_DIAGONAL = Math.ceil(MESH_SDF_BRICK_VOXELS / 2 * Math.sqrt(3) * 16) / 16;
+
+/** The arena's counters, from word 0: free slots on the stack. */
+export const MESH_SDF_COUNTER_SLOTS = 0;
+/** The arena's counters: the ring position take has consumed up to. */
+export const MESH_SDF_COUNTER_HEAD = 1;
+/** The arena's counters: the ring position classify appends at. */
+export const MESH_SDF_COUNTER_TAIL = 2;
+/** The arena's counters, in words: its first allocation. */
+export const MESH_SDF_COUNTER_WORDS = 4;
+
+/** `take`: the dispatch of evaluate and of store, three words: MESH_SDF_GROUPS_PER_BRICK a brick taken. */
+export const MESH_SDF_TAKE_DISPATCH = 0;
+/** `take`: the ring position of the first brick taken. */
+export const MESH_SDF_TAKE_START = 3;
+/** `take`: the dispatch of card placement's page pass, three words: a thread a column, as its merge found. */
+export const MESH_SDF_TAKE_PLACE_DISPATCH = 4;
+/** `take`, in words. */
+export const MESH_SDF_TAKE_WORDS = 8;
+
+/** `log`: bricks left on the ring after the frame's take, stale ones included. */
+export const MESH_SDF_LOG_QUEUED = 0;
+/** `log`: 1 when the take was held back by the free slots, which asks the host for more. */
+export const MESH_SDF_LOG_STARVED = 1;
+/** `log`: free slots before the take. */
+export const MESH_SDF_LOG_FREE_SLOTS = 2;
+/** `log`: bricks the take handed to evaluate. */
+export const MESH_SDF_LOG_TAKEN = 3;
+/** `log`: geometries completed this frame; their records follow the header. */
+export const MESH_SDF_LOG_COMPLETIONS = 4;
+/** `log`: words before the first record. */
+export const MESH_SDF_LOG_HEADER_WORDS = 5;
+/**
+ * `log`: words a record: the geometry id, the generation it was baked at, and what the record
+ * reports. A completion reports nothing; a placement, marked by MESH_SDF_LOG_PLACED on the id,
+ * reports the columns and the pages its cards took.
+ */
+export const MESH_SDF_LOG_RECORD_WORDS = 4;
+
+/**
+ * `log`: the mark on a record's geometry id that says its cards were placed. Geometry ids stay below it.
+ * @type {number}
+ */
+export const MESH_SDF_LOG_PLACED = 0x80000000;
+
+/**
+ * A tally, a workgroup's of its lanes and a brick's of its workgroups: the low half counts those
+ * finished, the high half those with a texel within the band, in this unit.
+ * @type {number}
+ */
+export const MESH_SDF_TALLY_BAND_UNIT = 65536;

package/src/shade/renderer/geometry/sdf/bake/chunk_mesh_sdf_bake.d.ts

@@ -0,0 +1,48 @@
+/**
+ * The indirection arena as the bake sees it: every word an atomic, the counters at word 0, the
+ * frame's log at `log_offset` and its tallies at `tally_offset`, and a geometry's pending word before its
+ * entries (`MESH_SDF_BAKE.js`).
+ * Readers bind the same buffer as plain words, through `MESH_SDF_INDIRECTION_RESOURCE`.
+ * @type {ShaderResourceDescriptor}
+ */
+export const MESH_SDF_ARENA_RESOURCE: ShaderResourceDescriptor;
+/**
+ * Runs of bricks or entries, one `vec2<u32>` a run: the run's first thread, then what it is the run
+ * of — a geometry id for classify, an indirection offset for free. The first run starts at thread 0.
+ * @type {ShaderResourceDescriptor}
+ */
+export const MESH_SDF_RANGES_RESOURCE: ShaderResourceDescriptor;
+/**
+ * The bake's layout as WGSL constants ({@link MESH_SDF_BAKE_WORKGROUP_SIZE} and the word indices of
+ * `MESH_SDF_BAKE.js`), on {@link chunk_mesh_sdf}.
+ *
+ * @type {CodeChunk}
+ */
+export const chunk_mesh_sdf_bake: CodeChunk;
+/**
+ * Counts a brick of a geometry settled, and logs the geometry complete, at the generation it was
+ * baked at, when the brick is its last. The log is the frame's, at `log_offset` in the arena; a
+ * record past `log_capacity` is dropped and still counted, so a count above the capacity says the log
+ * overflowed.
+ *
+ * ```wgsl
+ * fn mesh_sdf_bake_settle(header: MeshSDF, geometry: u32, log_offset: u32, log_capacity: u32)
+ * ```
+ *
+ * @type {CodeChunk}
+ */
+export const chunk_mesh_sdf_bake_settle: CodeChunk;
+/**
+ * The run a thread falls in: the last of the first `count` runs whose first thread is at or below
+ * `thread`. A binary search, ⌈log₂ count⌉ steps.
+ *
+ * ```wgsl
+ * fn mesh_sdf_range_find(count: u32, thread: u32) -> u32
+ * ```
+ *
+ * @type {CodeChunk}
+ */
+export const chunk_mesh_sdf_range_find: CodeChunk;
+import { ShaderResourceDescriptor } from "../../../shader/resource/ShaderResourceDescriptor.js";
+import { CodeChunk } from "../../../shader/compiler/CodeChunk.js";
+//# sourceMappingURL=chunk_mesh_sdf_bake.d.ts.map

package/src/shade/renderer/geometry/sdf/bake/chunk_mesh_sdf_bake.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"chunk_mesh_sdf_bake.d.ts","sourceRoot":"","sources":["../../../../../../../src/shade/renderer/geometry/sdf/bake/chunk_mesh_sdf_bake.js"],"names":[],"mappings":"AA0BA;;;;;;GAMG;AACH,sCAFU,wBAAwB,CAEwG;AAE1I;;;;GAIG;AACH,uCAFU,wBAAwB,CAEyF;AAE3H;;;;;GAKG;AACH,kCAFU,SAAS,CA2BZ;AAEP;;;;;;;;;;;GAWG;AACH,yCAFU,SAAS,CAwBZ;AAIP;;;;;;;;;GASG;AACH,wCAFU,SAAS,CAsBhB;yCA9IsC,sDAAsD;0BADrE,uCAAuC"}

package/src/shade/renderer/geometry/sdf/bake/chunk_mesh_sdf_bake.js

@@ -0,0 +1,146 @@
+import { CodeChunk } from "../../../shader/compiler/CodeChunk.js";
+import { ShaderResourceDescriptor } from "../../../shader/resource/ShaderResourceDescriptor.js";
+import { atomic_u32, vec2u } from "../../../shader/type/WEBGPU_WGSL_PRIMITIVE_TYPES.js";
+import { WebGPUArray } from "../../../shader/type/WebGPUArray.js";
+import { chunk_mesh_sdf } from "../chunk_mesh_sdf.js";
+import { MESH_SDF_STRUCT } from "../MESH_SDF_STRUCT.js";
+import {
+    MESH_SDF_BAKE_WORKGROUP_SIZE,
+    MESH_SDF_BRICK_HALF_DIAGONAL,
+    MESH_SDF_COUNTER_HEAD,
+    MESH_SDF_COUNTER_SLOTS,
+    MESH_SDF_COUNTER_TAIL,
+    MESH_SDF_LOG_COMPLETIONS,
+    MESH_SDF_LOG_FREE_SLOTS,
+    MESH_SDF_LOG_HEADER_WORDS,
+    MESH_SDF_LOG_QUEUED,
+    MESH_SDF_LOG_RECORD_WORDS,
+    MESH_SDF_LOG_STARVED,
+    MESH_SDF_LOG_TAKEN,
+    MESH_SDF_GROUPS_PER_BRICK,
+    MESH_SDF_STAGING_VEC4S,
+    MESH_SDF_TAKE_DISPATCH,
+    MESH_SDF_TAKE_START,
+    MESH_SDF_TALLY_BAND_UNIT
+} from "./MESH_SDF_BAKE.js";
+
+/**
+ * The indirection arena as the bake sees it: every word an atomic, the counters at word 0, the
+ * frame's log at `log_offset` and its tallies at `tally_offset`, and a geometry's pending word before its
+ * entries (`MESH_SDF_BAKE.js`).
+ * Readers bind the same buffer as plain words, through `MESH_SDF_INDIRECTION_RESOURCE`.
+ * @type {ShaderResourceDescriptor}
+ */
+export const MESH_SDF_ARENA_RESOURCE = ShaderResourceDescriptor.storageBuffer("mesh_sdf_indirection", WebGPUArray.from(atomic_u32), true);
+
+/**
+ * Runs of bricks or entries, one `vec2<u32>` a run: the run's first thread, then what it is the run
+ * of — a geometry id for classify, an indirection offset for free. The first run starts at thread 0.
+ * @type {ShaderResourceDescriptor}
+ */
+export const MESH_SDF_RANGES_RESOURCE = ShaderResourceDescriptor.storageBuffer("mesh_sdf_ranges", WebGPUArray.from(vec2u));
+
+/**
+ * The bake's layout as WGSL constants ({@link MESH_SDF_BAKE_WORKGROUP_SIZE} and the word indices of
+ * `MESH_SDF_BAKE.js`), on {@link chunk_mesh_sdf}.
+ *
+ * @type {CodeChunk}
+ */
+export const chunk_mesh_sdf_bake = CodeChunk.from(
+    //language=WGSL
+    `
+const MESH_SDF_BAKE_WORKGROUP_SIZE = ${MESH_SDF_BAKE_WORKGROUP_SIZE}u;
+const MESH_SDF_GROUPS_PER_BRICK = ${MESH_SDF_GROUPS_PER_BRICK}u;
+const MESH_SDF_STAGING_VEC4S = ${MESH_SDF_STAGING_VEC4S}u;
+const MESH_SDF_TALLY_BAND_UNIT = ${MESH_SDF_TALLY_BAND_UNIT}u;
+const MESH_SDF_BRICK_HALF_DIAGONAL = ${MESH_SDF_BRICK_HALF_DIAGONAL};
+
+const MESH_SDF_COUNTER_SLOTS = ${MESH_SDF_COUNTER_SLOTS}u;
+const MESH_SDF_COUNTER_HEAD = ${MESH_SDF_COUNTER_HEAD}u;
+const MESH_SDF_COUNTER_TAIL = ${MESH_SDF_COUNTER_TAIL}u;
+
+const MESH_SDF_TAKE_DISPATCH = ${MESH_SDF_TAKE_DISPATCH}u;
+const MESH_SDF_TAKE_START = ${MESH_SDF_TAKE_START}u;
+
+const MESH_SDF_LOG_QUEUED = ${MESH_SDF_LOG_QUEUED}u;
+const MESH_SDF_LOG_STARVED = ${MESH_SDF_LOG_STARVED}u;
+const MESH_SDF_LOG_FREE_SLOTS = ${MESH_SDF_LOG_FREE_SLOTS}u;
+const MESH_SDF_LOG_TAKEN = ${MESH_SDF_LOG_TAKEN}u;
+const MESH_SDF_LOG_COMPLETIONS = ${MESH_SDF_LOG_COMPLETIONS}u;
+const MESH_SDF_LOG_HEADER_WORDS = ${MESH_SDF_LOG_HEADER_WORDS}u;
+const MESH_SDF_LOG_RECORD_WORDS = ${MESH_SDF_LOG_RECORD_WORDS}u;
+`, [
+        chunk_mesh_sdf,
+    ]);
+
+/**
+ * Counts a brick of a geometry settled, and logs the geometry complete, at the generation it was
+ * baked at, when the brick is its last. The log is the frame's, at `log_offset` in the arena; a
+ * record past `log_capacity` is dropped and still counted, so a count above the capacity says the log
+ * overflowed.
+ *
+ * ```wgsl
+ * fn mesh_sdf_bake_settle(header: MeshSDF, geometry: u32, log_offset: u32, log_capacity: u32)
+ * ```
+ *
+ * @type {CodeChunk}
+ */
+export const chunk_mesh_sdf_bake_settle = CodeChunk.from(
+    //language=WGSL
+    `
+fn mesh_sdf_bake_settle(header: ${MESH_SDF_STRUCT.wgsl_ref}, geometry: u32, log_offset: u32, log_capacity: u32) {
+    // the geometry's pending word sits just before its first entry
+    if (atomicSub(&mesh_sdf_indirection[header.indirection - 1u], 1u) != 1u) {
+        return;
+    }
+
+    let record = atomicAdd(&mesh_sdf_indirection[log_offset + MESH_SDF_LOG_COMPLETIONS], 1u);
+
+    if (record >= log_capacity) {
+        return;
+    }
+
+    let word = log_offset + MESH_SDF_LOG_HEADER_WORDS + record * MESH_SDF_LOG_RECORD_WORDS;
+
+    atomicStore(&mesh_sdf_indirection[word], geometry);
+    atomicStore(&mesh_sdf_indirection[word + 1u], header.generation);
+}
+`, [
+        chunk_mesh_sdf_bake,
+    ]);
+
+chunk_mesh_sdf_bake_settle.requireResource(MESH_SDF_ARENA_RESOURCE);
+
+/**
+ * The run a thread falls in: the last of the first `count` runs whose first thread is at or below
+ * `thread`. A binary search, ⌈log₂ count⌉ steps.
+ *
+ * ```wgsl
+ * fn mesh_sdf_range_find(count: u32, thread: u32) -> u32
+ * ```
+ *
+ * @type {CodeChunk}
+ */
+export const chunk_mesh_sdf_range_find = CodeChunk.from(
+    //language=WGSL
+    `
+fn mesh_sdf_range_find(count: u32, thread: u32) -> u32 {
+    // the answer is in [low, high), and run low starts at or below the thread
+    var low = 0u;
+    var high = count;
+
+    while (high - low > 1u) {
+        let middle = (low + high) / 2u;
+
+        if (mesh_sdf_ranges[middle].x <= thread) {
+            low = middle;
+        } else {
+            high = middle;
+        }
+    }
+
+    return low;
+}
+`);
+
+chunk_mesh_sdf_range_find.requireResource(MESH_SDF_RANGES_RESOURCE);

package/src/shade/renderer/geometry/sdf/bake/shader_mesh_sdf_classify.d.ts

@@ -0,0 +1,31 @@
+/**
+ * The geometry tables a BLAS query reads, by the names the query chunks take them by: five storage
+ * buffers.
+ *
+ * @param {import("../../../shader/resource/ShaderResourceGroupDescriptor.js").ShaderResourceGroupDescriptor} group
+ */
+export function mesh_sdf_add_blas_resources(group: import("../../../shader/resource/ShaderResourceGroupDescriptor.js").ShaderResourceGroupDescriptor): void;
+/**
+ * @type {WebGPUStruct}
+ */
+export const MESH_SDF_CLASSIFY_SETTINGS: WebGPUStruct;
+/**
+ * Bake step 1, classify (PROBE_CLIPMAP_PROPOSAL_2026_10_27.md §6.4): one thread a brick of every
+ * geometry admitted this frame, a run each in `mesh_sdf_ranges`.
+ *
+ * One BLAS query a brick, for the nearest point within the band plus the brick's half-diagonal of its
+ * centre. Past that no texel of the brick can be within the band, and the brick is EMPTY: outside,
+ * whichever side of the surface it is on, since the vote casts no ray where the surface is not within
+ * the band (UE 5.4's). Otherwise the brick goes onto the ring as `(geometry, generation, brick, 0)`,
+ * for evaluate to settle. Either way its entry starts EMPTY, which is what a freed range must find in
+ * an entry never stored.
+ *
+ * A dropped brick is settled here: it counts its geometry's pending word down, and the last brick of
+ * a geometry to settle logs it complete.
+ *
+ * @type {ComputeShader}
+ */
+export const shader_mesh_sdf_classify: ComputeShader;
+import { WebGPUStruct } from "../../../shader/type/WebGPUStruct.js";
+import { ComputeShader } from "../../../shader/ComputeShader.js";
+//# sourceMappingURL=shader_mesh_sdf_classify.d.ts.map

package/src/shade/renderer/geometry/sdf/bake/shader_mesh_sdf_classify.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"shader_mesh_sdf_classify.d.ts","sourceRoot":"","sources":["../../../../../../../src/shade/renderer/geometry/sdf/bake/shader_mesh_sdf_classify.js"],"names":[],"mappings":"AAyCA;;;;;GAKG;AACH,mDAFW,OAAO,2DAA2D,EAAE,6BAA6B,QAS3G;AA/BD;;GAEG;AACH,yCAFU,YAAY,CAeQ;AA6B9B;;;;;;;;;;;;;;;GAeG;AACH,uCAFU,aAAa,CAqDpB;6BA9H0B,sCAAsC;8BAJrC,kCAAkC"}

package/src/shade/renderer/geometry/sdf/bake/shader_mesh_sdf_classify.js

@@ -0,0 +1,136 @@
+import { UINT32_MAX } from "../../../../../core/binary/UINT32_MAX.js";
+import { BVH2_NODE_STRUCT } from "../../../shader/chunk/bvh/BVH2_NODE_STRUCT.js";
+import { BVH_TRAVERSAL_STACK_SIZE } from "../../../shader/chunk/bvh/BVH_TRAVERSAL_STACK_SIZE.js";
+import { chunk_point_query_blas_nearest } from "../../../shader/chunk/sdf/chunk_point_query_blas_nearest.js";
+import { CodeChunk } from "../../../shader/compiler/CodeChunk.js";
+import { ComputeShader } from "../../../shader/ComputeShader.js";
+import { ShaderResourceSetDescriptor } from "../../../shader/resource/ShaderResourceSetDescriptor.js";
+import { u32, vec4u } from "../../../shader/type/WEBGPU_WGSL_PRIMITIVE_TYPES.js";
+import { WebGPUArray } from "../../../shader/type/WebGPUArray.js";
+import { WebGPUStruct } from "../../../shader/type/WebGPUStruct.js";
+import { GEOMETRY_ATTRIBUTE_DATA_RESOURCE } from "../../GEOMETRY_ATTRIBUTE_DATA_RESOURCE.js";
+import { GEOMETRY_METADATA_STRUCT } from "../../GEOMETRY_METADATA_STRUCT.js";
+import { MESHLET_METADATA_RESOURCE } from "../../meshlet/MESHLET_METADATA_RESOURCE.js";
+import { MESH_SDF_HEADERS_RESOURCE } from "../MESH_SDF_RESOURCES.js";
+import {
+    chunk_mesh_sdf_bake,
+    chunk_mesh_sdf_bake_settle,
+    chunk_mesh_sdf_range_find,
+    MESH_SDF_ARENA_RESOURCE,
+    MESH_SDF_RANGES_RESOURCE
+} from "./chunk_mesh_sdf_bake.js";
+import { MESH_SDF_BAKE_WORKGROUP_SIZE } from "./MESH_SDF_BAKE.js";
+
+/**
+ * @type {WebGPUStruct}
+ */
+export const MESH_SDF_CLASSIFY_SETTINGS = WebGPUStruct.from({
+    /** runs in `mesh_sdf_ranges`, a geometry each */
+    range_count: u32,
+    /** bricks over every run: the threads that do work */
+    brick_count: u32,
+    /** workgroups along x, the rest folded into y */
+    groups_x: u32,
+    /** entries of `mesh_sdf_ring`, a power of two */
+    ring_capacity: u32,
+    /** where the frame's log starts in the arena */
+    log_offset: u32,
+    /** records the log holds */
+    log_capacity: u32,
+}, "MeshSDFClassifySettings");
+
+/**
+ * The geometry tables a BLAS query reads, by the names the query chunks take them by: five storage
+ * buffers.
+ *
+ * @param {import("../../../shader/resource/ShaderResourceGroupDescriptor.js").ShaderResourceGroupDescriptor} group
+ */
+export function mesh_sdf_add_blas_resources(group) {
+    group
+        .addStorageBuffer("blas_lookup", WebGPUArray.u32)
+        .addStorageBuffer("blas_data", WebGPUArray.from(BVH2_NODE_STRUCT))
+        .addStorageBuffer("geometries", WebGPUArray.from(GEOMETRY_METADATA_STRUCT))
+        .add(MESHLET_METADATA_RESOURCE)
+        .add(GEOMETRY_ATTRIBUTE_DATA_RESOURCE);
+}
+
+const resources = new ShaderResourceSetDescriptor();
+
+resources.setImmediate("settings", MESH_SDF_CLASSIFY_SETTINGS);
+
+resources.createGroup()
+    .add(MESH_SDF_HEADERS_RESOURCE)
+    .add(MESH_SDF_RANGES_RESOURCE)
+    .add(MESH_SDF_ARENA_RESOURCE)
+    .addStorageBuffer("mesh_sdf_ring", WebGPUArray.from(vec4u), true);
+
+mesh_sdf_add_blas_resources(resources.createGroup());
+
+/**
+ * Bake step 1, classify (PROBE_CLIPMAP_PROPOSAL_2026_10_27.md §6.4): one thread a brick of every
+ * geometry admitted this frame, a run each in `mesh_sdf_ranges`.
+ *
+ * One BLAS query a brick, for the nearest point within the band plus the brick's half-diagonal of its
+ * centre. Past that no texel of the brick can be within the band, and the brick is EMPTY: outside,
+ * whichever side of the surface it is on, since the vote casts no ray where the surface is not within
+ * the band (UE 5.4's). Otherwise the brick goes onto the ring as `(geometry, generation, brick, 0)`,
+ * for evaluate to settle. Either way its entry starts EMPTY, which is what a freed range must find in
+ * an entry never stored.
+ *
+ * A dropped brick is settled here: it counts its geometry's pending word down, and the last brick of
+ * a geometry to settle logs it complete.
+ *
+ * @type {ComputeShader}
+ */
+export const shader_mesh_sdf_classify = ComputeShader.from({
+    label: "Mesh SDF Classify",
+    resources,
+    body: CodeChunk.from(
+        //language=WGSL
+        `
+@compute @workgroup_size(${MESH_SDF_BAKE_WORKGROUP_SIZE})
+fn main(
+    @builtin(workgroup_id) workgroup_id: vec3<u32>,
+    @builtin(local_invocation_index) lane: u32,
+) {
+    let thread = (workgroup_id.y * settings.groups_x + workgroup_id.x) * MESH_SDF_BAKE_WORKGROUP_SIZE + lane;
+
+    if (thread >= settings.brick_count) {
+        return;
+    }
+
+    let range = mesh_sdf_range_find(settings.range_count, thread);
+    let geometry = mesh_sdf_ranges[range].y;
+    let index = thread - mesh_sdf_ranges[range].x;
+
+    let header = mesh_sdf_headers[geometry];
+    let brick = mesh_sdf_brick_of(header, index);
+    let voxel = mesh_sdf_level_voxel(header, brick.x);
+
+    atomicStore(&mesh_sdf_indirection[header.indirection + index], MESH_SDF_EMPTY);
+
+    let centre = mesh_sdf_brick_corner(header, brick) + vec3<f32>(0.5 * f32(MESH_SDF_BRICK_VOXELS) * voxel);
+    let reach = (MESH_SDF_BAND_VOXELS + MESH_SDF_BRICK_HALF_DIAGONAL) * voxel;
+
+    var stack: array<u32, ${BVH_TRAVERSAL_STACK_SIZE}>;
+
+    let nearest = point_query_blas_nearest(centre, reach, geometry, &stack, 0u);
+
+    if (nearest.primitive == ${UINT32_MAX}u) {
+        // nothing within reach: every texel is a band or more from the surface
+        mesh_sdf_bake_settle(header, geometry, settings.log_offset, settings.log_capacity);
+
+        return;
+    }
+
+    let at = atomicAdd(&mesh_sdf_indirection[MESH_SDF_COUNTER_TAIL], 1u);
+
+    mesh_sdf_ring[at & (settings.ring_capacity - 1u)] = vec4<u32>(geometry, header.generation, index, 0u);
+}
+`, [
+            chunk_mesh_sdf_bake,
+            chunk_mesh_sdf_bake_settle,
+            chunk_mesh_sdf_range_find,
+            chunk_point_query_blas_nearest,
+        ]),
+});

package/src/shade/renderer/geometry/sdf/bake/shader_mesh_sdf_evaluate.d.ts

@@ -0,0 +1,29 @@
+/**
+ * @type {WebGPUStruct}
+ */
+export const MESH_SDF_EVALUATE_SETTINGS: WebGPUStruct;
+/**
+ * Bake step 3, evaluate (PROBE_CLIPMAP_PROPOSAL_2026_10_27.md §6.4): a thread a texel of each brick
+ * taken, eight 64-lane workgroups a brick, dispatched by take. Each texel is `blas_query_band_sdf`:
+ * the nearest point within the band, signed by UE 5.4's vote of 98 rays one band long, and none in a
+ * geometry baked two-sided. The vote runs in one thread, as the dense build mapped it: a thread with
+ * more texels than one runs their votes one after another, which on the 4090 made one brick cost a
+ * millisecond. Its byte goes to staging, a word a texel, for store.
+ *
+ * The brick's last thread to finish settles it, so that nothing waits on a barrier: a brick with a
+ * texel within the band pops a slot, one with none is EMPTY after all, and either way its entry is
+ * written and its geometry's pending word counted down — to the geometry's completion when it is the
+ * last. A texel with no surface within the band cast no ray and reads +R, so such a brick is outside.
+ * A workgroup's lanes count into a word of their own, lanes finished and lanes within the band; the
+ * workgroup's last lane adds the workgroup to the brick's tally in the arena, and the brick's last
+ * workgroup reads all eight there.
+ *
+ * A brick whose geometry is no longer baking at its generation is stale — freed, or rebaked since it
+ * was queued — and its workgroups leave without a write.
+ *
+ * @type {ComputeShader}
+ */
+export const shader_mesh_sdf_evaluate: ComputeShader;
+import { WebGPUStruct } from "../../../shader/type/WebGPUStruct.js";
+import { ComputeShader } from "../../../shader/ComputeShader.js";
+//# sourceMappingURL=shader_mesh_sdf_evaluate.d.ts.map

package/src/shade/renderer/geometry/sdf/bake/shader_mesh_sdf_evaluate.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"shader_mesh_sdf_evaluate.d.ts","sourceRoot":"","sources":["../../../../../../../src/shade/renderer/geometry/sdf/bake/shader_mesh_sdf_evaluate.js"],"names":[],"mappings":"AAeA;;GAEG;AACH,yCAFU,YAAY,CAaQ;AAgB9B;;;;;;;;;;;;;;;;;;;;GAoBG;AACH,uCAFU,aAAa,CAiFpB;6BA1I0B,sCAAsC;8BAJrC,kCAAkC"}

package/src/shade/renderer/geometry/sdf/bake/shader_mesh_sdf_evaluate.js

@@ -0,0 +1,146 @@
+import { BVH_TRAVERSAL_STACK_SIZE } from "../../../shader/chunk/bvh/BVH_TRAVERSAL_STACK_SIZE.js";
+import { SURFACE_POINT_3D } from "../../../shader/chunk/sdf/SURFACE_POINT_3D.js";
+import { CodeChunk } from "../../../shader/compiler/CodeChunk.js";
+import { ComputeShader } from "../../../shader/ComputeShader.js";
+import { ShaderResourceSetDescriptor } from "../../../shader/resource/ShaderResourceSetDescriptor.js";
+import { u32, vec4u } from "../../../shader/type/WEBGPU_WGSL_PRIMITIVE_TYPES.js";
+import { WebGPUArray } from "../../../shader/type/WebGPUArray.js";
+import { WebGPUStruct } from "../../../shader/type/WebGPUStruct.js";
+import { chunk_slot_stack } from "../../../gpu_primitive/slot_stack/chunk_slot_stack.js";
+import { chunk_blas_query_band_sdf } from "../chunk_blas_query_band_sdf.js";
+import { MESH_SDF_HEADERS_RESOURCE } from "../MESH_SDF_RESOURCES.js";
+import { chunk_mesh_sdf_bake, chunk_mesh_sdf_bake_settle, MESH_SDF_ARENA_RESOURCE } from "./chunk_mesh_sdf_bake.js";
+import { MESH_SDF_BAKE_WORKGROUP_SIZE } from "./MESH_SDF_BAKE.js";
+import { mesh_sdf_add_blas_resources } from "./shader_mesh_sdf_classify.js";
+
+/**
+ * @type {WebGPUStruct}
+ */
+export const MESH_SDF_EVALUATE_SETTINGS = WebGPUStruct.from({
+    /** entries of `mesh_sdf_ring`, a power of two; the staging starts here */
+    ring_capacity: u32,
+    /** slots the stack holds */
+    slot_capacity: u32,
+    /** where the frame's log starts in the arena */
+    log_offset: u32,
+    /** records the log holds */
+    log_capacity: u32,
+    /** where the frame's tallies start in the arena, a word a brick taken */
+    tally_offset: u32,
+}, "MeshSDFEvaluateSettings");
+
+const resources = new ShaderResourceSetDescriptor();
+
+resources.setImmediate("settings", MESH_SDF_EVALUATE_SETTINGS);
+
+// headers, ring and staging, take, the arena, the slots: five, and the BLAS query's five
+resources.createGroup()
+    .add(MESH_SDF_HEADERS_RESOURCE)
+    .addStorageBuffer("mesh_sdf_ring", WebGPUArray.from(vec4u), true)
+    .addStorageBuffer("mesh_sdf_take", WebGPUArray.u32)
+    .add(MESH_SDF_ARENA_RESOURCE)
+    .addStorageBuffer("mesh_sdf_slots", WebGPUArray.u32, true);
+
+mesh_sdf_add_blas_resources(resources.createGroup());
+
+/**
+ * Bake step 3, evaluate (PROBE_CLIPMAP_PROPOSAL_2026_10_27.md §6.4): a thread a texel of each brick
+ * taken, eight 64-lane workgroups a brick, dispatched by take. Each texel is `blas_query_band_sdf`:
+ * the nearest point within the band, signed by UE 5.4's vote of 98 rays one band long, and none in a
+ * geometry baked two-sided. The vote runs in one thread, as the dense build mapped it: a thread with
+ * more texels than one runs their votes one after another, which on the 4090 made one brick cost a
+ * millisecond. Its byte goes to staging, a word a texel, for store.
+ *
+ * The brick's last thread to finish settles it, so that nothing waits on a barrier: a brick with a
+ * texel within the band pops a slot, one with none is EMPTY after all, and either way its entry is
+ * written and its geometry's pending word counted down — to the geometry's completion when it is the
+ * last. A texel with no surface within the band cast no ray and reads +R, so such a brick is outside.
+ * A workgroup's lanes count into a word of their own, lanes finished and lanes within the band; the
+ * workgroup's last lane adds the workgroup to the brick's tally in the arena, and the brick's last
+ * workgroup reads all eight there.
+ *
+ * A brick whose geometry is no longer baking at its generation is stale — freed, or rebaked since it
+ * was queued — and its workgroups leave without a write.
+ *
+ * @type {ComputeShader}
+ */
+export const shader_mesh_sdf_evaluate = ComputeShader.from({
+    label: "Mesh SDF Evaluate",
+    resources,
+    body: CodeChunk.from(
+        //language=WGSL
+        `
+/** lanes finished in the low half, lanes with a texel within the band in the high half */
+var<workgroup> tally: atomic<u32>;
+
+@compute @workgroup_size(${MESH_SDF_BAKE_WORKGROUP_SIZE})
+fn main(
+    @builtin(workgroup_id) workgroup_id: vec3<u32>,
+    @builtin(local_invocation_index) lane: u32,
+) {
+    let taken = workgroup_id.x / MESH_SDF_GROUPS_PER_BRICK;
+    let item = mesh_sdf_ring[(mesh_sdf_take[MESH_SDF_TAKE_START] + taken) & (settings.ring_capacity - 1u)];
+    let geometry = item.x;
+    let header = mesh_sdf_headers[geometry];
+
+    if (header.state != MESH_SDF_STATE_BAKING || header.generation != item.y) {
+        return;
+    }
+
+    let brick = mesh_sdf_brick_of(header, item.z);
+    let voxel = mesh_sdf_level_voxel(header, brick.x);
+
+    // texel x + 8y + 64z of the brick, on its corner voxel
+    let t = MESH_SDF_BRICK_TEXELS;
+    let texel = (workgroup_id.x % MESH_SDF_GROUPS_PER_BRICK) * MESH_SDF_BAKE_WORKGROUP_SIZE + lane;
+    let point = mesh_sdf_brick_corner(header, brick) + vec3<f32>(vec3<u32>(texel % t, (texel / t) % t, texel / (t * t))) * voxel;
+
+    var stack: array<u32, ${BVH_TRAVERSAL_STACK_SIZE}>;
+    var contact: ${SURFACE_POINT_3D.wgsl_ref};
+
+    let band = MESH_SDF_BAND_VOXELS * voxel;
+    let distance = blas_query_band_sdf(point, geometry, band, header.two_sided != 0u, &contact, &stack, 0u);
+    let within_band = abs(distance) < band;
+
+    mesh_sdf_ring[settings.ring_capacity + taken * MESH_SDF_STAGING_VEC4S + texel / 4u][texel % 4u] = u32(round(mesh_sdf_encode(distance, voxel) * 255.0));
+
+    let lanes_before = atomicAdd(&tally, 1u + select(0u, MESH_SDF_TALLY_BAND_UNIT, within_band));
+
+    if ((lanes_before & 0xffffu) != MESH_SDF_BAKE_WORKGROUP_SIZE - 1u) {
+        return;
+    }
+
+    // the workgroup's last lane: every lane's count is in 'lanes_before' and its own
+    let workgroup_within_band = (lanes_before >> 16u) + select(0u, 1u, within_band) > 0u;
+
+    let groups_before = atomicAdd(
+        &mesh_sdf_indirection[settings.tally_offset + taken],
+        1u + select(0u, MESH_SDF_TALLY_BAND_UNIT, workgroup_within_band)
+    );
+
+    if ((groups_before & 0xffffu) != MESH_SDF_GROUPS_PER_BRICK - 1u) {
+        return;
+    }
+
+    // the brick's last workgroup
+    let brick_within_band = (groups_before >> 16u) + select(0u, 1u, workgroup_within_band) > 0u;
+
+    var entry = MESH_SDF_EMPTY;
+
+    if (brick_within_band) {
+        // take held the bricks of the frame to the free slots, so this pop is never refused
+        entry = slot_stack_pop(&mesh_sdf_indirection[MESH_SDF_COUNTER_SLOTS], &mesh_sdf_slots, settings.slot_capacity);
+    }
+
+    atomicStore(&mesh_sdf_indirection[header.indirection + item.z], entry);
+
+    mesh_sdf_bake_settle(header, geometry, settings.log_offset, settings.log_capacity);
+}
+`, [
+            SURFACE_POINT_3D.declaration_chunk,
+            chunk_mesh_sdf_bake,
+            chunk_mesh_sdf_bake_settle,
+            chunk_slot_stack,
+            chunk_blas_query_band_sdf,
+        ]),
+});