@woosh/meep-engine 3.61.1 → 3.61.3

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

@@ -1 +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"}
+{"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,CAsDpB;6BA/H0B,sCAAsC;8BAJrC,kCAAkC"}

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

@@ -75,7 +75,7 @@ mesh_sdf_add_blas_resources(resources.createGroup());
  * 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.
+ * an entry never stored, and its number `MESH_SDF_UNNUMBERED`, until evaluate gives it a slot.
  *
  * 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.
@@ -108,6 +108,7 @@ fn main(
     let voxel = mesh_sdf_level_voxel(header, brick.x);
 
     atomicStore(&mesh_sdf_indirection[header.indirection + index], MESH_SDF_EMPTY);
+    atomicStore(&mesh_sdf_indirection[mesh_sdf_numbers(header) + index], MESH_SDF_UNNUMBERED);
 
     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;

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

@@ -0,0 +1,18 @@
+/**
+ * @type {WebGPUStruct}
+ */
+export const MESH_SDF_CONTENT_REHASH_SETTINGS: WebGPUStruct;
+/**
+ * The content table of a grown atlas, empty and twice its slots, given the records of the table it
+ * replaces (`mesh_sdf_content_table_before`): a thread a record of that table, each live one inserted
+ * as it is, its key and its slot, so the grown table lists what the old one did. A record the grown
+ * table refuses leaves its slot held but never found (`chunk_mesh_sdf_contents`).
+ *
+ * Runs first in the bake that follows the growth, before anything reads or changes the grown table.
+ *
+ * @type {ComputeShader}
+ */
+export const shader_mesh_sdf_content_rehash: ComputeShader;
+import { WebGPUStruct } from "../../../shader/type/WebGPUStruct.js";
+import { ComputeShader } from "../../../shader/ComputeShader.js";
+//# sourceMappingURL=shader_mesh_sdf_content_rehash.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"shader_mesh_sdf_content_rehash.d.ts","sourceRoot":"","sources":["../../../../../../../src/shade/renderer/geometry/sdf/bake/shader_mesh_sdf_content_rehash.js"],"names":[],"mappings":"AAUA;;GAEG;AACH,+CAFU,YAAY,CAKa;AAUnC;;;;;;;;;GASG;AACH,6CAFU,aAAa,CA+BpB;6BA3D0B,sCAAsC;8BAJrC,kCAAkC"}

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

@@ -0,0 +1,66 @@
+import { chunk_hash_table_atomic } from "../../../gpu_primitive/hash_table/chunk_hash_table_atomic.js";
+import { CodeChunk } from "../../../shader/compiler/CodeChunk.js";
+import { ComputeShader } from "../../../shader/ComputeShader.js";
+import { ShaderResourceSetDescriptor } from "../../../shader/resource/ShaderResourceSetDescriptor.js";
+import { u32 } from "../../../shader/type/WEBGPU_WGSL_PRIMITIVE_TYPES.js";
+import { WebGPUArray } from "../../../shader/type/WebGPUArray.js";
+import { WebGPUStruct } from "../../../shader/type/WebGPUStruct.js";
+import { MESH_SDF_CONTENT_TABLE_RESOURCE } from "./chunk_mesh_sdf_contents.js";
+import { MESH_SDF_BAKE_WORKGROUP_SIZE } from "./MESH_SDF_BAKE.js";
+
+/**
+ * @type {WebGPUStruct}
+ */
+export const MESH_SDF_CONTENT_REHASH_SETTINGS = WebGPUStruct.from({
+    /** workgroups along x, the rest folded into y */
+    groups_x: u32,
+}, "MeshSDFContentRehashSettings");
+
+const resources = new ShaderResourceSetDescriptor();
+
+resources.setImmediate("settings", MESH_SDF_CONTENT_REHASH_SETTINGS);
+
+resources.createGroup()
+    .addStorageBuffer("mesh_sdf_content_table_before", WebGPUArray.u32)
+    .add(MESH_SDF_CONTENT_TABLE_RESOURCE);
+
+/**
+ * The content table of a grown atlas, empty and twice its slots, given the records of the table it
+ * replaces (`mesh_sdf_content_table_before`): a thread a record of that table, each live one inserted
+ * as it is, its key and its slot, so the grown table lists what the old one did. A record the grown
+ * table refuses leaves its slot held but never found (`chunk_mesh_sdf_contents`).
+ *
+ * Runs first in the bake that follows the growth, before anything reads or changes the grown table.
+ *
+ * @type {ComputeShader}
+ */
+export const shader_mesh_sdf_content_rehash = ComputeShader.from({
+    label: "Mesh SDF Content Rehash",
+    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 record = (workgroup_id.y * settings.groups_x + workgroup_id.x) * ${MESH_SDF_BAKE_WORKGROUP_SIZE}u + lane;
+
+    // the table's header: its records held, then its size
+    if (record >= mesh_sdf_content_table_before[1u]) {
+        return;
+    }
+
+    let stored = mesh_sdf_content_table_before[2u + 2u * record];
+
+    if (stored == 0u || stored == HASH_TABLE_REMOVED) {
+        return;
+    }
+
+    hash_table_atomic_insert(&mesh_sdf_content_table, 0u, stored - 1u, mesh_sdf_content_table_before[3u + 2u * record]);
+}
+`, [
+            chunk_hash_table_atomic,
+        ]),
+});

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

@@ -0,0 +1,17 @@
+/**
+ * @type {WebGPUStruct}
+ */
+export const MESH_SDF_COUNT_SETTINGS: WebGPUStruct;
+/**
+ * Bake step 5, count: a thread a record of the frame's log, dispatched over its capacity after store.
+ * A completion record gets its geometry's stored bricks, the
+ * count of numbers evaluate gave out (`MESH_SDF_LOG_STORED`). It is read here rather than when the
+ * last brick settles: the numbers and the pending word are different words, and only a pass boundary
+ * orders one brick's taking a number before another's reading the count.
+ *
+ * @type {ComputeShader}
+ */
+export const shader_mesh_sdf_count: ComputeShader;
+import { WebGPUStruct } from "../../../shader/type/WebGPUStruct.js";
+import { ComputeShader } from "../../../shader/ComputeShader.js";
+//# sourceMappingURL=shader_mesh_sdf_count.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"shader_mesh_sdf_count.d.ts","sourceRoot":"","sources":["../../../../../../../src/shade/renderer/geometry/sdf/bake/shader_mesh_sdf_count.js"],"names":[],"mappings":"AASA;;GAEG;AACH,sCAFU,YAAY,CAOK;AAU3B;;;;;;;;GAQG;AACH,oCAFU,aAAa,CA+BpB;6BA7D0B,sCAAsC;8BAHrC,kCAAkC"}

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

@@ -0,0 +1,66 @@
+import { CodeChunk } from "../../../shader/compiler/CodeChunk.js";
+import { ComputeShader } from "../../../shader/ComputeShader.js";
+import { ShaderResourceSetDescriptor } from "../../../shader/resource/ShaderResourceSetDescriptor.js";
+import { u32 } from "../../../shader/type/WEBGPU_WGSL_PRIMITIVE_TYPES.js";
+import { WebGPUStruct } from "../../../shader/type/WebGPUStruct.js";
+import { MESH_SDF_HEADERS_RESOURCE } from "../MESH_SDF_RESOURCES.js";
+import { chunk_mesh_sdf_bake, MESH_SDF_ARENA_RESOURCE } from "./chunk_mesh_sdf_bake.js";
+import { MESH_SDF_BAKE_WORKGROUP_SIZE, MESH_SDF_LOG_STORED } from "./MESH_SDF_BAKE.js";
+
+/**
+ * @type {WebGPUStruct}
+ */
+export const MESH_SDF_COUNT_SETTINGS = WebGPUStruct.from({
+    /** where the frame's log starts in the arena */
+    log_offset: u32,
+    /** records the log holds */
+    log_capacity: u32,
+}, "MeshSDFCountSettings");
+
+const resources = new ShaderResourceSetDescriptor();
+
+resources.setImmediate("settings", MESH_SDF_COUNT_SETTINGS);
+
+resources.createGroup()
+    .add(MESH_SDF_HEADERS_RESOURCE)
+    .add(MESH_SDF_ARENA_RESOURCE);
+
+/**
+ * Bake step 5, count: a thread a record of the frame's log, dispatched over its capacity after store.
+ * A completion record gets its geometry's stored bricks, the
+ * count of numbers evaluate gave out (`MESH_SDF_LOG_STORED`). It is read here rather than when the
+ * last brick settles: the numbers and the pending word are different words, and only a pass boundary
+ * orders one brick's taking a number before another's reading the count.
+ *
+ * @type {ComputeShader}
+ */
+export const shader_mesh_sdf_count = ComputeShader.from({
+    label: "Mesh SDF Count",
+    resources,
+    body: CodeChunk.from(
+        //language=WGSL
+        `
+@compute @workgroup_size(${MESH_SDF_BAKE_WORKGROUP_SIZE})
+fn main(@builtin(global_invocation_id) id: vec3<u32>) {
+    let record = id.x;
+    let count = min(atomicLoad(&mesh_sdf_indirection[settings.log_offset + MESH_SDF_LOG_COMPLETIONS]), settings.log_capacity);
+
+    if (record >= count) {
+        return;
+    }
+
+    let word = settings.log_offset + MESH_SDF_LOG_HEADER_WORDS + record * MESH_SDF_LOG_RECORD_WORDS;
+    let geometry = atomicLoad(&mesh_sdf_indirection[word]);
+    let header = mesh_sdf_headers[geometry];
+
+    // a record of a bake dropped since: the host passes it over, and its range may be gone
+    if (header.state != MESH_SDF_STATE_BAKING || header.generation != atomicLoad(&mesh_sdf_indirection[word + 1u])) {
+        return;
+    }
+
+    atomicStore(&mesh_sdf_indirection[word + ${MESH_SDF_LOG_STORED}u], atomicLoad(&mesh_sdf_indirection[header.indirection - 2u]));
+}
+`, [
+            chunk_mesh_sdf_bake,
+        ]),
+});

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

@@ -11,9 +11,11 @@ export const MESH_SDF_EVALUATE_SETTINGS: WebGPUStruct;
  * 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.
+ * texel within the band is PENDING, which slot holds its bytes being resolve's to say once key has
+ * read them, and takes the next number of its geometry's stored bricks; one with none is EMPTY after
+ * all; 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.

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

@@ -1 +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"}
+{"version":3,"file":"shader_mesh_sdf_evaluate.d.ts","sourceRoot":"","sources":["../../../../../../../src/shade/renderer/geometry/sdf/bake/shader_mesh_sdf_evaluate.js"],"names":[],"mappings":"AAcA;;GAEG;AACH,yCAFU,YAAY,CAWQ;AAe9B;;;;;;;;;;;;;;;;;;;;;;GAsBG;AACH,uCAFU,aAAa,CAoFpB;6BA3I0B,sCAAsC;8BAJrC,kCAAkC"}

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

@@ -6,7 +6,6 @@ import { ShaderResourceSetDescriptor } from "../../../shader/resource/ShaderReso
 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";
@@ -19,13 +18,11 @@ import { mesh_sdf_add_blas_resources } from "./shader_mesh_sdf_classify.js";
 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 */
+    /** where the records of the frame's bricks taken start in the arena, MESH_SDF_TAKEN_WORDS each */
     tally_offset: u32,
 }, "MeshSDFEvaluateSettings");
 
@@ -33,13 +30,12 @@ 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
+// headers, ring and staging, take, the arena: four, 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);
+    .add(MESH_SDF_ARENA_RESOURCE);
 
 mesh_sdf_add_blas_resources(resources.createGroup());
 
@@ -52,9 +48,11 @@ mesh_sdf_add_blas_resources(resources.createGroup());
  * 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.
+ * texel within the band is PENDING, which slot holds its bytes being resolve's to say once key has
+ * read them, and takes the next number of its geometry's stored bricks; one with none is EMPTY after
+ * all; 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.
@@ -114,7 +112,7 @@ fn main(
     let workgroup_within_band = (lanes_before >> 16u) + select(0u, 1u, within_band) > 0u;
 
     let groups_before = atomicAdd(
-        &mesh_sdf_indirection[settings.tally_offset + taken],
+        &mesh_sdf_indirection[settings.tally_offset + taken * MESH_SDF_TAKEN_WORDS + MESH_SDF_TAKEN_TALLY],
         1u + select(0u, MESH_SDF_TALLY_BAND_UNIT, workgroup_within_band)
     );
 
@@ -128,8 +126,12 @@ fn main(
     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);
+        entry = MESH_SDF_PENDING;
+
+        let number = atomicAdd(&mesh_sdf_indirection[header.indirection - 2u], 1u);
+
+        atomicStore(&mesh_sdf_indirection[mesh_sdf_numbers(header) + item.z], number);
+        atomicStore(&mesh_sdf_indirection[mesh_sdf_numbered(header) + number], item.z);
     }
 
     atomicStore(&mesh_sdf_indirection[header.indirection + item.z], entry);
@@ -140,7 +142,6 @@ fn main(
             SURFACE_POINT_3D.declaration_chunk,
             chunk_mesh_sdf_bake,
             chunk_mesh_sdf_bake_settle,
-            chunk_slot_stack,
             chunk_blas_query_band_sdf,
         ]),
 });

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

@@ -5,7 +5,8 @@ export const MESH_SDF_FREE_SETTINGS: WebGPUStruct;
 /**
  * Gives the slots of freed geometries back: one thread an entry of every run of entries freed since
  * the last bake, a run each in `mesh_sdf_ranges` as `(first thread, first entry)`. An entry holding a
- * slot pushes it onto the stack.
+ * slot holds it one entry fewer (`chunk_mesh_sdf_contents`), and the entry that was the last pushes it
+ * onto the stack, its content no longer listed.
  *
  * Runs first in the bake, before classify can hand a freed range to another geometry and overwrite
  * it. A range freed mid-bake holds EMPTY where its bricks were not yet stored, since classify writes

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

@@ -1 +1 @@
-{"version":3,"file":"shader_mesh_sdf_free.d.ts","sourceRoot":"","sources":["../../../../../../../src/shade/renderer/geometry/sdf/bake/shader_mesh_sdf_free.js"],"names":[],"mappings":"AAeA;;GAEG;AACH,qCAFU,YAAY,CASI;AAW1B;;;;;;;;;;GAUG;AACH,mCAFU,aAAa,CA+BpB;6BAvE0B,sCAAsC;8BAJrC,kCAAkC"}
+{"version":3,"file":"shader_mesh_sdf_free.d.ts","sourceRoot":"","sources":["../../../../../../../src/shade/renderer/geometry/sdf/bake/shader_mesh_sdf_free.js"],"names":[],"mappings":"AAoBA;;GAEG;AACH,qCAFU,YAAY,CASI;AAa1B;;;;;;;;;;;GAWG;AACH,mCAFU,aAAa,CAgCpB;6BAhF0B,sCAAsC;8BAJrC,kCAAkC"}

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

@@ -11,6 +11,11 @@ import {
     MESH_SDF_ARENA_RESOURCE,
     MESH_SDF_RANGES_RESOURCE
 } from "./chunk_mesh_sdf_bake.js";
+import {
+    chunk_mesh_sdf_contents,
+    MESH_SDF_CONTENT_TABLE_RESOURCE,
+    MESH_SDF_CONTENTS_RESOURCE
+} from "./chunk_mesh_sdf_contents.js";
 import { MESH_SDF_BAKE_WORKGROUP_SIZE } from "./MESH_SDF_BAKE.js";
 
 /**
@@ -32,12 +37,15 @@ resources.setImmediate("settings", MESH_SDF_FREE_SETTINGS);
 resources.createGroup()
     .add(MESH_SDF_RANGES_RESOURCE)
     .add(MESH_SDF_ARENA_RESOURCE)
-    .addStorageBuffer("mesh_sdf_slots", WebGPUArray.u32, true);
+    .addStorageBuffer("mesh_sdf_slots", WebGPUArray.u32, true)
+    .add(MESH_SDF_CONTENTS_RESOURCE)
+    .add(MESH_SDF_CONTENT_TABLE_RESOURCE);
 
 /**
  * Gives the slots of freed geometries back: one thread an entry of every run of entries freed since
  * the last bake, a run each in `mesh_sdf_ranges` as `(first thread, first entry)`. An entry holding a
- * slot pushes it onto the stack.
+ * slot holds it one entry fewer (`chunk_mesh_sdf_contents`), and the entry that was the last pushes it
+ * onto the stack, its content no longer listed.
  *
  * Runs first in the bake, before classify can hand a freed range to another geometry and overwrite
  * it. A range freed mid-bake holds EMPTY where its bricks were not yet stored, since classify writes
@@ -65,13 +73,14 @@ fn main(
     let range = mesh_sdf_range_find(settings.range_count, thread);
     let entry = atomicLoad(&mesh_sdf_indirection[mesh_sdf_ranges[range].y + thread - mesh_sdf_ranges[range].x]);
 
-    if (mesh_sdf_entry_holds_slot(entry)) {
+    if (mesh_sdf_entry_holds_slot(entry) && mesh_sdf_content_release(entry)) {
         slot_stack_push(&mesh_sdf_indirection[MESH_SDF_COUNTER_SLOTS], &mesh_sdf_slots, entry);
     }
 }
 `, [
             chunk_mesh_sdf_bake,
             chunk_mesh_sdf_range_find,
+            chunk_mesh_sdf_contents,
             chunk_slot_stack,
         ]),
 });

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

