@woosh/meep-engine 3.56.0 → 3.58.0

package/src/shade/renderer/geometry/meshlet/GPUMeshletManager.d.ts

@@ -155,7 +155,7 @@ export class GPUMeshletManager {
      * clone, emits two `copyBufferToBuffer` commands (one for vertex
      * data, one for metadata records). After every queued clone's
      * copies are recorded, dispatches a single batched patch shader
-     * pass that walks a flat `(record_index, address_delta)` table
+     * pass that walks a flat `(record_index, address)` table
      * — N clones → 1 patch dispatch, total threads = sum of clone
      * meshlet counts.
      *

package/src/shade/renderer/geometry/meshlet/GPUMeshletManager.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"GPUMeshletManager.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/geometry/meshlet/GPUMeshletManager.js"],"names":[],"mappings":"AAoEA;;;;;;GAMG;AACH,wCAFU,MAAM,CAE4B;AAE5C;;;;;GAKG;AACH,wCAFU,MAAM,CAEqC;AAErD;;;;GAIG;AACH,wCAFU,MAAM,CAE8B;AAE9C;;;;;;;;;;;GAWG;AACH,kDAFU,MAAM,CAE6C;AAE7D;;GAEG;AACH,iDAFU,MAAM,CAEsC;AAkHtD;IA8II;;;;;;;;OAQG;IACH;QAN8B,MAAM;QACR,qBAAqB,GAAtC,MAAM;QACW,yBAAyB,GAA1C,MAAM;QACW,gBAAgB,GAAjC,MAAM;OAuChB;IAxKD,6BAEC;IAOD,iCAEC;IAwED;;OAEG;IACH,8CAEC;IAkFD,gBAOC;IAED;;;;;;;;;;;;;;;;;;;;;OAqBG;IACH,sBAHW,MAAM,uBACN,MAAM,QA2HhB;IAkZD;;;;;;;;;;OAUG;IACH,qBAJW,4BAA4B,GAE1B,OAAO,CAmBnB;IAqED;;;;;;;;;;;;;;;;;;;;;;;;;;;;OA4BG;IACH,eAFW,sBAAsB,QAqChC;IAiND;;;;;;;;;;;;;;;;;;;;;;;;OAwBG;IACH,+BAHW,4BAA4B,GAC1B,4BAA4B,CAqCxC;IAED;;;;;;;;;;;;OAYG;IACH,gBAFW,sBAAsB,QA8GhC;IAED,gBAGC;IAED;;;;OAIG;IACH,iBAHW,YAAY,GACV,4BAA4B,CA6BxC;IAED,mCASC;IAED,wCAQC;IAED;;;;;;OAMG;IACH,wCAMC;IAED,+BAYC;;CACJ;yBAxjDY,OAAO,sDAAsD,EAAE,UAAU;qCACzE,OAAO,2CAA2C,EAAE,sBAAsB;2BAC1E,OAAO,mBAAmB,EAAE,YAAY;AA6FrD;;;;GAIG;AACH;IACI,gBAAY;IACZ,iBAAa;IACb,cAAU;IACV,qBAAiB;IACjB,yBAAqB;IACrB,yBAAqB;CACxB;AAmDD;IACI;;OAEG;IACH,UAFU,UAAU,CAEZ;IACR;;OAEG;IACH,MAFU,UAAU,CAEhB;IAEJ;;;OAGG;IACH,WAFU,MAAM,CAEF;IAEd;;;OAGG;IACH,eAFU,MAAM,CAEE;IAElB;;;OAGG;IACH,0BAFU,WAAW,CAEI;IAEzB;;;;;;;;;;OAUG;IACH,oBAFU,OAAO,CAEU;IAE3B;;;OAGG;IACH,aAAsB;CACzB"}
+{"version":3,"file":"GPUMeshletManager.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/geometry/meshlet/GPUMeshletManager.js"],"names":[],"mappings":"AAoEA;;;;;;GAMG;AACH,wCAFU,MAAM,CAE4B;AAE5C;;;;;GAKG;AACH,wCAFU,MAAM,CAEqC;AAErD;;;;GAIG;AACH,wCAFU,MAAM,CAE8B;AAE9C;;;;;;;;;;;GAWG;AACH,kDAFU,MAAM,CAE6C;AAE7D;;GAEG;AACH,iDAFU,MAAM,CAEsC;AA8JtD;IA8II;;;;;;;;OAQG;IACH;QAN8B,MAAM;QACR,qBAAqB,GAAtC,MAAM;QACW,yBAAyB,GAA1C,MAAM;QACW,gBAAgB,GAAjC,MAAM;OAuChB;IAxKD,6BAEC;IAOD,iCAEC;IAwED;;OAEG;IACH,8CAEC;IAkFD,gBAOC;IAED;;;;;;;;;;;;;;;;;;;;;OAqBG;IACH,sBAHW,MAAM,uBACN,MAAM,QA2HhB;IAkZD;;;;;;;;;;OAUG;IACH,qBAJW,4BAA4B,GAE1B,OAAO,CAmBnB;IAqED;;;;;;;;;;;;;;;;;;;;;;;;;;;;OA4BG;IACH,eAFW,sBAAsB,QAqChC;IAiND;;;;;;;;;;;;;;;;;;;;;;;;OAwBG;IACH,+BAHW,4BAA4B,GAC1B,4BAA4B,CAqCxC;IAED;;;;;;;;;;;;OAYG;IACH,gBAFW,sBAAsB,QAoGhC;IAED,gBAGC;IAED;;;;OAIG;IACH,iBAHW,YAAY,GACV,4BAA4B,CA6BxC;IAED,mCASC;IAED,wCAQC;IAED;;;;;;OAMG;IACH,wCAMC;IAED,+BAYC;;CACJ;yBA1lDY,OAAO,sDAAsD,EAAE,UAAU;qCACzE,OAAO,2CAA2C,EAAE,sBAAsB;2BAC1E,OAAO,mBAAmB,EAAE,YAAY;AAyIrD;;;;GAIG;AACH;IACI,gBAAY;IACZ,iBAAa;IACb,cAAU;IACV,qBAAiB;IACjB,yBAAqB;IACrB,yBAAqB;CACxB;AAmDD;IACI;;OAEG;IACH,UAFU,UAAU,CAEZ;IACR;;OAEG;IACH,MAFU,UAAU,CAEhB;IAEJ;;;OAGG;IACH,WAFU,MAAM,CAEF;IAEd;;;OAGG;IACH,eAFU,MAAM,CAEE;IAElB;;;OAGG;IACH,0BAFU,WAAW,CAEI;IAEzB;;;;;;;;;;OAUG;IACH,oBAFU,OAAO,CAEU;IAE3B;;;OAGG;IACH,aAAsB;CACzB"}

