@woosh/meep-engine 2.168.1 → 2.169.1

package/src/core/bvh8/build/NodeProxy.js

@@ -1,308 +1,314 @@
-import { array_remove_first } from "../../collection/array/array_remove_first.js";
-import { aabb3_array_combine } from "../../geom/3d/aabb/aabb3_array_combine.js";
-import { aabb3_compute_surface_area } from "../../geom/3d/aabb/aabb3_compute_surface_area.js";
-import { v3_distance_sqr } from "../../geom/vec3/v3_distance_sqr.js";
-import { BVH8_MAX_LEAF_TRIANGLE_OFFSET } from "../BVH8.js";
-import { aabb3_from_triangle_by_index } from "./aabb3_from_triangle_by_index.js";
-import { TriangleCluster } from "./TriangleCluster.js";
-
-export class NodeProxy {
-
-    /**
-     *
-     * @type {TriangleCluster[]}
-     */
-    primitives = []
-
-    primitive_index_low = 0xFFFFFFFF;
-    primitive_index_high = 0;
-
-    /**
-     *
-     * @type {NodeProxy[]}
-     */
-    children = []
-
-    bounds = new Float32Array([
-        Infinity, Infinity, Infinity,
-        -Infinity, -Infinity, -Infinity
-    ])
-
-    height = 0
-
-    computeHeight() {
-        const children = this.children;
-        const child_count = children.length;
-
-        let height = 0;
-        for (let i = 0; i < child_count; i++) {
-            const child = children[i];
-
-            if (child.height >= height) {
-                height = child.height + 1;
-            }
-        }
-
-        this.height = height;
-    }
-
-    primitive_count = 0;
-
-    /**
-     *
-     * @param {NodeProxy} other
-     * @returns {number}
-     */
-    computeCentroidSqrDistanceTo(other) {
-        const ax = (this.bounds[0] + this.bounds[3]) * 0.5;
-        const ay = (this.bounds[1] + this.bounds[4]) * 0.5;
-        const az = (this.bounds[2] + this.bounds[5]) * 0.5;
-
-        const bx = (other.bounds[0] + other.bounds[3]) * 0.5;
-        const by = (other.bounds[1] + other.bounds[4]) * 0.5;
-        const bz = (other.bounds[2] + other.bounds[5]) * 0.5;
-
-        return v3_distance_sqr(ax, ay, az, bx, by, bz);
-    }
-
-    computePrimitiveBounds(index_array, position_array) {
-        const clusters = this.primitives;
-        const cluster_count = clusters.length;
-        for (let i = 0; i < cluster_count; i++) {
-            clusters[i].computeBounds(index_array, position_array);
-        }
-    }
-
-    /**
-     * A node has 8 slots that can be used for either triangle clusters or children
-     * @returns {number}
-     */
-    get used_slot_count() {
-        return this.primitives.length + this.children.length;
-    }
-
-    recomputePrimitiveSpan() {
-        this.primitive_index_low = 0xFFFFFFFF;
-        this.primitive_index_high = 0;
-
-        for (let i = 0; i < this.primitives.length; i++) {
-            const cluster = this.primitives[i];
-
-            for (let j = 0; j < cluster.triangles.length; j++) {
-                const triangle = cluster.triangles[j];
-
-                this.primitive_index_low = Math.min(triangle, this.primitive_index_low);
-                this.primitive_index_high = Math.max(triangle, this.primitive_index_high);
-            }
-        }
-    }
-
-    /**
-     *
-     * @param {number} index
-     * @param {number[]|Float32Array} bounds
-     * @returns {boolean} true if added, false otherwise
-     */
-    tryAddPrimitive(index, bounds) {
-        const min = Math.min(index, this.primitive_index_low);
-        const max = Math.max(index, this.primitive_index_high);
-
-        if ((max - min) > BVH8_MAX_LEAF_TRIANGLE_OFFSET) {
-            // a leaf meta stores the offset of its first triangle relative to the node's
-            // lowest triangle index; offsets above the cap collide with the internal slot encoding
-            return false;
-        }
-
-        const clusters = this.primitives;
-        const cluster_count = clusters.length;
-
-
-        for (let i = 0; i < cluster_count; i++) {
-            const candidate = clusters[i];
-
-
-            if (candidate.canAccept(index, bounds)) {
-                candidate.add(index, bounds);
-
-                this.primitive_index_low = min;
-                this.primitive_index_high = max;
-
-                return true;
-            }
-        }
-
-        // no candidate found, see if we can create one
-        if (this.used_slot_count === 8) {
-            // at capacity
-            return false;
-        }
-
-        const cluster = new TriangleCluster();
-        cluster.add(index, bounds);
-
-        let insert_position;
-        for (insert_position = 0; insert_position < cluster_count; insert_position++) {
-            // find where to insert new cluster, keeping clusters sorted by first triangle
-            const candidate = clusters[insert_position];
-            if (candidate.triangles[0] > index) {
-                break;
-            }
-        }
-
-        clusters.splice(insert_position, 0, cluster);
-
-        this.primitive_index_low = min;
-        this.primitive_index_high = max;
-
-        return true;
-    }
-
-    addChild(node) {
-        this.children.push(node);
-        this.height = Math.max(this.height, node.height + 1);
-
-        aabb3_array_combine(this.bounds, 0, this.bounds, 0, node.bounds, 0);
-
-        this.primitive_count += node.primitive_count;
-    }
-
-    /**
-     * Attempt to pull up data from children and in process reduce number of nodes below
-     */
-    optimize_pull_up(index_array, position_array) {
-        const children = this.children;
-        for (let i = children.length - 1; i >= 0; i--) {
-            const child = children[i];
-
-            const optimized = this.tryAbsorbChild(child, index_array, position_array);
-
-            if (optimized && child.children.length > 0) {
-                // pull up and try again
-                child.optimize_pull_up(index_array, position_array);
-                i++;
-            }
-        }
-    }
-
-    /**
-     *
-     * @param {NodeProxy} child
-     * @param {number[]} index_array
-     * @param {number[]} position_array
-     * @return {boolean}
-     */
-    tryAbsorbChild(child, index_array, position_array) {
-        const child_clusters = child.primitives;
-        let child_cluster_count = child_clusters.length;
-
-        let absorbed_count = 0;
-
-        for (let i = 0; i < child_cluster_count; i++) {
-            const cluster = child_clusters[i];
-
-            const triangles = cluster.triangles;
-            let cluster_size = triangles.length;
-
-            let retry_middle = false;
-
-            for (let j = 0; j < cluster_size; j++) {
-                const triangle = triangles[j];
-
-                if (j > 0 && j < cluster_size - 1) {
-                    // triangle in the middle, can't remove
-                    // triangles are indexed sequentially, gaps are not valid
-                    retry_middle = true;
-                    continue;
-                }
-
-                const bounds = [];
-                aabb3_from_triangle_by_index(bounds, 0, triangle, index_array, position_array);
-
-                if (this.tryAddPrimitive(triangle, bounds)) {
-                    triangles.splice(j, 1);
-
-                    child.primitive_count--;
-
-                    absorbed_count++;
-
-                    j--;
-                    cluster_size--;
-
-                    if (retry_middle) {
-                        j--;
-                    }
-                }
-            }
-
-            if (cluster_size === 0) {
-                child_clusters.splice(i, 1);
-
-                i--;
-                child_cluster_count--;
-
-            }
-        }
-
-        if (absorbed_count <= 0) {
-            // nothing absorbed, we're done
-            return false;
-        }
-
-        child.recomputePrimitiveSpan();
-
-        if (child_cluster_count === 0 && child.children.length === 0) {
-            // dead child
-            array_remove_first(this.children, child);
-
-            if (child.height >= this.height - 1) {
-                // should recompute height
-                this.computeHeight();
-            }
-        }
-
-        return true;
-    }
-
-    /**
-     * Mostly useful for debug
-     * @param {number} index
-     * @returns {undefined|NodeProxy}
-     */
-    findNodeByPrimitive(index) {
-        const clusters = this.primitives;
-        for (let i = 0; i < clusters.length; i++) {
-            if (clusters[i].contains(index)) {
-                return this;
-            }
-        }
-
-        const children = this.children;
-        for (let i = 0; i < children.length; i++) {
-            const found = children[i].findNodeByPrimitive(index);
-
-            if (found !== undefined) {
-                return found;
-            }
-        }
-
-        // not found
-        return undefined;
-    }
-
-    /**
-     * Heuristic score of how good the tree is
-     * Lower = better
-     * @return {number}
-     */
-    area_score() {
-        let result = aabb3_compute_surface_area(...this.bounds);
-
-        for (const child of this.children) {
-            result += child.area_score();
-        }
-
-        return result;
-    }
-}
-
-NodeProxy.prototype.isNodeProxy = true;
+import { array_remove_first } from "../../collection/array/array_remove_first.js";
+import { aabb3_array_combine } from "../../geom/3d/aabb/aabb3_array_combine.js";
+import { aabb3_compute_surface_area } from "../../geom/3d/aabb/aabb3_compute_surface_area.js";
+import { v3_distance_sqr } from "../../geom/vec3/v3_distance_sqr.js";
+import { BVH8_MAX_LEAF_TRIANGLE_OFFSET } from "../BVH8.js";
+import { aabb3_from_triangle_by_index } from "./aabb3_from_triangle_by_index.js";
+import { TriangleCluster } from "./TriangleCluster.js";
+
+export class NodeProxy {
+
+    /**
+     *
+     * @type {TriangleCluster[]}
+     */
+    primitives = []
+
+    primitive_index_low = 0xFFFFFFFF;
+    primitive_index_high = 0;
+
+    /**
+     *
+     * @type {NodeProxy[]}
+     */
+    children = []
+
+    bounds = new Float32Array([
+        Infinity, Infinity, Infinity,
+        -Infinity, -Infinity, -Infinity
+    ])
+
+    height = 0
+
+    computeHeight() {
+        const children = this.children;
+        const child_count = children.length;
+
+        let height = 0;
+        for (let i = 0; i < child_count; i++) {
+            const child = children[i];
+
+            if (child.height >= height) {
+                height = child.height + 1;
+            }
+        }
+
+        this.height = height;
+    }
+
+    primitive_count = 0;
+
+    /**
+     *
+     * @param {NodeProxy} other
+     * @returns {number}
+     */
+    computeCentroidSqrDistanceTo(other) {
+        const ax = (this.bounds[0] + this.bounds[3]) * 0.5;
+        const ay = (this.bounds[1] + this.bounds[4]) * 0.5;
+        const az = (this.bounds[2] + this.bounds[5]) * 0.5;
+
+        const bx = (other.bounds[0] + other.bounds[3]) * 0.5;
+        const by = (other.bounds[1] + other.bounds[4]) * 0.5;
+        const bz = (other.bounds[2] + other.bounds[5]) * 0.5;
+
+        return v3_distance_sqr(ax, ay, az, bx, by, bz);
+    }
+
+    computePrimitiveBounds(index_array, position_array) {
+        const clusters = this.primitives;
+        const cluster_count = clusters.length;
+        for (let i = 0; i < cluster_count; i++) {
+            clusters[i].computeBounds(index_array, position_array);
+        }
+    }
+
+    /**
+     * A node has 8 slots that can be used for either triangle clusters or children
+     * @returns {number}
+     */
+    get used_slot_count() {
+        return this.primitives.length + this.children.length;
+    }
+
+    recomputePrimitiveSpan() {
+        this.primitive_index_low = 0xFFFFFFFF;
+        this.primitive_index_high = 0;
+
+        for (let i = 0; i < this.primitives.length; i++) {
+            const cluster = this.primitives[i];
+
+            for (let j = 0; j < cluster.triangles.length; j++) {
+                const triangle = cluster.triangles[j];
+
+                this.primitive_index_low = Math.min(triangle, this.primitive_index_low);
+                this.primitive_index_high = Math.max(triangle, this.primitive_index_high);
+            }
+        }
+    }
+
+    /**
+     *
+     * @param {number} index
+     * @param {number[]|Float32Array} bounds
+     * @returns {boolean} true if added, false otherwise
+     */
+    tryAddPrimitive(index, bounds) {
+        const min = Math.min(index, this.primitive_index_low);
+        const max = Math.max(index, this.primitive_index_high);
+
+        if ((max - min) > BVH8_MAX_LEAF_TRIANGLE_OFFSET) {
+            // a leaf meta stores the offset of its first triangle relative to the node's
+            // lowest triangle index; offsets above the cap collide with the internal slot encoding
+            return false;
+        }
+
+        const clusters = this.primitives;
+        const cluster_count = clusters.length;
+
+
+        for (let i = 0; i < cluster_count; i++) {
+            const candidate = clusters[i];
+
+
+            if (candidate.canAccept(index, bounds)) {
+                candidate.add(index, bounds);
+
+                this.primitive_index_low = min;
+                this.primitive_index_high = max;
+
+                return true;
+            }
+        }
+
+        // no candidate found, see if we can create one
+        if (this.used_slot_count === 8) {
+            // at capacity
+            return false;
+        }
+
+        const cluster = new TriangleCluster();
+        cluster.add(index, bounds);
+
+        let insert_position;
+        for (insert_position = 0; insert_position < cluster_count; insert_position++) {
+            // find where to insert new cluster, keeping clusters sorted by first triangle
+            const candidate = clusters[insert_position];
+            if (candidate.triangles[0] > index) {
+                break;
+            }
+        }
+
+        clusters.splice(insert_position, 0, cluster);
+
+        this.primitive_index_low = min;
+        this.primitive_index_high = max;
+
+        return true;
+    }
+
+    addChild(node) {
+        this.children.push(node);
+        this.height = Math.max(this.height, node.height + 1);
+
+        aabb3_array_combine(this.bounds, 0, this.bounds, 0, node.bounds, 0);
+
+        this.primitive_count += node.primitive_count;
+    }
+
+    /**
+     * Attempt to pull up data from children and in process reduce number of nodes below
+     */
+    optimize_pull_up(index_array, position_array) {
+        const children = this.children;
+        for (let i = children.length - 1; i >= 0; i--) {
+            const child = children[i];
+
+            const optimized = this.tryAbsorbChild(child, index_array, position_array);
+
+            if (optimized && child.children.length > 0) {
+                // pull up and try again
+                child.optimize_pull_up(index_array, position_array);
+                i++;
+            }
+        }
+    }
+
+    /**
+     *
+     * @param {NodeProxy} child
+     * @param {number[]} index_array
+     * @param {number[]} position_array
+     * @return {boolean}
+     */
+    tryAbsorbChild(child, index_array, position_array) {
+        const child_clusters = child.primitives;
+        let child_cluster_count = child_clusters.length;
+
+        let absorbed_count = 0;
+
+        for (let i = 0; i < child_cluster_count; i++) {
+            const cluster = child_clusters[i];
+
+            const triangles = cluster.triangles;
+            let cluster_size = triangles.length;
+
+            let retry_middle = false;
+
+            for (let j = 0; j < cluster_size; j++) {
+                const triangle = triangles[j];
+
+                if (j > 0 && j < cluster_size - 1) {
+                    // triangle in the middle, can't remove
+                    // triangles are indexed sequentially, gaps are not valid
+                    retry_middle = true;
+                    continue;
+                }
+
+                const bounds = [];
+                aabb3_from_triangle_by_index(bounds, 0, triangle, index_array, position_array);
+
+                if (this.tryAddPrimitive(triangle, bounds)) {
+                    triangles.splice(j, 1);
+
+                    child.primitive_count--;
+
+                    absorbed_count++;
+
+                    j--;
+                    cluster_size--;
+
+                    // step back one further so a triangle previously skipped as
+                    // "middle" is reconsidered now that the cluster has shrunk.
+                    // Guarded: without it the index can reach -2, the loop's
+                    // increment then hands the body -1, and triangles[-1] is
+                    // undefined -- which gets absorbed as if it were a real
+                    // primitive and drives leaves past the offset ceiling.
+                    if (retry_middle && j >= 0) {
+                        j--;
+                    }
+                }
+            }
+
+            if (cluster_size === 0) {
+                child_clusters.splice(i, 1);
+
+                i--;
+                child_cluster_count--;
+
+            }
+        }
+
+        if (absorbed_count <= 0) {
+            // nothing absorbed, we're done
+            return false;
+        }
+
+        child.recomputePrimitiveSpan();
+
+        if (child_cluster_count === 0 && child.children.length === 0) {
+            // dead child
+            array_remove_first(this.children, child);
+
+            if (child.height >= this.height - 1) {
+                // should recompute height
+                this.computeHeight();
+            }
+        }
+
+        return true;
+    }
+
+    /**
+     * Mostly useful for debug
+     * @param {number} index
+     * @returns {undefined|NodeProxy}
+     */
+    findNodeByPrimitive(index) {
+        const clusters = this.primitives;
+        for (let i = 0; i < clusters.length; i++) {
+            if (clusters[i].contains(index)) {
+                return this;
+            }
+        }
+
+        const children = this.children;
+        for (let i = 0; i < children.length; i++) {
+            const found = children[i].findNodeByPrimitive(index);
+
+            if (found !== undefined) {
+                return found;
+            }
+        }
+
+        // not found
+        return undefined;
+    }
+
+    /**
+     * Heuristic score of how good the tree is
+     * Lower = better
+     * @return {number}
+     */
+    area_score() {
+        let result = aabb3_compute_surface_area(...this.bounds);
+
+        for (const child of this.children) {
+            result += child.area_score();
+        }
+
+        return result;
+    }
+}
+
+NodeProxy.prototype.isNodeProxy = true;

