@woosh/meep-engine 3.55.0 → 3.57.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/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/global_illumination/lpv/graph_bake_irradiance_lookup_2d.js

@@ -7,9 +7,9 @@ import { CAMERA_UNIFORM_STRUCT } from "../../camera/CAMERA_UNIFORM_STRUCT.js";
 import { DEPTH_BACKGROUND_VALUE } from "../../depth/DEPTH_BACKGROUND_VALUE.js";
 import { BVH_STRUCT } from "../../shader/chunk/bvh/BVH_STRUCT.js";
 import { chunk_v3_matrix4_project } from "../../shader/chunk/geometry/vec3/chunk_v3_matrix4_project.js";
-import { chunk_sh3_to_sh2_color } from "../../shader/chunk/light/lpv/chunk_lpv_mesh_interpolate_probe.js";
+import { chunk_lpv_mesh_lookup_nearest_cell } from "../../shader/chunk/light/lpv/chunk_lpv_mesh_lookup_nearest_cell.js";
+
 
-import { chunk_lpv_sample_sh3_at } from "../../shader/chunk/light/lpv/chunk_lpv_sample_sh3_at.js";
 import {
     chunk_texture_sample_bilinear_uv
 } from "../../shader/chunk/texture/sample/chunk_texture_sample_bilinear_uv.js";
@@ -88,8 +88,8 @@ fn main(
         CAMERA_UNIFORM_STRUCT.declaration_chunk,
         chunk_v3_matrix4_project,
         chunk_texture_sample_bilinear_uv,
-        chunk_lpv_sample_sh3_at,
-        chunk_sh3_to_sh2_color,
+        chunk_lpv_mesh_lookup_nearest_cell,
+
     ]).compile().text;
 
 const compute_pipeline = ComputePipelineDescriptor.simplified({

package/src/shade/renderer/global_illumination/probe/octahedral/sample/chunk_lpv_mesh_interpolate_radiance_via_atlas.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"chunk_lpv_mesh_interpolate_radiance_via_atlas.d.ts","sourceRoot":"","sources":["../../../../../../../../src/shade/renderer/global_illumination/probe/octahedral/sample/chunk_lpv_mesh_interpolate_radiance_via_atlas.js"],"names":[],"mappings":"AAMA;;;GAGG;AACH,4DAFU,SAAS,CAgDlB;0BArDyB,0CAA0C"}
+{"version":3,"file":"chunk_lpv_mesh_interpolate_radiance_via_atlas.d.ts","sourceRoot":"","sources":["../../../../../../../../src/shade/renderer/global_illumination/probe/octahedral/sample/chunk_lpv_mesh_interpolate_radiance_via_atlas.js"],"names":[],"mappings":"AAMA;;;GAGG;AACH,4DAFU,SAAS,CAoDlB;0BAzDyB,0CAA0C"}

package/src/shade/renderer/global_illumination/probe/octahedral/sample/chunk_lpv_mesh_interpolate_radiance_via_atlas.js

@@ -35,7 +35,11 @@ fn lpv_mesh_interpolate_radiance_via_atlas(
     c_weights *= coord.barycentric;
     
     // normalize weights
-    c_weights /= dot(c_weights, vec4(1.0));
+    let weight_sum = dot(c_weights, vec4(1.0));
+    if (weight_sum <= 0.0) {
+        return vec3(0.0);
+    }
+    c_weights /= weight_sum;
     
     
     let radiance = color_mix_4_linear(

package/src/shade/renderer/loader/gltf/load_gltf.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"load_gltf.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/loader/gltf/load_gltf.js"],"names":[],"mappings":"AAsIA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA6CG;AACH,sDATW,YAAY,aAGZ,MAAM,iBACN,MAAM,kBACN;IAAC,CAAC,EAAC,MAAM,CAAC;IAAC,CAAC,EAAC,MAAM,CAAC;IAAC,CAAC,EAAC,MAAM,CAAC;IAAC,CAAC,EAAC,MAAM,CAAA;CAAC,QAUlD;AAuBD;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2BG;AACH,+BAdW,MAAM;IAEgB,YAAY;IAGN,KAAK;IACY,OAAO,GAApD,IAAI,MAAM,EAAE,IAAI,GAAC,IAAI,GAAC,WAAW,CAAC;IAGF,eAAe,GAA/C,qBAAqB;IAGpB,QAAQ,WAAW,CAAC,CA00B/B;AAED;;;;;;;;;;;;;;;;;;GAkBG;AACH,wCARW,MAAM;IAEgB,YAAY;IACN,KAAK;IACY,OAAO,GAApD,IAAI,MAAM,EAAE,IAAI,GAAC,IAAI,GAAC,WAAW,CAAC;IACF,eAAe,GAA/C,qBAAqB;IACnB,QAAQ,QAAQ,CAAC,CAU7B;4BAjjC2B,mBAAmB;yBAWtB,gBAAgB"}
+{"version":3,"file":"load_gltf.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/loader/gltf/load_gltf.js"],"names":[],"mappings":"AAsIA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA6CG;AACH,sDATW,YAAY,aAGZ,MAAM,iBACN,MAAM,kBACN;IAAC,CAAC,EAAC,MAAM,CAAC;IAAC,CAAC,EAAC,MAAM,CAAC;IAAC,CAAC,EAAC,MAAM,CAAC;IAAC,CAAC,EAAC,MAAM,CAAA;CAAC,QAUlD;AAuBD;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2BG;AACH,+BAdW,MAAM;IAEgB,YAAY;IAGN,KAAK;IACY,OAAO,GAApD,IAAI,MAAM,EAAE,IAAI,GAAC,IAAI,GAAC,WAAW,CAAC;IAGF,eAAe,GAA/C,qBAAqB;IAGpB,QAAQ,WAAW,CAAC,CAkzB/B;AAED;;;;;;;;;;;;;;;;;;GAkBG;AACH,wCARW,MAAM;IAEgB,YAAY;IACN,KAAK;IACY,OAAO,GAApD,IAAI,MAAM,EAAE,IAAI,GAAC,IAAI,GAAC,WAAW,CAAC;IACF,eAAe,GAA/C,qBAAqB;IACnB,QAAQ,QAAQ,CAAC,CAU7B;4BAzhC2B,mBAAmB;yBAWtB,gBAAgB"}