package/src/shade/renderer/geometry/meshlet/GPUMeshletManager.js

@@ -110,6 +110,50 @@ export const MESHLET_SWEEP_SCATTER_MINIMUM_WORDS = 16 * 1024;
 export const MESHLET_SWEEP_SCATTER_MINIMUM_ROWS = 512;
 const METADATA_ADDRESS_WORD = MESHLET_METADATA_STRUCT.fields.find(f => f.name === 'address').offset >>> 2;
 
+/**
+ * Append one `(row, address)` pair per row of `record` to an address-patch table: the row's
+ * address relative to its batch, from the CPU bytes every record keeps, plus where the record's
+ * data is now.
+ *
+ * The address is made from what the CPU knows rather than added to what the device holds, so a
+ * row named twice gets the same value twice, and a row the device holds wrong is put right.
+ *
+ * @param {Uint32Array} patches
+ * @param {number} p the pair-word to start at
+ * @param {MeshletBatchAllocationRecord} record
+ * @returns {number} the pair-word after the last one written
+ */
+function write_address_patches(patches, p, record) {
+    const relative = new Uint32Array(record.metadata_buffer_original, 0, record.meshlet_count * METADATA_ROW_WORDS);
+
+    for (let i = 0; i < record.meshlet_count; i++) {
+        patches[p++] = record.metadata.offset + i;
+        patches[p++] = relative[i * METADATA_ROW_WORDS + METADATA_ADDRESS_WORD] + record.data.offset;
+    }
+
+    return p;
+}
+
+/**
+ * Whether the record `moves[index]` moved already appears earlier in `moves`. A scan rather than a
+ * set: one sweep call moves at most {@link MESHLET_SWEEP_MOVE_BUDGET} records per arena.
+ *
+ * @param {{record: MeshletBatchAllocationRecord}[]} moves
+ * @param {number} index
+ * @returns {boolean}
+ */
+function is_repeat_move(moves, index) {
+    const record = moves[index].record;
+
+    for (let k = 0; k < index; k++) {
+        if (moves[k].record === record) {
+            return true;
+        }
+    }
+
+    return false;
+}
+
 /**
  * What the manager has done to its arenas, for a bench, a tour or an overlay to read without
  * reaching inside. A rebuild is the O(all batches) event the compaction plan is about; a growth
@@ -347,7 +391,7 @@ export class GPUMeshletManager {
      * Queue of GPU-side clones that have been allocated but not yet
      * copied + patched. Drained by {@link update}. Each entry holds the
      * minimum bookkeeping needed to issue two `copyBufferToBuffer`
-     * commands and N `(record_index, address_delta)` patch entries.
+     * commands and N `(record_index, address)` patch entries.
      *
      * Entries name the two records, not the addresses they held when the
      * clone was queued: a {@link compact} in between migrates both, and
@@ -1265,10 +1309,16 @@ export class GPUMeshletManager {
             }
         }
 
+        // A record's data can move twice in one call — a pass, then the restart pass over holes
+        // opened under it. Its rows are given the address its final offset makes, so how far it
+        // came, and in how many steps, is not the patch's business; they are named once, because a
+        // second naming would only write the same word again.
         let patch_count = 0;
 
-        for (const move of data_moves) {
-            patch_count += move.record.meshlet_count;
+        for (let j = 0; j < data_moves.length; j++) {
+            if (!is_repeat_move(data_moves, j)) {
+                patch_count += data_moves[j].record.meshlet_count;
+            }
         }
 
         if (patch_count === 0) {
@@ -1279,15 +1329,9 @@ export class GPUMeshletManager {
 
         let p = 0;
 
-        for (const move of data_moves) {
-            const record = move.record;
-
-            // the same wrapping add as the clone flush: a move down is a negative delta
-            const delta = (move.to - move.from) >>> 0;
-
-            for (let i = 0; i < record.meshlet_count; i++) {
-                patches[p++] = record.metadata.offset + i;
-                patches[p++] = delta;
+        for (let j = 0; j < data_moves.length; j++) {
+            if (!is_repeat_move(data_moves, j)) {
+                p = write_address_patches(patches, p, data_moves[j].record);
             }
         }
 
@@ -1401,7 +1445,7 @@ export class GPUMeshletManager {
      * clone, emits two `copyBufferToBuffer` commands (one for vertex
      * data, one for metadata records). After every queued clone's
      * copies are recorded, dispatches a single batched patch shader
-     * pass that walks a flat `(record_index, address_delta)` table
+     * pass that walks a flat `(record_index, address)` table
      * — N clones → 1 patch dispatch, total threads = sum of clone
      * meshlet counts.
      *
@@ -1480,25 +1524,15 @@ export class GPUMeshletManager {
             },
         });
 
-        // Build the flat (record_index, address_delta) table. One pair
-        // per cloned meshlet record. Uploaded as a transient storage
-        // buffer the patch shader binds for one dispatch.
+        // Build the flat (record_index, address) table. One pair per
+        // cloned meshlet record, its address made from the clone's own
+        // offset — not from what the source's rows hold on the device.
+        // Uploaded as a transient storage buffer the patch shader binds
+        // for one dispatch.
         const patches_array = new Uint32Array(total_records * 2);
         let p = 0;
         for (let i = 0; i < pending.length; i++) {
-            const { source, clone } = pending[i];
-
-            // Address delta is in u32 word units. When the clone's offset
-            // is below the source's, the unsigned subtraction wraps — the
-            // patch shader does the matching wrapping add, so the final
-            // per-record `address` lands at the right absolute word offset
-            // either way.
-            const address_delta = (clone.data.offset - source.data.offset) >>> 0;
-
-            for (let m = 0; m < clone.meshlet_count; m++) {
-                patches_array[p++] = clone.metadata.offset + m;
-                patches_array[p++] = address_delta;
-            }
+            p = write_address_patches(patches_array, p, pending[i].clone);
         }
 
         const patches_buffer = cmd_ctx.allocateTransientBufferAndLoad(

package/src/shade/renderer/geometry/meshlet/MeshletBatch.d.ts

@@ -28,6 +28,11 @@ export class MeshletBatch {
      * @return {number}
      */
     get count(): number;
