@woosh/meep-engine 3.40.0 → 3.42.0

package/src/shade/renderer/camera/orbital/OrbitalCameraRig.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"OrbitalCameraRig.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/camera/orbital/OrbitalCameraRig.js"],"names":[],"mappings":"AAYA;;;;;;;;;;;;;;;;;;GAkBG;AACH;IACI;;;;;OAKG;IACH;QAJkE,MAAM,GAA7D,WAAW,gCAAgC,CAAC;QAClB,cAAc,GAAxC,eAAe;QACE,kBAAkB,GAAnC,MAAM;OA4BhB;IAzBG;;;;kCAPJ;;;;;WAKG;;;;;;;;;OAEqB;IACpB,gCAAsE;IACtE,2BAA4C;IAG5C,mBAAyC;IACzC,qBAAiC;IACjC,kBAA8B;IAC9B,kBAA8B;IAC9B,kBAA8B;IAG9B,iBAAiB;IAIjB,sBAAyB;IAGzB;;;;;;;;;;;;;;MAAgB;IAGhB,6BAAwC;IACxC,+BAA0C;IAC1C,wBAAmC;IAOvC,0FAA0F;IAC1F,qBAIC;IAED;;;;;OAKG;IACH,aAHW,MAAM,UACN,MAAM,QAKhB;IAED,4FAA4F;IAC5F,wBAGC;IAMD,mDAAmD;IACnD,kBAKC;IAED;;;;;;;OAOG;IACH,cALW,MAAM,MACN,MAAM,kBACN,MAAM,OACN,MAAM,QAsBhB;IAED,kFAAkF;IAClF,qBAMC;IAMD;;;;OAIG;IACH,cAFW,MAAM,QAQhB;IAED,6DAA6D;IAC7D,iCAGC;IAED;;;;;;;OAOG;IACH,cAJW,MAAM,KACN,MAAM,MACN,MAAM,QAuBhB;IAMD;;;;;;;OAOG;IACH,cALW,OAAO,MACP,OAAO;QAEQ,OAAO,GAAtB,OAAO;aAyBjB;IAMD;;;;;OAKG;IACH,WAHW,MAAM,GACJ,OAAO,CAoCnB;IAED;;;;;OAKG;IACH,4CASC;IAID,kBAAqC;IACrC,oBAAyC;IACzC,yDAAyD;IACzD,wBAQC;IAED;;;;;OAKG;IACH,gBAHW,OAAO,GACL,OAAO,CAMnB;IAMD,8BAiBC;IAED;;;;MAaC;IAED,0BAGC;IAED,yEAAyE;IACzE,oCAOC;IAED,iFAYC;IAED,yEAAyE;IACzE,iDAIC;CACJ;gCA3Y+B,mDAAmD;6BAGtD,mBAAmB;4BADpB,iDAAiD;oBADzD,kCAAkC;0CAGZ,0BAA0B"}
+{"version":3,"file":"OrbitalCameraRig.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/camera/orbital/OrbitalCameraRig.js"],"names":[],"mappings":"AAYA;;;;;;;;;;;;;;;;;;GAkBG;AACH;IACI;;;;;OAKG;IACH;QAJkE,MAAM,GAA7D,WAAW,gCAAgC,CAAC;QAClB,cAAc,GAAxC,eAAe;QACE,kBAAkB,GAAnC,MAAM;OA4BhB;IAzBG;;;;kCAPJ;;;;;WAKG;;;;;;;;;OAEqB;IACpB,gCAAsE;IACtE,2BAA4C;IAG5C,mBAAyC;IACzC,qBAAiC;IACjC,kBAA8B;IAC9B,kBAA8B;IAC9B,kBAA8B;IAG9B,iBAAiB;IAIjB,sBAAyB;IAGzB;;;;;;;;;;;;;;MAAgB;IAGhB,6BAAwC;IACxC,+BAA0C;IAC1C,wBAAmC;IAOvC,0FAA0F;IAC1F,qBAIC;IAED;;;;;OAKG;IACH,aAHW,MAAM,UACN,MAAM,QAKhB;IAED,4FAA4F;IAC5F,wBAGC;IAMD,mDAAmD;IACnD,kBAKC;IAED;;;;;;;OAOG;IACH,cALW,MAAM,MACN,MAAM,kBACN,MAAM,OACN,MAAM,QAsBhB;IAED,kFAAkF;IAClF,qBAMC;IAED,8EAA8E;IAC9E,sBAQC;IAMD;;;;OAIG;IACH,cAFW,MAAM,QAQhB;IAED,6DAA6D;IAC7D,iCAGC;IAED;;;;;;;OAOG;IACH,cAJW,MAAM,KACN,MAAM,MACN,MAAM,QAuBhB;IAMD;;;;;;;OAOG;IACH,cALW,OAAO,MACP,OAAO;QAEQ,OAAO,GAAtB,OAAO;aAyBjB;IAMD;;;;;OAKG;IACH,WAHW,MAAM,GACJ,OAAO,CAoCnB;IAED;;;;;OAKG;IACH,4CASC;IAID,kBAAqC;IACrC,oBAAyC;IACzC,yDAAyD;IACzD,wBAQC;IAED;;;;;OAKG;IACH,gBAHW,OAAO,GACL,OAAO,CAMnB;IAMD,8BAiBC;IAED;;;;MAaC;IAED,0BAGC;IAED,yEAAyE;IACzE,oCAOC;IAED,iFAYC;IAED,yEAAyE;IACzE,iDAIC;CACJ;gCAtZ+B,mDAAmD;6BAGtD,mBAAmB;4BADpB,iDAAiD;oBADzD,kCAAkC;0CAGZ,0BAA0B"}

