@woosh/meep-engine 2.168.1 → 2.169.0

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/collection/list/List.d.ts

@@ -151,6 +151,14 @@ declare class List<T> {
      * @return {T[]}
      */
     slice(start?: number, end?: number): T[];
+    /**
+     * Whether every element satisfies the condition. Vacuously true when empty,
+     * matching Array.prototype.every.
+     *
+     * @param {function(element:T):boolean} condition
+     * @returns {boolean}
+     */
+    every(condition: any): boolean;
     /**
      *
      * @param {function(element:T):boolean} condition
@@ -330,5 +338,12 @@ declare class List<T> {
      * @returns {number}
      */
     compare(other: List<T>): number;
+    /**
+     * Iterate the list's elements, so `for...of` and spread work on it the way
+     * they already do on HashMap, HashSet and Deque.
+     *
+     * @returns {Iterator<T>}
+     */
+    [Symbol.iterator](): Iterator<T>;
 }
 //# sourceMappingURL=List.d.ts.map

package/src/core/collection/list/List.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"List.d.ts","sourceRoot":"","sources":["../../../../../src/core/collection/list/List.js"],"names":[],"mappings":"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"}
+{"version":3,"file":"List.d.ts","sourceRoot":"","sources":["../../../../../src/core/collection/list/List.js"],"names":[],"mappings":"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"}