+    /**
+     * Total number of triangles encoded across all meshlets in the batch.
+     * @returns {number}
+     */
+    get primitive_count(): number;
     /**
      *
      * @returns {number}

package/src/shade/renderer/geometry/meshlet/MeshletBatch.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"MeshletBatch.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/geometry/meshlet/MeshletBatch.js"],"names":[],"mappings":"AA4DA;;GAEG;AACH;IAiBI;;;OAGG;IACH,oCAGC;IAXD,+BAEC;IA6BD;;;OAGG;IACH,wCAGC;IAfD;;;OAGG;IACH,mCAEC;IAqBD;;;OAGG;IACH,yBAEC;IAdD;;;OAGG;IACH,oBAEC;IAUD;;;OAGG;IACH,QAFa,MAAM,CASlB;IAED;;;OAGG;IACH,cAFW,YAAY,WAQtB;IAED;;;;OAIG;IACH,YAFa,MAAM,CAiHlB;IAED;;;OAGG;IACH,iBAEC;IAED;;;;OAIG;IACH,wBAHW,MAAM,GACL,EAAE,CAeb;IAED;;;OAGG;IACH,yBAFW,MAAM;;;;MAgChB;IA4LD,qBA+BC;IAED;;;OAGG;IACH,gBAFW,QAAQ,QASlB;IAIL;;;;OAIG;IACH,yBAFU,OAAO,CAEoB;;CAPpC;uBA9hBY,OAAO,gBAAgB,EAAE,QAAQ"}
+{"version":3,"file":"MeshletBatch.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/geometry/meshlet/MeshletBatch.js"],"names":[],"mappings":"AA4DA;;GAEG;AACH;IAiBI;;;OAGG;IACH,oCAGC;IAXD,+BAEC;IA6BD;;;OAGG;IACH,wCAGC;IAfD;;;OAGG;IACH,mCAEC;IAuBD;;;OAGG;IACH,yBAEC;IAdD;;;OAGG;IACH,oBAEC;IAUD;;;OAGG;IACH,8BAEC;IAED;;;OAGG;IACH,QAFa,MAAM,CASlB;IAED;;;OAGG;IACH,cAFW,YAAY,WAQtB;IAED;;;;OAIG;IACH,YAFa,MAAM,CAiHlB;IAED;;;OAGG;IACH,iBAEC;IAED;;;;OAIG;IACH,wBAHW,MAAM,GACL,EAAE,CAeb;IAED;;;OAGG;IACH,yBAFW,MAAM;;;;MAgChB;IAiMD,qBA+BC;IAED;;;OAGG;IACH,gBAFW,QAAQ,QASlB;IAIL;;;;OAIG;IACH,yBAFU,OAAO,CAEoB;;CAPpC;uBA7iBY,OAAO,gBAAgB,EAAE,QAAQ"}

package/src/shade/renderer/geometry/meshlet/MeshletBatch.js

@@ -116,6 +116,8 @@ export class MeshletBatch {
 
     #count = 0;
 
+    #primitive_count = 0;
+
     /**
      * Number of meshlets in the batch
      * @return {number}
@@ -132,6 +134,14 @@ export class MeshletBatch {
         this.#count = value;
     }
 
+    /**
+     * Total number of triangles encoded across all meshlets in the batch.
+     * @returns {number}
+     */
+    get primitive_count() {
+        return this.#primitive_count;
+    }
+
     /**
      *
      * @returns {number}
@@ -383,6 +393,8 @@ export class MeshletBatch {
 
         const initial_bounds_box = geometry.bounding_box;
 
+        let total_primitive_count = 0;
+
         for (let i = 0; i < meshlet_count; i++) {
             const [
                 p_vertex_offset,
@@ -391,6 +403,8 @@ export class MeshletBatch {
                 p_triangle_count,
             ] = metadata_table.readRow(i);
 
+            total_primitive_count += p_triangle_count;
+
             const metadata = {
                 // actual bounding box is computed later (build_bounds)
                 bounds_box: initial_bounds_box,
@@ -513,6 +527,7 @@ export class MeshletBatch {
         }
 
         this.#count = meshlet_count;
+        this.#primitive_count = total_primitive_count;
 
         encoded_metadata_buffer.trim();
         this.metadata_buffer = encoded_metadata_buffer.data;

package/src/shade/renderer/geometry/meshlet/build/meshoptimizer/geometry_to_meshlets_meshoptimizer.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"geometry_to_meshlets_meshoptimizer.d.ts","sourceRoot":"","sources":["../../../../../../../../src/shade/renderer/geometry/meshlet/build/meshoptimizer/geometry_to_meshlets_meshoptimizer.js"],"names":[],"mappings":"AAgBA;;;;;;;;;;;;;;GAcG;AACH,2HAPW,MAAM,EAAE,qBACR,MAAM,gBACN,MAAM,oBACN,YAAY,yBACZ,MAAM,2BACN,MAAM,QAyDhB"}
+{"version":3,"file":"geometry_to_meshlets_meshoptimizer.d.ts","sourceRoot":"","sources":["../../../../../../../../src/shade/renderer/geometry/meshlet/build/meshoptimizer/geometry_to_meshlets_meshoptimizer.js"],"names":[],"mappings":"AAeA;;;;;;;;;;;;;;GAcG;AACH,2HAPW,MAAM,EAAE,qBACR,MAAM,gBACN,MAAM,oBACN,YAAY,yBACZ,MAAM,2BACN,MAAM,QAgDhB"}

package/src/shade/renderer/geometry/meshlet/build/meshoptimizer/geometry_to_meshlets_meshoptimizer.js

@@ -1,87 +1,77 @@
-import { assert } from "../../../../../../core/assert.js";
-import { MeshoptClusterizer } from "./meshopt_clusterizer.js";
-import { meshopt_optimizeMeshlet } from "./meshopt_optimizeMeshlet.js";
-
-/**
- * Whether meshoptimizer's WASM has landed. The vendored module instantiates it asynchronously at
- * import and exposes only the promise, so this holds the promise's outcome for the assertion below.
- *
- * @type {boolean}
- */
-let clusterizer_ready = false;
-
-MeshoptClusterizer.ready?.then(() => {
-    clusterizer_ready = true;
-});
-
-/**
- * Needs meshoptimizer's WASM, which instantiates asynchronously at import. A build before it has
- * fails inside the vendored module, on an instance that is not there yet, with a message about
- * `exports` that names nothing the caller did — so await `MeshoptClusterizer.ready` before the
- * first call.
- *
- * @param {RowFirstTable} result_metadata
- * @param {BinaryBuffer} result_data
- * @param {number[]} input_index Index array
- * @param {number} input_index_count Number of active indices at the start of input_index
- * @param {number} vertex_count Number of vertices in the geometry
- * @param {Float32Array} vertex_positions
- * @param {number} [meshlet_vertex_limit]
- * @param {number} [meshlet_triangle_limit]
- */
-export function geometry_to_meshlets_meshoptimizer(
-    result_metadata,
-    result_data,
-    input_index,
-    input_index_count,
-    vertex_count,
-    vertex_positions,
-    meshlet_vertex_limit = 64,
-    meshlet_triangle_limit = 64,
-) {
-    assert.ok(clusterizer_ready, 'meshoptimizer is not ready; await MeshoptClusterizer.ready');
-
-    const active_index = input_index_count === input_index.length
-        ? input_index
-        : Array.isArray(input_index)
-            ? input_index.slice(0, input_index_count)
-            : input_index.subarray(0, input_index_count);
-
-    const meshlets = MeshoptClusterizer.buildMeshlets(active_index, vertex_positions, 3, meshlet_vertex_limit, meshlet_triangle_limit, 0.0);
-
-    result_metadata.setCapacity(result_metadata.length + meshlets.meshletCount);
-
-    for (let i = 0; i < meshlets.meshletCount; i++) {
-        const vertex_offset = meshlets.meshlets[i * 4];
-        const triangle_offset = meshlets.meshlets[i * 4 + 1];
-        const vertex_count = meshlets.meshlets[i * 4 + 2];
-        const triangle_count = meshlets.meshlets[i * 4 + 3];
-
-        const output_vertex_offset = result_data.position >>> 2;
-        const output_triangle_offset = output_vertex_offset + vertex_count;
-
-        // at the end of the table, not at the meshoptimizer-side ordinal: the reservation above is
-        // `length + meshletCount`, an append, and `i` equals `length` only when the table arrived
-        // empty. The sibling greedy builder writes here too.
-        result_metadata.writeRow(result_metadata.length, [
-            output_vertex_offset,
-            output_triangle_offset,
-            vertex_count,
-            triangle_count,
-        ])
-
-        result_metadata.length++;
-
-        // optimize meshlet for cache efficiency
-        meshopt_optimizeMeshlet(
-            meshlets.vertices.subarray(vertex_offset, vertex_offset + vertex_count),
-            meshlets.triangles.subarray(triangle_offset, triangle_offset + triangle_count * 3),
-            triangle_count,
-            vertex_count,
-        );
-
-        result_data.writeUint32Array(meshlets.vertices, vertex_offset, vertex_count);
-        result_data.writeUint32Array(meshlets.triangles, triangle_offset, triangle_count * 3);
-
-    }
-}
+import { assert } from "../../../../../../core/assert.js";
+import { MeshoptClusterizer } from "./meshopt_clusterizer.js";
+
+/**
+ * Whether meshoptimizer's WASM has landed. The vendored module instantiates it asynchronously at
+ * import and exposes only the promise, so this holds the promise's outcome for the assertion below.
+ *
+ * @type {boolean}
+ */
+let clusterizer_ready = false;
+
+MeshoptClusterizer.ready?.then(() => {
+    clusterizer_ready = true;
+});
+
+/**
+ * Needs meshoptimizer's WASM, which instantiates asynchronously at import. A build before it has
+ * fails inside the vendored module, on an instance that is not there yet, with a message about
+ * `exports` that names nothing the caller did — so await `MeshoptClusterizer.ready` before the
+ * first call.
+ *
+ * @param {RowFirstTable} result_metadata
+ * @param {BinaryBuffer} result_data
+ * @param {number[]} input_index Index array
+ * @param {number} input_index_count Number of active indices at the start of input_index
+ * @param {number} vertex_count Number of vertices in the geometry
+ * @param {Float32Array} vertex_positions
+ * @param {number} [meshlet_vertex_limit]
+ * @param {number} [meshlet_triangle_limit]
+ */
+export function geometry_to_meshlets_meshoptimizer(
+    result_metadata,
+    result_data,
+    input_index,
+    input_index_count,
+    vertex_count,
+    vertex_positions,
+    meshlet_vertex_limit = 64,
+    meshlet_triangle_limit = 64,
+) {
+    assert.ok(clusterizer_ready, 'meshoptimizer is not ready; await MeshoptClusterizer.ready');
+
+    const active_index = input_index_count === input_index.length
+        ? input_index
+        : Array.isArray(input_index)
+            ? input_index.slice(0, input_index_count)
+            : input_index.subarray(0, input_index_count);
+
+    const meshlets = MeshoptClusterizer.buildMeshlets(active_index, vertex_positions, 3, meshlet_vertex_limit, meshlet_triangle_limit, 0.0);
+
+    result_metadata.setCapacity(result_metadata.length + meshlets.meshletCount);
+
+    for (let i = 0; i < meshlets.meshletCount; i++) {
+        const vertex_offset = meshlets.meshlets[i * 4];
+        const triangle_offset = meshlets.meshlets[i * 4 + 1];
+        const vertex_count = meshlets.meshlets[i * 4 + 2];
+        const triangle_count = meshlets.meshlets[i * 4 + 3];
+
+        const output_vertex_offset = result_data.position >>> 2;
+        const output_triangle_offset = output_vertex_offset + vertex_count;
+
+        // at the end of the table, not at the meshoptimizer-side ordinal: the reservation above is
+        // `length + meshletCount`, an append, and `i` equals `length` only when the table arrived
+        // empty. The sibling greedy builder writes here too.
+        result_metadata.writeRow(result_metadata.length, [
+            output_vertex_offset,
+            output_triangle_offset,
+            vertex_count,
+            triangle_count,
+        ]);
+
+        result_metadata.length++;
+
+        result_data.writeUint32Array(meshlets.vertices, vertex_offset, vertex_count);
+        result_data.writeUint32Array(meshlets.triangles, triangle_offset, triangle_count * 3);
+    }
+}