package/src/shade/renderer/camera/orbital/OrbitalCameraRig.js

@@ -143,6 +143,17 @@ export class OrbitalCameraRig {
         this._tz.release(w, m);
     }
 
+    /** Abort direct control without throwing, retaining the last applied pose. */
+    cancelGesture() {
+        this._phi.settle(this._phi.value);
+        this._theta.settle(this._theta.value);
+        this._tx.settle(this._tx.value);
+        this._ty.settle(this._ty.value);
+        this._tz.settle(this._tz.value);
+        // The last drag may not have reached the facade's next frame yet.
+        this._directDirty = true;
+    }
+
     // ─────────────────────────────────────────────────────────────────────────
     //  Zoom + keyboard (direct, no momentum)
     // ─────────────────────────────────────────────────────────────────────────

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

@@ -7,7 +7,7 @@
  * @param {RowFirstTable} result_metadata
  * @param {BinaryBuffer} result_data
  * @param {number[]} input_index Index array
- * @param {number} input_index_count
+ * @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]

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,QAmDhB"}
+{"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"}

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

@@ -23,7 +23,7 @@ MeshoptClusterizer.ready?.then(() => {
  * @param {RowFirstTable} result_metadata
  * @param {BinaryBuffer} result_data
  * @param {number[]} input_index Index array
- * @param {number} input_index_count
+ * @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]
@@ -41,7 +41,13 @@ export function geometry_to_meshlets_meshoptimizer(
 ) {
     assert.ok(clusterizer_ready, 'meshoptimizer is not ready; await MeshoptClusterizer.ready');
 
-    const meshlets = MeshoptClusterizer.buildMeshlets(input_index, vertex_positions, 3, meshlet_vertex_limit, meshlet_triangle_limit, 0.0);
+    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);
 
@@ -78,4 +84,4 @@ export function geometry_to_meshlets_meshoptimizer(
         result_data.writeUint32Array(meshlets.triangles, triangle_offset, triangle_count * 3);
 
     }
-}
+}

package/src/shade/renderer/geometry/util/geometry_simplify_redundant_topology.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"geometry_simplify_redundant_topology.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/geometry/util/geometry_simplify_redundant_topology.js"],"names":[],"mappings":"AAWA;;;;GAIG;AAEH;;;;;;;;;;;;;;;;;;;;;;GAsBG;AACH,6DAJW,QAAQ,YACR,uBAAuB,GACrB,QAAQ,CAsCpB;;;;;8BA/Da,MAAM;;;;0BACN,MAAM;;;;;;oBAkEN,MAAM,EAAE,EAAE;;;;gBACV,IAAI,MAAM,CAAC,EAAE;;yBA7EF,gBAAgB"}
+{"version":3,"file":"geometry_simplify_redundant_topology.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/geometry/util/geometry_simplify_redundant_topology.js"],"names":[],"mappings":"AAWA;;;;GAIG;AAEH;;;;;;;;;;;;;;;;;;;;;;GAsBG;AACH,6DAJW,QAAQ,YACR,uBAAuB,GACrB,QAAQ,CAsCpB;;;;;8BA/Da,MAAM;;;;0BACN,MAAM;;;;;;oBAkEN,MAAM,EAAE,EAAE;;;;gBACV,IAAI,MAAM,CAAC,EAAE;;yBA7Ea,gBAAgB"}

package/src/shade/renderer/geometry/util/geometry_simplify_redundant_topology.js

@@ -2,7 +2,7 @@ import { v3_array_normalize } from "../../../../core/geom/vec3/v3_array_normaliz
 import { v3_cross_array } from "../../../../core/geom/vec3/v3_cross_array.js";
 import { v3_dot } from "../../../../core/geom/vec3/v3_dot.js";
 import { Attribute } from "../Attribute.js";
-import { Geometry } from "../Geometry.js";
+import { Geometry, GeometryFlags } from "../Geometry.js";
 import { geometry_deduplicate_vertices } from "../geometry_deduplicate_vertices.js";
 import { StandardAttributes } from "../StandardAttributes.js";
 