package/src/shade/renderer/loader/gltf/load_gltf.js

@@ -715,37 +715,13 @@ export function load_gltf(url, { assetManager, scope, fileMap, texture_support }
             // produced here are queued and pushed into `skin.meshes` once the walk finishes.
             const skin_index = typeof node.skin === "number" ? node.skin : -1;
 
-            const record = new SceneNode();
-
-            record.parent = parent;
-
-            if (node.name !== undefined) {
-                record.name = node.name;
-            }
-
+            const record = SceneNode.from(
+                node.matrix !== undefined
+                    ? { name: node.name, parent, matrix: node.matrix }
+                    : { name: node.name, parent, translation: node.translation, rotation: node.rotation, scale: node.scale }
+            );
             const t = record.local;
 
-            if (node.matrix !== undefined) {
-                t.fromMatrix(node.matrix);
-            } else {
-                if (node.translation !== undefined) {
-                    const v = node.translation;
-                    t.setTranslation(v[0], v[1], v[2]);
-                }
-
-                if (node.rotation !== undefined) {
-                    const q = node.rotation;
-                    t.setRotation(q[0], q[1], q[2], q[3]);
-                }
-
-                if (node.scale !== undefined) {
-                    const v = node.scale;
-                    t.setScale(v[0], v[1], v[2]);
-                }
-
-                t.updateMatrix();
-            }
-
             const index = bundle.add_node(record);
 
             // joint refs, channel targets and light anchors resolve through this once the
@@ -801,12 +777,12 @@ export function load_gltf(url, { assetManager, scope, fileMap, texture_support }
                     // one child per primitive, each named after the mesh, at the node's own place
                     for (let i = 0; i < primitives.length; i++) {
                         const primitive = primitives[i];
-                        const child = new SceneNode();
-
-                        child.parent = index;
-                        child.name = primitive.name;
-                        child.geometry = primitive.geometry;
-                        child.material = primitive.material;
+                        const child = SceneNode.from({
+                            name: primitive.name,
+                            parent: index,
+                            geometry: primitive.geometry,
+                            material: primitive.material,
+                        });
 
                         produced.push(bundle.add_node(child));
                     }

package/src/shade/renderer/loader/usd/load_usd.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"load_usd.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/loader/usd/load_usd.js"],"names":[],"mappings":"AAyDA;;;;;;;;;;;;;GAaG;AACH,iCAPW,WAAW,YACX,cAAc,GACZ,QAAQ,OAAO,mBAAmB,EAAE,WAAW,CAAC,CAuE5D;;;;;eA3Ga,MAAM;;;;iBACN,oBAAoB;;qCAN6B,2BAA2B"}
+{"version":3,"file":"load_usd.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/loader/usd/load_usd.js"],"names":[],"mappings":"AA2DA;;;;;;;;;;;;;GAaG;AACH,iCAPW,WAAW,YACX,cAAc,GACZ,QAAQ,OAAO,mBAAmB,EAAE,WAAW,CAAC,CAuE5D;;;;;eA3Ga,MAAM;;;;iBACN,oBAAoB;;qCAN6B,2BAA2B"}

package/src/shade/renderer/loader/usd/load_usd.js

@@ -18,6 +18,8 @@
  * @module load_usd
  */
 
+import { utf8_decode } from "../../../../core/binary/utf8/utf8_decode.js";
+import { array_range_equal_strict } from "../../../../core/collection/array/array_range_equal_strict.js";
 import { computeFileExtension } from "../../../../core/path/computeFileExtension.js";
 import { parse_usda } from "../../../../format/scene/usd/parse_usda.js";
 import { unpack_usdz } from "../../../../format/scene/usd/unpack_usdz.js";
@@ -160,16 +162,8 @@ function detect_format(buffer, fileName) {
     }
 
     // Check for USDA text header
-    if (bytes.length >= 6) {
-        let header = "";
-
-        for (let i = 0; i < 6; i++) {
-            header += String.fromCharCode(bytes[i]);
-        }
-
-        if (header === USDA_HEADER) {
-            return "usda";
-        }
+    if (bytes.length >= 6 && utf8_decode(bytes, 0, 6) === USDA_HEADER) {
+        return "usda";
     }
 
     // Fall back to file extension
@@ -196,14 +190,7 @@ function detect_format(buffer, fileName) {
  * @returns {boolean}
  */
 function bytes_match(data, magic) {
-
-    if (data.length < magic.length) return false;
-
-    for (let i = 0; i < magic.length; i++) {
-        if (data[i] !== magic[i]) return false;
-    }
-
-    return true;
+    return data.length >= magic.length && array_range_equal_strict(data, 0, magic, 0, magic.length);
 }
 
 
@@ -221,5 +208,5 @@ function decode_utf8(buffer, byteOffset = 0, byteLength) {
         ? new Uint8Array(buffer, byteOffset, byteLength)
         : new Uint8Array(buffer, byteOffset);
 
-    return new TextDecoder("utf-8").decode(view);
+    return utf8_decode(view);
 }