package/src/shade/renderer/geometry/meshlet/build/meshoptimizer/meshopt_clusterizer.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"meshopt_clusterizer.d.ts","sourceRoot":"","sources":["../../../../../../../../src/shade/renderer/geometry/meshlet/build/meshoptimizer/meshopt_clusterizer.js"],"names":[],"mappings":"AAEA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EA8XK"}
+{"version":3,"file":"meshopt_clusterizer.d.ts","sourceRoot":"","sources":["../../../../../../../../src/shade/renderer/geometry/meshlet/build/meshoptimizer/meshopt_clusterizer.js"],"names":[],"mappings":"AAEA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EA+XK"}

package/src/shade/renderer/geometry/meshlet/build/meshoptimizer/meshopt_clusterizer.js

@@ -131,13 +131,14 @@ export var MeshoptClusterizer = (function () {
         var last_vertex_count = meshlets[(count - 1) * 4 + 2];
         var last_triangle_count = meshlets[(count - 1) * 4 + 3];
 
-        var used_vertices = last_vertex_offset + last_vertex_count;
-        var used_triangles = last_triangle_offset + last_triangle_count * 3;
+        var used_vertices = count > 0 ? last_vertex_offset + last_vertex_count : 0;
+        var used_triangles = count > 0 ? last_triangle_offset + last_triangle_count * 3 : 0;
+
 
         var result = {
             meshlets: meshlets,
             vertices: new Uint32Array(heap.buffer, meshlet_verticesp, used_vertices).slice(),
-            triangles: new Uint8Array(heap.buffer, meshlet_trianglesp, used_triangles * 3).slice(),
+            triangles: new Uint8Array(heap.buffer, meshlet_trianglesp, used_triangles).slice(),
             meshletCount: count,
         };
 

package/src/shade/renderer/geometry/meshlet/shader_meshlet_metadata_address_patch.d.ts

@@ -1,16 +1,16 @@
 /**
- * Compute shader that rewrites the `address` field of cloned meshlet
- * metadata records by a per-clone offset. After
- * {@link GPUMeshletManager#clone_batch_allocation} GPU-copies a source
- * batch's metadata into a freshly-allocated metadata range, the cloned
- * records' `address` fields still point at the source's data region;
- * this shader fixes them up so they point at the clone's own data
- * region.
+ * Compute shader that sets the `address` field of selected meshlet
+ * metadata records. A record's rows can land where their `address` is
+ * wrong for it — copied from a source batch into a clone's range by
+ * {@link GPUMeshletManager#clone_batch_allocation}, or left behind when
+ * {@link GPUMeshletManager#sweep} slides the record's data down — and this
+ * shader points them at the record's own data.
  *
- * The input `patches` buffer is a flat array of (record_index,
- * address_delta) pairs — one pair per cloned meshlet record across all
- * clones being flushed in this dispatch. `patch_count` is the number of
- * pairs (i.e. half the array length).
+ * The input `patches` buffer is a flat array of (record_index, address)
+ * pairs, the address computed on the CPU from the batch's relative
+ * addresses and the record's data offset. `patch_count` is the number of
+ * pairs (i.e. half the array length). The value written does not depend
+ * on what the row held, so a row named twice is set twice to the same word.
  *
  * Dispatch via `dispatchThreads({ thread_count_x: patch_count, ... })`.
  */

package/src/shade/renderer/geometry/meshlet/shader_meshlet_metadata_address_patch.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"shader_meshlet_metadata_address_patch.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/geometry/meshlet/shader_meshlet_metadata_address_patch.js"],"names":[],"mappings":"AAmDA;;;;;;;;;;;;;;;GAeG;AACH,kEAIG;8BApE2B,+BAA+B"}
+{"version":3,"file":"shader_meshlet_metadata_address_patch.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/geometry/meshlet/shader_meshlet_metadata_address_patch.js"],"names":[],"mappings":"AAiDA;;;;;;;;;;;;;;;GAeG;AACH,kEAIG;8BAlE2B,+BAA+B"}