@@ -363,7 +363,7 @@ function apply_remap_and_compact(source, remap) {
     // Build new geometry with compacted attribute arrays
     const result = new Geometry();
     result.name = source.name;
-    result.flags = source.flags;
+    result.flags = source.flags | GeometryFlags.BoundsNeedUpdate;
 
     for (const src_attr of source.attributes) {
         const stride = src_attr.spec.itemSize;

package/src/shade/renderer/geometry/virtual/format/vgeo_validate_container.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"vgeo_validate_container.d.ts","sourceRoot":"","sources":["../../../../../../../src/shade/renderer/geometry/virtual/format/vgeo_validate_container.js"],"names":[],"mappings":"AA+xDA;;;;;;;;;GASG;AACH,gDAHW,YAAY,GACV,QAAQ,UAAU,EAAE,CAAC,CAqFjC;6BA53D4B,4CAA4C;2BAoD9C,iBAAiB"}
+{"version":3,"file":"vgeo_validate_container.d.ts","sourceRoot":"","sources":["../../../../../../../src/shade/renderer/geometry/virtual/format/vgeo_validate_container.js"],"names":[],"mappings":"AAk3DA;;;;;;;;;GASG;AACH,gDAHW,YAAY,GACV,QAAQ,UAAU,EAAE,CAAC,CAuFjC;6BAj9D4B,4CAA4C;2BAoD9C,iBAAiB"}

package/src/shade/renderer/geometry/virtual/format/vgeo_validate_container.js

@@ -381,6 +381,12 @@ function check_header(buffer, out) {
         usable = false;
     }
 
+    if (root_page_offset >= directory_offset) {
+        out.push(new VGeoDefect(VGEO_DEFECT.HEADER, `root_page_offset ${root_page_offset} is not before directory_offset ${directory_offset}`));
+
+        usable = false;
+    }
+
     // Byte 103 was reserved through `format_version` 5 and is `level_count`'s high byte from 6 on,
     // so there is nothing left to check between it and `source_vertex_count`; the read above landed
     // at 104 and the one below expects to start there.
@@ -425,6 +431,63 @@ function check_header(buffer, out) {
     return usable;
 }
 
+/**
+ * @param {BinaryBuffer} buffer with a checked, in-file level table
+ * @param {number} level_count
+ * @param {number} total_clusters
+ * @param {number} total_groups
+ * @param {VGeoDefect[]} out
+ */
+function check_levels(buffer, level_count, total_clusters, total_groups, out) {
+    let counted_clusters = 0;
+    let counted_groups = 0;
+
+    for (let level = 0; level < level_count; level++) {
+        const base = VGEO_HEADER_SIZE + level * VGEO_LEVEL_RECORD_SIZE;
+
+        buffer.position = base;
+
+        const min_error = buffer.readFloat32();
+        const max_error = buffer.readFloat32();
+
+        if (!Number.isFinite(min_error) || min_error < 0) {
+            out.push(new VGeoDefect(VGEO_DEFECT.HEADER, `level ${level}: min_error ${min_error} must be finite and non-negative`));
+        }
+
+        if (!Number.isFinite(max_error) || max_error < 0) {
+            out.push(new VGeoDefect(VGEO_DEFECT.HEADER, `level ${level}: max_error ${max_error} must be finite and non-negative`));
+        }
+
+        if (min_error > max_error) {
+            out.push(new VGeoDefect(VGEO_DEFECT.HEADER, `level ${level}: min_error ${min_error} exceeds max_error ${max_error}`));
+        }
+
+        buffer.position = base + 12;
+
+        const cluster_count = buffer.readUint32();
+        const group_count = buffer.readUint32();
+
+        if (cluster_count === 0) {
+            out.push(new VGeoDefect(VGEO_DEFECT.HEADER, `level ${level}: cluster_count is 0`));
+        }
+
+        if (group_count === 0) {
+            out.push(new VGeoDefect(VGEO_DEFECT.HEADER, `level ${level}: group_count is 0`));
+        }
+
+        counted_clusters += cluster_count;
+        counted_groups += group_count;
+    }
+
+    if (counted_clusters !== total_clusters) {
+        out.push(new VGeoDefect(VGEO_DEFECT.HEADER, `level table holds ${counted_clusters} clusters, header says ${total_clusters}`));
+    }
+
+    if (counted_groups !== total_groups) {
+        out.push(new VGeoDefect(VGEO_DEFECT.HEADER, `level table holds ${counted_groups} groups, header says ${total_groups}`));
+    }
+}
+
 /**
  * @param {BinaryBuffer} buffer whole file
  * @param {VGeoDefect[]} out
@@ -865,6 +928,7 @@ function check_page_nodes(pages, page_groups, page_clusters, out) {
          * @type {Int32Array}
          */
         const group_hits = new Int32Array(groups.length);
+        const node_hits = new Int32Array(nodes.length);
 
         let structural = true;
 
@@ -902,12 +966,31 @@ function check_page_nodes(pages, page_groups, page_clusters, out) {
 
                 structural = false;
             }
+
+            for (let i = 0; i < node.child_count; i++) {
+                node_hits[node.child_first + i]++;
+            }
         });
 
         if (!structural) {
             continue;
         }
 
+        // Strictly forward children with one parent per non-root node form one rooted tree.
+        for (let index = 0; index < nodes.length; index++) {
+            const expected = index === 0 ? 0 : 1;
+
+            if (node_hits[index] !== expected) {
+                out.push(new VGeoDefect(VGEO_DEFECT.PAGE_LAYOUT, `page ${page.page_index} node ${index}: has ${node_hits[index]} incoming node references, expected ${expected}`));
+
+                structural = false;
+            }
+        }
+
+        if (!structural) {
+            continue;
+        }
+
         const unreached = group_hits.reduce((count, hits) => count + (hits === 0 ? 1 : 0), 0);
         const repeated = group_hits.reduce((count, hits) => count + (hits > 1 ? 1 : 0), 0);
 