package/src/core/cache/Cache.d.ts

@@ -23,8 +23,8 @@ export class Cache<Key, Value> {
      * Note: setting {@link maxWeight} to 0 is pointless, as the cache will not be able to hold even a single element.
      *
      * @param {number} [maxWeight=Number.POSITIVE_INFINITY] capacity of the cache, measure in "weight"; The weight is computed by summing key and value weights.
-     * @param {function(key:Key):number} [keyWeigher= key=>0] function to compute weight of a key
-     * @param {function(value:Value):number} [valueWeigher= value=>1] function to compute weight of a value
+     * @param {(key: Key) => number} [keyWeigher= key=>0] function to compute weight of a key
+     * @param {(value: Value) => number} [valueWeigher= value=>1] function to compute weight of a value
      * @param {function(Key):number} [keyHashFunction]
      * @param {function(Key, Key):boolean} [keyEqualityFunction]
      * @param {number} [capacity] initial capacity for the cache, helps prevent early resizing
@@ -200,11 +200,11 @@ export class Cache<Key, Value> {
     drop(): void;
     /**
      *
-     * @param {function(message:string, key:Key, value:Value)} callback
+     * @param {(message: string, key: Key, value: Value) => void} callback
      * @param {*} [thisArg]
      * @returns {boolean}
      */
-    validate(callback: any, thisArg?: any): boolean;
+    validate(callback: (message: string, key: Key, value: Value) => void, thisArg?: any): boolean;
     /**
      * Shortcut for "Map" class spec compliance
      * @readonly

package/src/core/cache/Cache.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"Cache.d.ts","sourceRoot":"","sources":["../../../../src/core/cache/Cache.js"],"names":[],"mappings":"AAUA;;;;;;;;;;;;;;;;;;;GAmBG;AACH;IAgBI;;;;;;;;;;OAUG;IACH,sGARW,MAAM,EA2FhB;IAzDG;;;;OAIG;IACH,mBAA4B;IAE5B;;;;OAIG;IACH,qBAAgC;IAEhC;;;;OAIG;IACH,gBAAmB;IACnB;;;;OAIG;IACH,eAAkB;IAGlB;;;;OAIG;IACH,aAIE;IAEF;;;;OAIG;IACH,eAA6B;IAE7B;;;OAGG;IACH,eAA6B;IAE7B;;;OAGG;IACH,WAAyB;IAG7B;;;;;OAKG;IACH,kBAqBC;IAED;;;OAGG;IACH,QAFa,MAAM,CAIlB;IAED;;OAEG;IACH,+BAEC;IAED;;;;;OAKG;IACH,qBAEC;IAED;;;OAGG;IACH,2BAeC;IAED,wBAEC;IAED;;;;OAIG;IACH,wBAaC;IAED;;;;;;OAMG;IACH,yBAHW,GAAG,GACD,OAAO,CAgCnB;IAED;;;;;OAKG;IACH,6BAUC;IAED;;;OAGG;IACH,sBAFa,aAAa,GAAG,EAAC,KAAK,CAAC,GAAC,IAAI,CAIxC;IAED;;;OAGG;IACH,YAFa,OAAO,CAkBnB;IAED;;;OAGG;IACH,gCAFW,MAAM,QAWhB;IAED;;;;OAIG;IACH,SAHW,GAAG,SACH,KAAK,QA+Ef;IAED;;;;OAIG;IACH,cAHW,GAAG,GACD,OAAO,CAInB;IAED;;;;OAIG;IACH,SAHW,GAAG,GACD,KAAK,GAAC,IAAI,CAYtB;IAGD;;;;;;OAMG;IACH,kBALW,GAAG,kBACM,GAAG,KAAE,KAAK,0BAElB,KAAK,CAchB;IAED;;;;OAIG;IACH,wBAqBC;IAED;;;;OAIG;IACH,YAHW,GAAG,GACD,OAAO,CAgBnB;IAED;;;;;OAKG;IACH,kBAHW,GAAG,GACD,OAAO,CAanB;IAED;;;;OAIG;IACH,cAcC;IAED;;;OAGG;IACH,aAOC;IAED;;;;;OAKG;IACH,wCAFa,OAAO,CAMnB;IAGL;;;OAGG;IACH,6CAAmB;IAEnB;;;OAGG;IACH,+BA9FiB,OAAO,CA8FF;IAEtB;;;OAGG;IACH,4BAhLiB,OAAO,CAgLL;;CAlBlB;6BApkB4B,mBAAmB"}
+{"version":3,"file":"Cache.d.ts","sourceRoot":"","sources":["../../../../src/core/cache/Cache.js"],"names":[],"mappings":"AAUA;;;;;;;;;;;;;;;;;;;GAmBG;AACH;IAgBI;;;;;;;;;;OAUG;IACH,sGARW,MAAM,EA2FhB;IAzDG;;;;OAIG;IACH,mBAA4B;IAE5B;;;;OAIG;IACH,qBAAgC;IAEhC;;;;OAIG;IACH,gBAAmB;IACnB;;;;OAIG;IACH,eAAkB;IAGlB;;;;OAIG;IACH,aAIE;IAEF;;;;OAIG;IACH,eAA6B;IAE7B;;;OAGG;IACH,eAA6B;IAE7B;;;OAGG;IACH,WAAyB;IAG7B;;;;;OAKG;IACH,kBAqBC;IAED;;;OAGG;IACH,QAFa,MAAM,CAIlB;IAED;;OAEG;IACH,+BAEC;IAED;;;;;OAKG;IACH,qBAEC;IAED;;;OAGG;IACH,2BAeC;IAED,wBAEC;IAED;;;;OAIG;IACH,wBAaC;IAED;;;;;;OAMG;IACH,yBAHW,GAAG,GACD,OAAO,CAgCnB;IAED;;;;;OAKG;IACH,6BAUC;IAED;;;OAGG;IACH,sBAFa,aAAa,GAAG,EAAC,KAAK,CAAC,GAAC,IAAI,CAIxC;IAED;;;OAGG;IACH,YAFa,OAAO,CAkBnB;IAED;;;OAGG;IACH,gCAFW,MAAM,QAWhB;IAED;;;;OAIG;IACH,SAHW,GAAG,SACH,KAAK,QA+Ef;IAED;;;;OAIG;IACH,cAHW,GAAG,GACD,OAAO,CAInB;IAED;;;;OAIG;IACH,SAHW,GAAG,GACD,KAAK,GAAC,IAAI,CAYtB;IAGD;;;;;;OAMG;IACH,kBALW,GAAG,kBACM,GAAG,KAAE,KAAK,0BAElB,KAAK,CAchB;IAED;;;;OAIG;IACH,wBAqBC;IAED;;;;OAIG;IACH,YAHW,GAAG,GACD,OAAO,CAgBnB;IAED;;;;;OAKG;IACH,kBAHW,GAAG,GACD,OAAO,CAanB;IAED;;;;OAIG;IACH,cAcC;IAED;;;OAGG;IACH,aAOC;IAED;;;;;OAKG;IACH,6BAJqB,MAAM,OAAO,GAAG,SAAS,KAAK,KAAK,IAAI,kBAE/C,OAAO,CAMnB;IAGL;;;OAGG;IACH,6CAAmB;IAEnB;;;OAGG;IACH,+BA9FiB,OAAO,CA8FF;IAEtB;;;OAGG;IACH,4BAhLiB,OAAO,CAgLL;;CAlBlB;6BApkB4B,mBAAmB"}