package/src/shade/renderer/geometry/meshlet/shader_meshlet_metadata_address_patch.js

@@ -8,8 +8,8 @@ import { MESHLET_METADATA_STRUCT } from "./encoding/MESHLET_METADATA_STRUCT.js";
 const WORKGROUP_SIZE = 64;
 
 // Each patch is two consecutive u32s in the `patches` storage buffer:
-//   patches[i*2 + 0] = record_index   — offset into meshlet_metadata
-//   patches[i*2 + 1] = address_delta  — value to add to that record's `address`
+//   patches[i*2 + 0] = record_index — offset into meshlet_metadata
+//   patches[i*2 + 1] = address      — the word that record's `address` is set to
 //
 // Flat-pair layout means a batch of N clones (with M_total cloned meshlets
 // in aggregate) flushes through one dispatch over M_total threads, no
@@ -36,13 +36,11 @@ fn main(@builtin(global_invocation_id) gid: vec3<u32>) {
     // Pair-of-u32 packing: avoids declaring a struct for the patches buffer
     // and lets the JS side stage entries with a single Uint32Array view.
     let record_index = patches[i * 2u];
-    let address_delta = patches[i * 2u + 1u];
+    let address = patches[i * 2u + 1u];
 
-    // u32 wraparound add: when delta is negative-as-i32, wrapping addition
-    // still produces the correct absolute target address as long as
-    // (source_address + delta) lands in the buffer's word range — which it
-    // does by construction (delta = clone_data_offset - source_data_offset).
-    meshlet_metadata[record_index].address = meshlet_metadata[record_index].address + address_delta;
+    // A store, not an add to what the row holds: nothing orders two invocations
+    // that name one row, and an add from each would lose one of them.
+    meshlet_metadata[record_index].address = address;
 }
 `, [
         MESHLET_METADATA_STRUCT.declaration_chunk,
@@ -50,18 +48,18 @@ fn main(@builtin(global_invocation_id) gid: vec3<u32>) {
 );
 
 /**
- * Compute shader that rewrites the `address` field of cloned meshlet
- * metadata records by a per-clone offset. After
- * {@link GPUMeshletManager#clone_batch_allocation} GPU-copies a source
- * batch's metadata into a freshly-allocated metadata range, the cloned
- * records' `address` fields still point at the source's data region;
- * this shader fixes them up so they point at the clone's own data
- * region.
+ * Compute shader that sets the `address` field of selected meshlet
+ * metadata records. A record's rows can land where their `address` is
+ * wrong for it — copied from a source batch into a clone's range by
+ * {@link GPUMeshletManager#clone_batch_allocation}, or left behind when
+ * {@link GPUMeshletManager#sweep} slides the record's data down — and this
+ * shader points them at the record's own data.
  *
- * The input `patches` buffer is a flat array of (record_index,
- * address_delta) pairs — one pair per cloned meshlet record across all
- * clones being flushed in this dispatch. `patch_count` is the number of
- * pairs (i.e. half the array length).
+ * The input `patches` buffer is a flat array of (record_index, address)
+ * pairs, the address computed on the CPU from the batch's relative
+ * addresses and the record's data offset. `patch_count` is the number of
+ * pairs (i.e. half the array length). The value written does not depend
+ * on what the row held, so a row named twice is set twice to the same word.
  *
  * Dispatch via `dispatchThreads({ thread_count_x: patch_count, ... })`.
  */

package/src/shade/renderer/geometry/meshlet_batch_to_bvh.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"meshlet_batch_to_bvh.d.ts","sourceRoot":"","sources":["../../../../../src/shade/renderer/geometry/meshlet_batch_to_bvh.js"],"names":[],"mappings":"AAUA;;;;;;;;GAQG;AACH;IANwB,GAAG;IACM,QAAQ;IACR,YAAY,EAAlC,YAAY;IACI,eAAe,EAA/B,MAAM;IACW,YAAY,GAA7B,MAAM;SA4NhB"}
+{"version":3,"file":"meshlet_batch_to_bvh.d.ts","sourceRoot":"","sources":["../../../../../src/shade/renderer/geometry/meshlet_batch_to_bvh.js"],"names":[],"mappings":"AAUA;;;;;;;;GAQG;AACH;IANwB,GAAG;IACM,QAAQ;IACR,YAAY,EAAlC,YAAY;IACI,eAAe,EAA/B,MAAM;IACW,YAAY,GAA7B,MAAM;SAqOhB"}

package/src/shade/renderer/geometry/meshlet_batch_to_bvh.js

@@ -32,23 +32,46 @@ export function meshlet_batch_to_bvh({
 
     const meshlet_count = meshlets.count;
 
-    // we assume that the total number of triangles is the same in the meshlet batch
-    // this *should* be true.
-    const node_leaf_count = primitive_count;
+    bvh.release_all();
 
+    if (meshlet_count === 0) {
+        bvh.root = NULL_NODE;
+        bvh.trim();
+        return;
+    }
 
-    const node_bin_count = max2(0, node_leaf_count - 1);
+    // order meshlet indices by morton codes and count actual triangles in the batch
+    const meshlet_morton_codes = new Uint32Array(meshlet_count);
+    let node_leaf_count = 0;
 
-    const node_total_count = node_leaf_count + node_bin_count;
+    for (let i = 0; i < meshlet_count; i++) {
 
-    bvh.release_all();
+        const header = meshlets.read_header(i);
+
+        node_leaf_count += header.primitive_count;
+
+        const bb = header.bounds_box;
+
+        const center_x = (bb[0] + bb[3]) * 0.5;
+        const center_y = (bb[1] + bb[4]) * 0.5;
+        const center_z = (bb[2] + bb[5]) * 0.5;
+
+        meshlet_morton_codes[i] = v3_morton_encode_bounded(
+            center_x, center_y, center_z,
+            bounding_box,
+        );
+    }
 
     if (node_leaf_count === 0) {
-        // special case, should not happen in practice
         bvh.root = NULL_NODE;
+        bvh.trim();
         return;
     }
 
+    const node_bin_count = max2(0, node_leaf_count - 1);
+
+    const node_total_count = node_leaf_count + node_bin_count;
+
     bvh.allocate_linear(node_total_count);
 
     const partial_tree_nodes = new Uint32Array(meshlet_count);
@@ -73,25 +96,6 @@ export function meshlet_batch_to_bvh({
             bottom_tree_node_pool[i] = node;
         }
 
-
-        // order meshlet indices by morton codes
-        const meshlet_morton_codes = new Uint32Array(meshlet_count);
-        for (let i = 0; i < meshlet_count; i++) {
-
-            const header = meshlets.read_header(i);
-
-            const bb = header.bounds_box;
-
-            const center_x = (bb[0] + bb[3]) * 0.5;
-            const center_y = (bb[1] + bb[4]) * 0.5;
-            const center_z = (bb[2] + bb[5]) * 0.5;
-
-            meshlet_morton_codes[i] = v3_morton_encode_bounded(
-                center_x, center_y, center_z,
-                bounding_box,
-            );
-        }
-
         const sorted_indices = new Uint32Array(meshlet_count);
         for (let i = 0; i < meshlet_count; i++) {
             sorted_indices[i] = i;
@@ -114,6 +118,8 @@ export function meshlet_batch_to_bvh({
 
             const meshlet_triangle_count = meshlet_header.primitive_count;
 
+            assert.greaterThan(meshlet_triangle_count, 0, 'meshlet_triangle_count');
+
             for (let triangle_index = 0; triangle_index < meshlet_triangle_count; triangle_index++) {
 
                 const index3 = triangle_index * 3;
@@ -173,6 +179,7 @@ export function meshlet_batch_to_bvh({
             partial_tree_nodes[i] = bottom_tree_node_scratch[0];
         }
 
+        assert.equal(bottom_tree_node_cursor, bottom_tree_node_count, 'bottom_tree_node_cursor !== bottom_tree_node_count');
     }
 
     // ===========
@@ -216,6 +223,8 @@ export function meshlet_batch_to_bvh({
 
         }
 
+        assert.equal(top_tree_node_cursor, top_tree_node_count, 'top_tree_node_cursor !== top_tree_node_count');
+
         const root = partial_tree_nodes[0];
 
         assert.equal(root, 0, 'root must be node 0');

package/src/shade/renderer/geometry/meshlet_geometry_build_from_geometry.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"meshlet_geometry_build_from_geometry.d.ts","sourceRoot":"","sources":["../../../../../src/shade/renderer/geometry/meshlet_geometry_build_from_geometry.js"],"names":[],"mappings":"AAIA;;;;;;;;;;;;;;;;;;;;;;;;;;GA0BG;AACH,+EAJW,eAAe,GACb,eAAe,CAqC3B;gCA/D+B,sBAAsB"}
+{"version":3,"file":"meshlet_geometry_build_from_geometry.d.ts","sourceRoot":"","sources":["../../../../../src/shade/renderer/geometry/meshlet_geometry_build_from_geometry.js"],"names":[],"mappings":"AAIA;;;;;;;;;;;;;;;;;;;;;;;;;;GA0BG;AACH,+EAJW,eAAe,GACb,eAAe,CAsC3B;gCAhE+B,sBAAsB"}