@@ -0,0 +1,21 @@
+/**
+ * @type {WebGPUStruct}
+ */
+export const MESH_SDF_KEY_SETTINGS: WebGPUStruct;
+/**
+ * Bake step 4, key: a thread a texel of each brick taken, eight workgroups a brick, dispatched by
+ * take as evaluate is. A PENDING brick's texel adds its term of the brick's content key
+ * (`MESH_SDF_BRICK_KEY.js`) into the brick's record, a subgroup's terms in one atomic: a sum, so the
+ * order they land in is no matter, and resolve reads it after the dispatch. A brick EMPTY, or stale,
+ * adds nothing. A subgroup's lanes are of one brick, a workgroup's 64 texels being, so the words of a
+ * brick are loaded once a subgroup (`chunk_subgroup_atomic_load`).
+ *
+ * A pass of its own: evaluate's eight workgroups write a brick's staging in one dispatch, and nothing
+ * there orders their writes before another of them reads them.
+ *
+ * @type {ComputeShader}
+ */
+export const shader_mesh_sdf_key: ComputeShader;
+import { WebGPUStruct } from "../../../shader/type/WebGPUStruct.js";
+import { ComputeShader } from "../../../shader/ComputeShader.js";
+//# sourceMappingURL=shader_mesh_sdf_key.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"shader_mesh_sdf_key.d.ts","sourceRoot":"","sources":["../../../../../../../src/shade/renderer/geometry/sdf/bake/shader_mesh_sdf_key.js"],"names":[],"mappings":"AAaA;;GAEG;AACH,oCAFU,YAAY,CAOG;AA6CzB;;;;;;;;;;;;GAYG;AACH,kCAFU,aAAa,CAMpB;6BA5E0B,sCAAsC;8BAJrC,kCAAkC"}

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