@@ -1847,6 +1930,8 @@ export async function vgeo_validate_container(buffer) {
     const total_clusters = Number(buffer.readUint64());
     const total_groups = Number(buffer.readUint64());
 
+    check_levels(buffer, level_count, total_clusters, total_groups, out);
+
     buffer.position = VGEO_HEADER_OFFSET.OBJECT_SPHERE;
 
     const object_sphere = read_sphere(buffer);

package/src/shade/renderer/geometry/virtual/runtime/GPUVirtualGeometryRuntime.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"GPUVirtualGeometryRuntime.d.ts","sourceRoot":"","sources":["../../../../../../../src/shade/renderer/geometry/virtual/runtime/GPUVirtualGeometryRuntime.js"],"names":[],"mappings":"AAoBA;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AACH;IAiHI;;;;;;;;;;;;;;;OAeG;IACH;QAd2C,IAAI,EAApC,sBAAsB;QACL,aAAa,GAA9B,MAAM;QACW,qBAAqB,GAAtC,MAAM;QAEW,mBAAmB,GAApC,MAAM;QAEW,cAAc,GAA/B,MAAM;QACW,cAAc,GAA/B,MAAM;QAEW,qBAAqB,GAAtC,MAAM;QACW,aAAa,GAA9B,MAAM;OAgFhB;IAzKD;;;;OAIG;IACH,KAFU,MAAM,CAER;IAER;;OAEG;IACH,cAFU,OAAO,CAEG;IAiKpB;;OAEG;IACH,yEAEC;IAED;;;;OAIG;IACH,4BAEC;IAED;;OAEG;IACH,6BAEC;IAED;;OAEG;IACH,kCAEC;IAED;;;;;OAKG;IACH,6BAEC;IAED;;;;OAIG;IACH,gCAEC;IAWD;;;;;;OAMG;IACH,iCAKC;IArBD;;;;OAIG;IACH,4BAEC;IAgBD;;;;OAIG;IACH,0BAEC;IAED;;;;OAIG;IACH,yDAEC;IAED;;;;;OAKG;IACH,2BAEC;IAED;;OAEG;IACH;;;;;;;;MAEC;IAED;;;;;;;;;;;;;;;;;;;;;;;;;OAyBG;IACH;QAHgC,IAAI,EAAzB,WAAW;QACT,IAAI,CAoChB;IAwBD;;;;;;;;;;OAUG;IACH,cAHW,WAAW,GACT,MAAM,CA0BlB;IAED;;;;;;OAMG;IACH,mBAHW,MAAM,GACJ,MAAM,CAIlB;IAED;;;;;OAKG;IACH,eAFa,WAAW,EAAE,EAAE,CAI3B;IAED;;;;;;;;;OASG;IACH,mBAHW,UAAU,GACR,MAAM,CAkClB;IAED;;;;;;;;;;;;OAYG;IACH,wBAJW,UAAU,UACV,MAAM,GACJ,IAAI,CAOhB;IAED;;;;;;;;;;;;;;;;OAgBG;IACH;QAJ2B,iBAAiB,EAAjC,MAAM;QACU,gBAAgB,EAAhC,MAAM;QACJ,IAAI,CAahB;IAED;;OAEG;IACH,gCAEC;IAED;;OAEG;IACH,+BAEC;IAED;;;;;OAKG;IACH,aAFa,IAAI,CAKhB;IAED;;;;;;;;OAQG;IACH,WAFa,IAAI,CAOhB;;CACJ;qCArnBY,OAAO,6BAA6B,EAAE,sBAAsB;0BAC5D,OAAO,kBAAkB,EAAE,WAAW;yBACtC,OAAO,iEAAiE,EAAE,UAAU"}
+{"version":3,"file":"GPUVirtualGeometryRuntime.d.ts","sourceRoot":"","sources":["../../../../../../../src/shade/renderer/geometry/virtual/runtime/GPUVirtualGeometryRuntime.js"],"names":[],"mappings":"AAoBA;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AACH;IAmHI;;;;;;;;;;;;;;;OAeG;IACH;QAd2C,IAAI,EAApC,sBAAsB;QACL,aAAa,GAA9B,MAAM;QACW,qBAAqB,GAAtC,MAAM;QAEW,mBAAmB,GAApC,MAAM;QAEW,cAAc,GAA/B,MAAM;QACW,cAAc,GAA/B,MAAM;QAEW,qBAAqB,GAAtC,MAAM;QACW,aAAa,GAA9B,MAAM;OAgFhB;IA3KD;;;;OAIG;IACH,KAFU,MAAM,CAER;IAER;;OAEG;IACH,cAFU,OAAO,CAEG;IAmKpB;;OAEG;IACH,yEAEC;IAED;;;;OAIG;IACH,4BAEC;IAED;;OAEG;IACH,6BAEC;IAED;;OAEG;IACH,kCAEC;IAED;;;;;OAKG;IACH,6BAEC;IAED;;;;OAIG;IACH,gCAEC;IAWD;;;;;;OAMG;IACH,iCAKC;IArBD;;;;OAIG;IACH,4BAEC;IAgBD;;;;OAIG;IACH,0BAEC;IAED;;;;OAIG;IACH,yDAEC;IAED;;;;;OAKG;IACH,2BAEC;IAED;;OAEG;IACH;;;;;;;;MAEC;IAED;;;;;;;;;;;;;;;;;;;;;;;;;OAyBG;IACH;QAHgC,IAAI,EAAzB,WAAW;QACT,IAAI,CAqChB;IAwBD;;;;;;;;;;OAUG;IACH,cAHW,WAAW,GACT,MAAM,CA0BlB;IAED;;;;;;OAMG;IACH,mBAHW,MAAM,GACJ,MAAM,CAIlB;IAED;;;;;OAKG;IACH,eAFa,WAAW,EAAE,EAAE,CAI3B;IAED;;;;;;;;;OASG;IACH,mBAHW,UAAU,GACR,MAAM,CAkClB;IAED;;;;;;;;;;;;OAYG;IACH,wBAJW,UAAU,UACV,MAAM,GACJ,IAAI,CAOhB;IAED;;;;;;;;;;;;;;;;OAgBG;IACH;QAJ2B,iBAAiB,EAAjC,MAAM;QACU,gBAAgB,EAAhC,MAAM;QACJ,IAAI,CAgBhB;IAED;;OAEG;IACH,gCAEC;IAED;;OAEG;IACH,+BAEC;IAED;;;;;OAKG;IACH,aAFa,IAAI,CAKhB;IAED;;;;;;;;OAQG;IACH,WAFa,IAAI,CAOhB;;CACJ;qCA3nBY,OAAO,6BAA6B,EAAE,sBAAsB;0BAC5D,OAAO,kBAAkB,EAAE,WAAW;yBACtC,OAAO,iEAAiE,EAAE,UAAU"}

package/src/shade/renderer/geometry/virtual/runtime/GPUVirtualGeometryRuntime.js