@@ -0,0 +1,84 @@
+import { chunk_subgroup_atomic_add } from "../../../shader/chunk/subgroup/chunk_subgroup_atomic_add.js";
+import { chunk_subgroup_atomic_load } from "../../../shader/chunk/subgroup/chunk_subgroup_atomic_load.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_mesh_sdf_brick_key } from "../chunk_mesh_sdf_brick_key.js";
+import { MESH_SDF_HEADERS_RESOURCE } from "../MESH_SDF_RESOURCES.js";
+import { chunk_mesh_sdf_bake, MESH_SDF_ARENA_RESOURCE } from "./chunk_mesh_sdf_bake.js";
+import { MESH_SDF_BAKE_WORKGROUP_SIZE } from "./MESH_SDF_BAKE.js";
+
+/**
+ * @type {WebGPUStruct}
+ */
+export const MESH_SDF_KEY_SETTINGS = WebGPUStruct.from({
+    /** entries of `mesh_sdf_ring`, a power of two; the staging starts here */
+    ring_capacity: u32,
+    /** where the records of the frame's bricks taken start in the arena, MESH_SDF_TAKEN_WORDS each */
+    tally_offset: u32,
+}, "MeshSDFKeySettings");
+
+const resources = new ShaderResourceSetDescriptor();
+
+resources.setImmediate("settings", MESH_SDF_KEY_SETTINGS);
+
+resources.createGroup()
+    .add(MESH_SDF_HEADERS_RESOURCE)
+    .addStorageBuffer("mesh_sdf_ring", WebGPUArray.from(vec4u))
+    .addStorageBuffer("mesh_sdf_take", WebGPUArray.u32)
+    .add(MESH_SDF_ARENA_RESOURCE);
+
+const 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 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 header = mesh_sdf_headers[item.x];
+
+    // the same for every lane of the workgroup, and of each of its subgroups: one brick
+    if (header.state != MESH_SDF_STATE_BAKING || header.generation != item.y) {
+        return;
+    }
+
+    if (subgroup_atomic_load_u32(&mesh_sdf_indirection[header.indirection + item.z]) != MESH_SDF_PENDING) {
+        return;
+    }
+
+    let texel = (workgroup_id.x % MESH_SDF_GROUPS_PER_BRICK) * MESH_SDF_BAKE_WORKGROUP_SIZE + lane;
+    let byte = mesh_sdf_ring[settings.ring_capacity + taken * MESH_SDF_STAGING_VEC4S + texel / 4u][texel % 4u];
+
+    subgroup_atomic_add_u32(&mesh_sdf_indirection[settings.tally_offset + taken * MESH_SDF_TAKEN_WORDS + MESH_SDF_TAKEN_KEY], mesh_sdf_brick_key_term(texel, byte));
+}
+`, [
+        chunk_mesh_sdf_bake,
+        chunk_mesh_sdf_brick_key,
+        chunk_subgroup_atomic_add,
+        chunk_subgroup_atomic_load,
+    ]);
+
+/**
+ * Bake step 4, key: a thread a texel of each brick taken, eight workgroups a brick, dispatched by
+ * take as evaluate is. A PENDING brick's texel adds its term of the brick's content key
+ * (`MESH_SDF_BRICK_KEY.js`) into the brick's record, a subgroup's terms in one atomic: a sum, so the
+ * order they land in is no matter, and resolve reads it after the dispatch. A brick EMPTY, or stale,
+ * adds nothing. A subgroup's lanes are of one brick, a workgroup's 64 texels being, so the words of a
+ * brick are loaded once a subgroup (`chunk_subgroup_atomic_load`).
+ *
+ * A pass of its own: evaluate's eight workgroups write a brick's staging in one dispatch, and nothing
+ * there orders their writes before another of them reads them.
+ *
+ * @type {ComputeShader}
+ */
+export const shader_mesh_sdf_key = ComputeShader.from({
+    label: "Mesh SDF Key",
+    resources,
+    body,
+});

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

@@ -0,0 +1,53 @@
+/**
+ * @type {WebGPUStruct}
+ */
+export const MESH_SDF_RESOLVE_SETTINGS: WebGPUStruct;
+/**
+ * Bake step 5, resolve, first pass, find: a thread a brick taken, over the frame's budget. A PENDING
+ * brick finds a slot listed under its content key (`chunk_mesh_sdf_contents`), which compare holds its
+ * bytes against, and keeps it in its record. One that finds none claims its key in the frame's
+ * claims, a table of the frame's bricks by key: the first to claim a key is its representative, which
+ * fresh gives a slot, and every brick names its key's representative in its record, whose bytes
+ * compare holds its own against.
+ *
+ * The keys are key's, read after its dispatch. No list shares this dispatch, so every find meets the
+ * table as the last frame left it.
+ *
+ * @type {ComputeShader}
+ */
+export const shader_mesh_sdf_resolve_find: ComputeShader;
+/**
+ * Bake step 5, resolve, second pass, compare: a thread a texel of each brick taken, eight workgroups a
+ * brick, dispatched by take. A PENDING brick that found a slot holds each of its staged bytes against
+ * the byte the slot holds there, and one that names a representative other than itself against the
+ * representative's staged byte, and the texels that differ are counted in the brick's record. A key
+ * finds the bricks its bytes may be those of; this pass says whether they are.
+ *
+ * A subgroup's lanes are of one brick, a workgroup's 64 texels being, so the brick's words are loaded
+ * and its count added once a subgroup (`chunk_subgroup_atomic_load`, `chunk_subgroup_atomic_add`).
+ *
+ * @type {ComputeShader}
+ */
+export const shader_mesh_sdf_resolve_compare: ComputeShader;
+/**
+ * Bake step 5, resolve, third pass, fresh: a thread a brick taken. A representative pops a slot and
+ * lists it under its key, and its record says the slot is fresh, which store fills. A brick whose
+ * bytes differ from those it was compared with pops a fresh slot of its own, listed nowhere, so no
+ * brick after shares it: its key is another bytes' too, and the log counts it collided. Take held the
+ * frame's bricks to the free slots, and a brick pops one slot at most, so no pop here is refused.
+ *
+ * @type {ComputeShader}
+ */
+export const shader_mesh_sdf_resolve_fresh: ComputeShader;
+/**
+ * Bake step 5, resolve, last pass, hold: a thread a brick taken. A PENDING brick takes its slot, the
+ * one it found or popped, or its representative's when it has none, holds it one entry more, and its
+ * entry holds it. Logs the bricks that took a slot already holding their bytes, or their
+ * representative's.
+ *
+ * @type {ComputeShader}
+ */
+export const shader_mesh_sdf_resolve_hold: ComputeShader;
+import { WebGPUStruct } from "../../../shader/type/WebGPUStruct.js";
+import { ComputeShader } from "../../../shader/ComputeShader.js";
+//# sourceMappingURL=shader_mesh_sdf_resolve.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"shader_mesh_sdf_resolve.d.ts","sourceRoot":"","sources":["../../../../../../../src/shade/renderer/geometry/sdf/bake/shader_mesh_sdf_resolve.js"],"names":[],"mappings":"AAqBA;;GAEG;AACH,wCAFU,YAAY,CAeO;AAmG7B;;;;;;;;;;;;GAYG;AACH,2CAFU,aAAa,CAsDmD;AAE1E;;;;;;;;;;;GAWG;AACH,8CAFU,aAAa,CAuDpB;AAEH;;;;;;;;GAQG;AACH,4CAFU,aAAa,CA6BA;AAEvB;;;;;;;GAOG;AACH,2CAFU,aAAa,CA4BhB;6BA5UsB,sCAAsC;8BAJrC,kCAAkC"}