@@ -150,6 +150,8 @@ export class GPUVirtualGeometryRuntime {
      */
     #instance_capacity = 0;
 
+    #collections_declared = false;
+
     /**
      * @type {number}
      */
@@ -414,6 +416,7 @@ export class GPUVirtualGeometryRuntime {
          that runs against it appends nothing rather than appending past the end of a collection
          whose real size it was never told.
          */
+        this.#collections_declared = false;
         this.#instance_capacity = 0;
         this.#meshlet_capacity = 0;
     }
@@ -583,13 +586,16 @@ export class GPUVirtualGeometryRuntime {
         assert.isNonNegativeInteger(instance_capacity, 'instance_capacity');
         assert.isNonNegativeInteger(meshlet_capacity, 'meshlet_capacity');
 
-        this.#instance_capacity = this.#instance_capacity === 0
-            ? instance_capacity
-            : Math.min(this.#instance_capacity, instance_capacity);
+        if (!this.#collections_declared) {
+            this.#instance_capacity = instance_capacity;
+            this.#meshlet_capacity = meshlet_capacity;
+            this.#collections_declared = true;
+
+            return;
+        }
 
-        this.#meshlet_capacity = this.#meshlet_capacity === 0
-            ? meshlet_capacity
-            : Math.min(this.#meshlet_capacity, meshlet_capacity);
+        this.#instance_capacity = Math.min(this.#instance_capacity, instance_capacity);
+        this.#meshlet_capacity = Math.min(this.#meshlet_capacity, meshlet_capacity);
     }
 
     /**

package/src/shade/renderer/geometry/virtual/runtime/VGeoPageFetcher.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"VGeoPageFetcher.d.ts","sourceRoot":"","sources":["../../../../../../../src/shade/renderer/geometry/virtual/runtime/VGeoPageFetcher.js"],"names":[],"mappings":"AAIA;;;GAGG;AAEH;;;;;;;;;;;;;;;;GAgBG;AACH;IAgFI;;;;;;OAMG;IACH;QAL4B,YAAY,GAA7B,MAAM;QACuB,WAAW,SAA5B,MAAM;OAS5B;IAED;;OAEG;IACH,2BAEC;IAED;;;OAGG;IACH,iCAEC;IAED;;;OAGG;IACH,qCAEC;IAED;;OAEG;IACH,4BAEC;IAED;;;OAGG;IACH,gCAEC;IAED;;;;;;;OAOG;IACH,cAPW,mBAAmB,cACnB,MAAM,gBACN,MAAM,cACN,MAAM,WACN,WAAW,GACT,QAAQ,QAAQ,CAAC,CAqB7B;IAED;;;;;;OAMG;IACH,eAHW,mBAAmB,GACjB,MAAM,CAkClB;IAED;;;;;OAKG;IACH,WAFa,IAAI,CAsBhB;;CAgOJ;kCAzdY,OAAO,uCAAuC,EAAE,mBAAmB;uBACnE,OAAO,4BAA4B,EAAE,QAAQ"}
+{"version":3,"file":"VGeoPageFetcher.d.ts","sourceRoot":"","sources":["../../../../../../../src/shade/renderer/geometry/virtual/runtime/VGeoPageFetcher.js"],"names":[],"mappings":"AAIA;;;GAGG;AAEH;;;;;;;;;;;;;;;;GAgBG;AACH;IAgFI;;;;;;OAMG;IACH;QAL4B,YAAY,GAA7B,MAAM;QACuB,WAAW,SAA5B,MAAM;OAS5B;IAED;;OAEG;IACH,2BAEC;IAED;;;OAGG;IACH,iCAEC;IAED;;;OAGG;IACH,qCAEC;IAED;;OAEG;IACH,4BAEC;IAED;;;OAGG;IACH,gCAEC;IAED;;;;;;;OAOG;IACH,cAPW,mBAAmB,cACnB,MAAM,gBACN,MAAM,cACN,MAAM,WACN,WAAW,GACT,QAAQ,QAAQ,CAAC,CA4B7B;IAED;;;;;;OAMG;IACH,eAHW,mBAAmB,GACjB,MAAM,CAkClB;IAED;;;;;OAKG;IACH,WAFa,IAAI,CAsBhB;;CAgOJ;kCAheY,OAAO,uCAAuC,EAAE,mBAAmB;uBACnE,OAAO,4BAA4B,EAAE,QAAQ"}

package/src/shade/renderer/geometry/virtual/runtime/VGeoPageFetcher.js

@@ -174,6 +174,13 @@ export class VGeoPageFetcher {
             );
         }
 
+        if (signal?.aborted) {
+            return Promise.reject(new VGeoFetchError(
+                `page ${page_index}: the fetch was cancelled`, false,
+                String(signal.reason?.message ?? signal.reason)
+            ));
+        }
+
         if (this.#worker_count > 0 && !this.#no_workers && reader.source.descriptor !== undefined) {
             const worker = this.#worker_for();
 

package/src/shade/renderer/geometry/virtual/runtime/VGeoRuntimeTables.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"VGeoRuntimeTables.d.ts","sourceRoot":"","sources":["../../../../../../../src/shade/renderer/geometry/virtual/runtime/VGeoRuntimeTables.js"],"names":[],"mappings":"AAmBA;;GAEG;AAEH;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2DG;AACH;IAmKI;;;;;;;;OAQG;IACH;QAP4B,aAAa,GAA9B,MAAM;QACW,SAAS,GAA1B,MAAM;QAEW,UAAU,GAA3B,MAAM;QACW,YAAY,GAA7B,MAAM;QACW,iBAAiB,GAAlC,MAAM;OA6BhB;IAED;;OAEG;IACH,gCAEC;IAED;;OAEG;IACH,+BAEC;IAED;;OAEG;IACH,kCAEC;IAED;;OAEG;IACH,gCAEC;IAED;;OAEG;IACH,yBAEC;IAED;;OAEG;IACH,4BAEC;IAED;;;OAGG;IACH,kCAEC;IAED;;OAEG;IACH,kCAEC;IAED;;;OAGG;IACH,iCAEC;IAED;;;;;;OAMG;IACH,wBAHW,MAAM,GACJ,MAAM,CAIlB;IAED;;;;;;;;;;;OAWG;IACH,8BALW,MAAM,qBACN,MAAM,GACJ,MAAM,CAiDlB;IAED;;;;;;OAMG;IACH,kCAJW,MAAM,GACJ,MAAM,EAAE,CAgDpB;IAED;;;;OAIG;IACH,6BAJW,MAAM,SACN,MAAM,GACJ,MAAM,CAIlB;IAED;;;;OAIG;IACH,0BAJW,MAAM,cACN,MAAM,GACJ,MAAM,CAQlB;IAED;;;;OAIG;IACH,qBAJW,MAAM,SACN,MAAM,GACJ,MAAM,CAIlB;IAED;;;;;OAKG;IACH,oBAHW,MAAM,GACJ,MAAM,CAIlB;IAED;;;OAGG;IACH,qBAHW,MAAM,GACJ,MAAM,CAKlB;IAED;;;OAGG;IACH,uBAHW,MAAM,GACJ,MAAM,CAKlB;IAED;;;;;;;;OAQG;IACH,sBAHW,MAAM,GACJ,MAAM,CAKlB;IAED;;;;;;;;;;;;;;;;;OAiBG;IACH,sBARW,MAAM,QACN,QAAQ,gBACR,MAAM,GACJ,MAAM,CAkFlB;IAED;;;;;OAKG;IACH,qBAHW,QAAQ,GACN,MAAM,CAOlB;IAED;;;;;;;;;;;;;;OAcG;IACH,gBAHW,MAAM,GACJ,OAAO,CAuCnB;IAED;;;;;;OAMG;IACH,uBAHW,MAAM,GACJ,IAAI,MAAM,CAAC,CAIvB;IAED;;;;;;;;;;OAUG;IACH,4BAHW,MAAM,GACJ,MAAM,CAIlB;IAED;;;;OAIG;IACH,uBAFa,MAAM,EAAE,CAQpB;IAwWD;;;;;;;;;;;;OAYG;IACH,+BALW,MAAM,SACN,MAAM,cACN,OAAO,GACL,IAAI,CAUhB;IAED;;;;OAIG;IACH,8BAJW,MAAM,SACN,MAAM,GACJ,OAAO,CAQnB;IAED;;;;;OAKG;IACH,qBAHW,MAAM,GACJ,MAAM,EAAE,CAapB;IAED;;;;;OAKG;IACH,sBAHW,MAAM,GACJ,MAAM,EAAE,CAOpB;IAED;;;;;;OAMG;IACH,2BAJW,MAAM,gBACN,MAAM,GACJ,OAAO,CAYnB;;CA4DJ;uBAjtCY,OAAO,4BAA4B,EAAE,QAAQ"}
+{"version":3,"file":"VGeoRuntimeTables.d.ts","sourceRoot":"","sources":["../../../../../../../src/shade/renderer/geometry/virtual/runtime/VGeoRuntimeTables.js"],"names":[],"mappings":"AAmBA;;GAEG;AAEH;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2DG;AACH;IAmKI;;;;;;;;OAQG;IACH;QAP4B,aAAa,GAA9B,MAAM;QACW,SAAS,GAA1B,MAAM;QAEW,UAAU,GAA3B,MAAM;QACW,YAAY,GAA7B,MAAM;QACW,iBAAiB,GAAlC,MAAM;OA6BhB;IAED;;OAEG;IACH,gCAEC;IAED;;OAEG;IACH,+BAEC;IAED;;OAEG;IACH,kCAEC;IAED;;OAEG;IACH,gCAEC;IAED;;OAEG;IACH,yBAEC;IAED;;OAEG;IACH,4BAEC;IAED;;;OAGG;IACH,kCAEC;IAED;;OAEG;IACH,kCAEC;IAED;;;OAGG;IACH,iCAEC;IAED;;;;;;OAMG;IACH,wBAHW,MAAM,GACJ,MAAM,CAIlB;IAED;;;;;;;;;;;OAWG;IACH,8BALW,MAAM,qBACN,MAAM,GACJ,MAAM,CAmDlB;IAED;;;;;;OAMG;IACH,kCAJW,MAAM,GACJ,MAAM,EAAE,CAgDpB;IAED;;;;OAIG;IACH,6BAJW,MAAM,SACN,MAAM,GACJ,MAAM,CAIlB;IAED;;;;OAIG;IACH,0BAJW,MAAM,cACN,MAAM,GACJ,MAAM,CAQlB;IAED;;;;OAIG;IACH,qBAJW,MAAM,SACN,MAAM,GACJ,MAAM,CAIlB;IAED;;;;;OAKG;IACH,oBAHW,MAAM,GACJ,MAAM,CAIlB;IAED;;;OAGG;IACH,qBAHW,MAAM,GACJ,MAAM,CAKlB;IAED;;;OAGG;IACH,uBAHW,MAAM,GACJ,MAAM,CAKlB;IAED;;;;;;;;OAQG;IACH,sBAHW,MAAM,GACJ,MAAM,CAKlB;IAED;;;;;;;;;;;;;;;;;OAiBG;IACH,sBARW,MAAM,QACN,QAAQ,gBACR,MAAM,GACJ,MAAM,CAkFlB;IAED;;;;;OAKG;IACH,qBAHW,QAAQ,GACN,MAAM,CAOlB;IAED;;;;;;;;;;;;;;OAcG;IACH,gBAHW,MAAM,GACJ,OAAO,CAuCnB;IAED;;;;;;OAMG;IACH,uBAHW,MAAM,GACJ,IAAI,MAAM,CAAC,CAIvB;IAED;;;;;;;;;;OAUG;IACH,4BAHW,MAAM,GACJ,MAAM,CAIlB;IAED;;;;OAIG;IACH,uBAFa,MAAM,EAAE,CAQpB;IAwWD;;;;;;;;;;;;OAYG;IACH,+BALW,MAAM,SACN,MAAM,cACN,OAAO,GACL,IAAI,CAUhB;IAED;;;;OAIG;IACH,8BAJW,MAAM,SACN,MAAM,GACJ,OAAO,CAQnB;IAED;;;;;OAKG;IACH,qBAHW,MAAM,GACJ,MAAM,EAAE,CAapB;IAED;;;;;OAKG;IACH,sBAHW,MAAM,GACJ,MAAM,EAAE,CAOpB;IAED;;;;;;OAMG;IACH,2BAJW,MAAM,gBACN,MAAM,GACJ,OAAO,CAYnB;;CA4DJ;uBAntCY,OAAO,4BAA4B,EAAE,QAAQ"}

package/src/shade/renderer/geometry/virtual/runtime/VGeoRuntimeTables.js

@@ -374,7 +374,7 @@ export class VGeoRuntimeTables {
         assert.isNonNegativeInteger(page_count, 'page_count');
         assert.greaterThan(page_count, 0, 'page_count');
 
-        const recycled = this.#free_geometry_rows.pop();
+        const recycled = this.#free_geometry_rows[this.#free_geometry_rows.length - 1];
 
         const row = recycled ?? this.#geometry_row_high_water;
 
@@ -396,6 +396,8 @@ export class VGeoRuntimeTables {
 
         if (recycled === undefined) {
             this.#geometry_row_high_water = row + 1;
+        } else {
+            this.#free_geometry_rows.pop();
         }
 
         this.#geometry_allocations.set(row, allocation);

package/src/shade/renderer/loader/gltf/tiny-gltf.d.ts

@@ -13,7 +13,7 @@ export class TinyGltf {
      * @readonly
      * @type {TextureFormat}
      */
-    static readonly "__#259@#UNCOMPRESSED_TARGET": TextureFormat;
+    static readonly "__#264@#UNCOMPRESSED_TARGET": TextureFormat;
     /**
      * @param {AssetManager} assetManager
      * @param {AssetRequestScope} [scope]

package/src/shade/renderer/object_property/chunk_write_object_property.d.ts

@@ -12,7 +12,9 @@
  * `weight` is the weight `value` has already been multiplied by. Only the
  * Node3D writer wants it, and only for rotation: a rotation channel missing
  * its `w` curve defaults to the identity's 1, which has to be weighted the
- * same way the authored channels were.
+ * same way the authored channels were. `rest_rotation` is the target's
+ * rest rotation from its binding, and the same goes for it: only a Node3D
+ * rotation reads it.
  *
  * Each writer lives in its own CodeChunk and operates on whatever storage
  * buffers the importing shader has bound under the documented names —

package/src/shade/renderer/object_property/chunk_write_object_property.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"chunk_write_object_property.d.ts","sourceRoot":"","sources":["../../../../../src/shade/renderer/object_property/chunk_write_object_property.js"],"names":[],"mappings":"AASA;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AACH,0CAFU,SAAS,CA2Bb;0BA1DoB,iCAAiC"}
+{"version":3,"file":"chunk_write_object_property.d.ts","sourceRoot":"","sources":["../../../../../src/shade/renderer/object_property/chunk_write_object_property.js"],"names":[],"mappings":"AASA;;;;;;;;;;;;;;;;;;;;;;;;;GAyBG;AACH,0CAFU,SAAS,CA4Bb;0BA7DoB,iCAAiC"}

package/src/shade/renderer/object_property/chunk_write_object_property.js

@@ -21,7 +21,9 @@ import { ObjectType } from "./ObjectType.js";
  * `weight` is the weight `value` has already been multiplied by. Only the
  * Node3D writer wants it, and only for rotation: a rotation channel missing
  * its `w` curve defaults to the identity's 1, which has to be weighted the
- * same way the authored channels were.
+ * same way the authored channels were. `rest_rotation` is the target's
+ * rest rotation from its binding, and the same goes for it: only a Node3D
+ * rotation reads it.
  *
  * Each writer lives in its own CodeChunk and operates on whatever storage
  * buffers the importing shader has bound under the documented names —
@@ -40,12 +42,13 @@ fn write_object_property(
     mask: u32,
     value: vec4f,
     weight: f32,
+    rest_rotation: vec4f,
 ) {
     let object_type = instance >> 24u;
 
     switch(object_type){
         case ${ObjectType.Node3D}u: {
-            write_object_property_node3d(instance, property, mask, value, weight);
+            write_object_property_node3d(instance, property, mask, value, weight, rest_rotation);
         }
         case ${ObjectType.Material}u: {
             write_object_property_material(instance, property, mask, value);

package/src/shade/renderer/object_property/chunk_write_object_property_node3d.d.ts

@@ -35,6 +35,10 @@
  * channel has to carry the same weight as the channels that were
  * authored; nothing else here does.
  *
+ * `rest_rotation` is the target's rest rotation, from its binding. Only
+ * Rotation reads it: it rides into the slot with the contribution, for
+ * the resolve to write when the rotations summed to nothing.
+ *
  * @type {CodeChunk}
  */
 export const chunk_write_object_property_node3d: CodeChunk;

package/src/shade/renderer/object_property/chunk_write_object_property_node3d.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"chunk_write_object_property_node3d.d.ts","sourceRoot":"","sources":["../../../../../src/shade/renderer/object_property/chunk_write_object_property_node3d.js"],"names":[],"mappings":"AAIA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAsCG;AACH,iDAFU,SAAS,CA6Bb;0BArEoB,iCAAiC"}
+{"version":3,"file":"chunk_write_object_property_node3d.d.ts","sourceRoot":"","sources":["../../../../../src/shade/renderer/object_property/chunk_write_object_property_node3d.js"],"names":[],"mappings":"AAIA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA0CG;AACH,iDAFU,SAAS,CA8Bb;0BA1EoB,iCAAiC"}

package/src/shade/renderer/object_property/chunk_write_object_property_node3d.js

@@ -39,6 +39,10 @@ import { Node3DProperty } from "./Node3DProperty.js";
  * channel has to carry the same weight as the channels that were
  * authored; nothing else here does.
  *
+ * `rest_rotation` is the target's rest rotation, from its binding. Only
+ * Rotation reads it: it rides into the slot with the contribution, for
+ * the resolve to write when the rotations summed to nothing.
+ *
  * @type {CodeChunk}
  */
 export const chunk_write_object_property_node3d = CodeChunk.from(
@@ -50,6 +54,7 @@ fn write_object_property_node3d(
     mask: u32,
     value: vec4f,
     weight: f32,
+    rest_rotation: vec4f,
 ) {
     let node_index = instance & 0x00FFFFFFu;
 
@@ -58,7 +63,7 @@ fn write_object_property_node3d(
             pose_accumulator_add_translation(node_index, value.xyz, mask);
         }
         case ${Node3DProperty.Rotation}u: {
-            pose_accumulator_add_rotation(node_index, value, mask, weight);
+            pose_accumulator_add_rotation(node_index, value, mask, weight, rest_rotation);
         }
         case ${Node3DProperty.Scale}u: {
             pose_accumulator_add_scale(node_index, value.xyz, mask);

package/src/shade/renderer/postprocess/nss/NSS.d.ts

@@ -53,7 +53,7 @@ export class NSS {
      * @returns {number}
      */
     static recommended_jitter_sequence_size(upscale_ratio: number): number;
-    static "__#190@#preprocess_tensor_descriptor"(render_w: any, render_h: any): TextureResourceDescriptor;
+    static "__#192@#preprocess_tensor_descriptor"(render_w: any, render_h: any): TextureResourceDescriptor;
     /**
      * @param {GraphicsContext} graphics
      */

package/src/shade/renderer/scene/SCENE_DATABASE_SPEC.js

@@ -24,8 +24,9 @@ export const SCENE_DATABASE_SPEC = GPUDatabaseDefinition.from({
 
 SCENE_DATABASE_SPEC.add_link({ table: 'water_bodies', field: 'node', target_database: SCENE_DATABASE_SPEC,
     target_table: 'transforms', nullable: false, owning: false });
+// Every body has its surface row: any body can carry wave particles, and its bounds are read every frame.
 SCENE_DATABASE_SPEC.add_link({ table: 'water_bodies', field: 'wave', target_database: SCENE_DATABASE_SPEC,
-    target_table: 'water_waves', nullable: true, owning: true });
+    target_table: 'water_waves', nullable: false, owning: true });
 SCENE_DATABASE_SPEC.add_link({ table: 'water_waves', field: 'node', target_database: SCENE_DATABASE_SPEC,
     target_table: 'transforms', nullable: false, owning: false });
 

package/src/shade/renderer/scene/optimization/geometry/geometry_deduplicate.d.ts

@@ -37,7 +37,7 @@ export type GeometryDeduplicateOptions = {
      */
     position_epsilon?: number;
     /**
-     * Max occurrences kept per rolling-hash bucket
+     * Max triangles kept per neighbourhood hash
      */
     seed_budget?: number;
 };

package/src/shade/renderer/scene/optimization/geometry/geometry_deduplicate.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"geometry_deduplicate.d.ts","sourceRoot":"","sources":["../../../../../../../src/shade/renderer/scene/optimization/geometry/geometry_deduplicate.js"],"names":[],"mappings":"AA6CA;;;;;;;;;;GAUG;AACH,qGAHW,0BAA0B,GACxB,cAAc,CAAC,WAAW,WAAW,EAAE,CAAC,CAqNpD;;;;;gBA8Ea,MAAM;gBACN,MAAM;gBACN,MAAM;;;;YACN,MAAM;;;gBA1UN,UAAU;;;;qBACV,MAAM;;;;;;;;uBACN,MAAM;;;;kBAKN,MAAM;;4BArBQ,oDAAoD"}
+{"version":3,"file":"geometry_deduplicate.d.ts","sourceRoot":"","sources":["../../../../../../../src/shade/renderer/scene/optimization/geometry/geometry_deduplicate.js"],"names":[],"mappings":"AAyDA;;;;;;;;;;GAUG;AACH,qGAHW,0BAA0B,GACxB,cAAc,CAAC,WAAW,WAAW,EAAE,CAAC,CA4LpD;;;;;gBAoJa,MAAM;gBACN,MAAM;gBACN,MAAM;;;;YACN,MAAM;;;gBAlYN,UAAU;;;;qBACV,MAAM;;;;;;;;uBACN,MAAM;;;;kBAKN,MAAM;;4BAtBQ,oDAAoD"}