@woosh/meep-engine 2.34.33 → 2.34.37

package/core/bvh2/LeafNode.js

@@ -14,98 +14,97 @@ function isLeaf(node) {
     return node.isLeafNode;
 }
 
-/**
- *
- * @param {*} object
- * @param {number} x0
- * @param {number} y0
- * @param {number} z0
- * @param {number} x1
- * @param {number} y1
- * @param {number} z1
- * @constructor
- */
-function LeafNode(object, x0, y0, z0, x1, y1, z1) {
-    this.object = object;
-    this.parentNode = null;
-
-
-    this.x0 = x0;
-    this.y0 = y0;
-    this.z0 = z0;
-    this.x1 = x1;
-    this.y1 = y1;
-    this.z1 = z1;
-}
+export class LeafNode extends Node {
+    /**
+     *
+     * @param {*} object
+     * @param {number} x0
+     * @param {number} y0
+     * @param {number} z0
+     * @param {number} x1
+     * @param {number} y1
+     * @param {number} z1
+     * @constructor
+     */
+    constructor(object, x0, y0, z0, x1, y1, z1) {
+        super();
+
+        this.object = object;
+        this.parentNode = null;
+
+        this.x0 = x0;
+        this.y0 = y0;
+        this.z0 = z0;
+        this.x1 = x1;
+        this.y1 = y1;
+        this.z1 = z1;
+
+        /**
+         *
+         * @type {boolean}
+         */
+        this.isLeafNode = true;
+        /**
+         * Useful shortcut, to avoid having to distinguish between leaf and intermediate nodes
+         * @readonly
+         * @type {number}
+         */
+        this.leafNodeCount = 1;
+    }
 
-LeafNode.prototype = Object.create(Node.prototype);
+    /**
+     *
+     * @param {number} dx
+     * @param {number} dy
+     * @param {number} dz
+     */
+    move(dx, dy, dz) {
+        this.x0 += dx;
+        this.x1 += dx;
+        this.y0 += dy;
+        this.y1 += dy;
+        this.z0 += dz;
+        this.z1 += dz;
+        if (this.parentNode !== null) {
+            this.parentNode.bubbleRefit();
+        }
+    }
 
-/**
- *
- * @type {boolean}
- */
-LeafNode.prototype.isLeafNode = true;
+    /**
+     *
+     * @param {number} x0
+     * @param {number} y0
+     * @param {number} z0
+     * @param {number} x1
+     * @param {number} y1
+     * @param {number} z1
+     */
+    resize(x0, y0, z0, x1, y1, z1) {
+        this.setBounds(x0, y0, z0, x1, y1, z1);
+
+        this.bubbleRefit();
+    }
 
-/**
- * Useful shortcut, to avoid having to distinguish between leaf and intermediate nodes
- * @readonly
- * @type {number}
- */
-LeafNode.prototype.leafNodeCount = 1;
+    bubbleRefit() {
 
-/**
- *
- * @param {number} dx
- * @param {number} dy
- * @param {number} dz
- */
-LeafNode.prototype.move = function (dx, dy, dz) {
-    this.x0 += dx;
-    this.x1 += dx;
-    this.y0 += dy;
-    this.y1 += dy;
-    this.z0 += dz;
-    this.z1 += dz;
-    if (this.parentNode !== null) {
-        this.parentNode.bubbleRefit();
+        if (this.parentNode !== null) {
+            this.parentNode.bubbleRefit();
+        }
     }
-};
-
-/**
- *
- * @param {number} x0
- * @param {number} y0
- * @param {number} z0
- * @param {number} x1
- * @param {number} y1
- * @param {number} z1
- */
-LeafNode.prototype.resize = function (x0, y0, z0, x1, y1, z1) {
-    this.setBounds(x0, y0, z0, x1, y1, z1);
 
-    this.bubbleRefit();
-};
+    /**
+     *
+     * @return {LeafNode}
+     */
+    clone() {
+        const clone = new LeafNode(this.object, this.x0, this.y0, this.z0, this.x1, this.y1, this.z1);
 
-LeafNode.prototype.bubbleRefit = function (){
+        clone.parentNode = this.parentNode;
 
-    if (this.parentNode !== null) {
-        this.parentNode.bubbleRefit();
+        return clone;
     }
 }
 
-/**
- *
- * @return {LeafNode}
- */
-LeafNode.prototype.clone = function () {
-    const clone = new LeafNode(this.object, this.x0, this.y0, this.z0, this.x1, this.y1, this.z1);
-
-    clone.parentNode = this.parentNode;
-
-    return clone;
-};
-
-
 /**
  *
  * @param {BinaryBuffer} buffer
@@ -130,7 +129,6 @@ function deserializeLeafNode(buffer, node, valueDeserializer) {
 
 export {
     isLeaf,
-    LeafNode,
     serializeLeafNode,
     deserializeLeafNode
 };

package/core/bvh2/Node.d.ts

@@ -3,4 +3,7 @@ import {BinaryNode} from "./BinaryNode";
 
 export class Node<T> extends AABB3 {
     public parentNode: BinaryNode<T>
+
+
+    readonly leafNodeCount: number
 }

package/core/bvh2/Node.js

@@ -5,144 +5,142 @@ import computeMortonCode from "../geom/3d/morton/Morton.js";
 import { AABB3 } from "./aabb3/AABB3.js";
 
 
-/**
- * @extends {AABB3}
- * @constructor
- */
-function Node() {
+export class Node extends AABB3 {
+    constructor() {
+        super();
+
+        /**
+         *
+         * @type {BinaryNode|null}
+         */
+        this.parentNode = null;
+        this._mortonCode = void 0;
+    }
+
     /**
-     *
-     * @type {BinaryNode|null}
+     * @return {boolean}
      */
-    this.parentNode = null;
-    this._mortonCode = void 0;
-}
-
-Node.prototype = Object.create(AABB3.prototype);
+    validateAncestorChain() {
+        //check containment
+        const parent = this.parentNode;
+        if (parent === null) {
+            //nothing to do
+            return true;
+        }
 
-/**
- * @return {boolean}
- */
-Node.prototype.validateAncestorChain = function () {
-    //check containment
-    const parent = this.parentNode;
-    if (parent === null) {
-        //nothing to do
-        return true;
-    }
+        if (!parent.containsBox(this)) {
+            //bounds violated
+            return false;
+        }
 
-    if (!parent.containsBox(this)) {
-        //bounds violated
-        return false;
-    }
+        if (parent.left === this || parent.right === this) {
+            //all is well
+        } else {
+            return false;
+        }
 
-    if (parent.left === this || parent.right === this) {
-        //all is well
-    } else {
-        return false;
+        return true;
     }
 
-    return true;
-};
+    /**
+     *
+     * @returns {number}
+     */
+    computeDepth() {
+        let d = 0;
+        let node = this.parentNode;
 
-/**
- *
- * @returns {number}
- */
-Node.prototype.computeDepth = function () {
-    let d = 0;
-    let node = this.parentNode;
+        while (node !== null) {
+            node = node.parentNode;
 
-    while (node !== null) {
-        node = node.parentNode;
+            d++;
+        }
 
-        d++;
+        return d;
     }
 
-    return d;
-};
+    /**
+     *
+     * @returns {Node}
+     */
+    computeRoot() {
+        let p = this;
 
-/**
- *
- * @returns {Node}
- */
-Node.prototype.computeRoot = function () {
-    let p = this;
+        while (p.parentNode !== null) {
+            p = p.parentNode;
+        }
 
-    while (p.parentNode !== null) {
-        p = p.parentNode;
+        return p;
     }
 
-    return p;
-};
-
-Node.prototype.getMortonCode = function () {
-    if (this._mortonCode === void 0) {
-        const hx = (this.x1 + this.x0) / 2;
-        const hy = (this.y1 + this.y0) / 2;
-        const hz = (this.z1 + this.z0) / 2;
-        const mortonCode = computeMortonCode(hx, hy, hz);
-        this._mortonCode = mortonCode;
-        return mortonCode;
-    } else {
-        return this._mortonCode;
+    getMortonCode() {
+        if (this._mortonCode === void 0) {
+            const hx = (this.x1 + this.x0) / 2;
+            const hy = (this.y1 + this.y0) / 2;
+            const hz = (this.z1 + this.z0) / 2;
+            const mortonCode = computeMortonCode(hx, hy, hz);
+            this._mortonCode = mortonCode;
+            return mortonCode;
+        } else {
+            return this._mortonCode;
+        }
     }
-};
 
-/**
- * Expands current node and all ancestors until root to accommodate for given box, terminate if node is already
- * large enough
- * @param {AABB3} box
- */
-Node.prototype.bubbleExpandToFit = function (box) {
-    let node = this;
-    while (node.expandToFit(box)) {
-        node = node.parentNode;
-        if (node === null) {
-            break;
+    /**
+     * Expands current node and all ancestors until root to accommodate for given box, terminate if node is already
+     * large enough
+     * @param {AABB3} box
+     */
+    bubbleExpandToFit(box) {
+        let node = this;
+        while (node.expandToFit(box)) {
+            node = node.parentNode;
+            if (node === null) {
+                break;
+            }
         }
     }
-};
 
-/**
- * @deprecated
- */
-Node.prototype.remove = function () {
-    console.error("This method is deprecated, use 'disconnect' instead.");
-    this.disconnect();
-};
+    /**
+     * @deprecated
+     */
+    remove() {
+        console.error("This method is deprecated, use 'disconnect' instead.");
+        this.disconnect();
+    }
 
-/**
- * Detaches this node from its parent
- */
-Node.prototype.disconnect = function () {
-    const node = this.parentNode;
+    /**
+     * Detaches this node from its parent
+     */
+    disconnect() {
+        const node = this.parentNode;
 
-    if (node === null) {
-        //no parent already
-        // console.warn(`Node has no parent, nothing to disconnect from`);
-        return;
-    }
+        if (node === null) {
+            //no parent already
+            // console.warn(`Node has no parent, nothing to disconnect from`);
+            return;
+        }
 
-    if (this === node.left) {
-        node.left = null;
-        this.parentNode = null;
-    } else if (this === node.right) {
-        node.right = null;
-        this.parentNode = null;
-    } else {
-        throw new Error("impostor child");
-    }
+        if (this === node.left) {
+            node.left = null;
+            this.parentNode = null;
+        } else if (this === node.right) {
+            node.right = null;
+            this.parentNode = null;
+        } else {
+            throw new Error("impostor child");
+        }
 
-    node.updateLeafNodeCount();
-};
+        node.updateLeafNodeCount();
+    }
 
-/**
- * traverses all siblings up to the root
- */
-Node.prototype.traverseSiblingsUp = function () {
-    throw new Error('Not Implemented');
-};
+    /**
+     * traverses all siblings up to the root
+     */
+    traverseSiblingsUp() {
+        throw new Error('Not Implemented');
+    }
+}
 
 function buildPathForNode(n) {
 
@@ -185,7 +183,7 @@ function strinfityPath(path) {
  * @param {int} len maximum number of path elements
  * @returns {string}
  */
-function buildShortStringPath(n, len) {
+export function buildShortStringPath(n, len) {
     const longPath = buildPathForNode(n);
 
     if (longPath.length > len) {
@@ -195,4 +193,3 @@ function buildShortStringPath(n, len) {
     }
 }
 
-export { Node, buildShortStringPath };

package/core/bvh2/aabb3/AABB3.js

@@ -6,9 +6,10 @@
 import { aabb3_computeDistanceAbovePlane } from "../../geom/3d/aabb/aabb3_computeDistanceAbovePlane.js";
 import { computeAABB3PlaneSide } from "../../geom/3d/aabb/computeAABB3PlaneSide.js";
 import computeMortonCode from "../../geom/3d/morton/Morton.js";
-import { _boxSurfaceArea2, intersectRay, intersectSegment } from "./AABB3Math.js";
+import { boxSurfaceArea, intersectRay, intersectSegment } from "./AABB3Math.js";
 import { aabb3_build_corners } from "../../geom/3d/aabb/aabb3_build_corners.js";
 import { assert } from "../../assert.js";
+import { aabb3_intersects_frustum_degree } from "./aabb3_intersects_frustum_degree.js";
 
 
 /**
@@ -81,7 +82,7 @@ AABB3.prototype.computeMortonCode = function () {
  * @returns {number}
  */
 AABB3.prototype.computeSurfaceArea = function () {
-    return _boxSurfaceArea2(this.x0, this.y0, this.z0, this.x1, this.y1, this.z1);
+    return boxSurfaceArea(this.x0, this.y0, this.z0, this.x1, this.y1, this.z1);
 };
 
 /**
@@ -296,7 +297,8 @@ AABB3.prototype.costForInclusion = function (other) {
 };
 
 /**
- *
+ * Surface area delta when including a given AABB
+ * 0 means that including a given AABB would not cause any change to total surface area
  * @param {number} x0
  * @param {number} y0
  * @param {number} z0
@@ -834,7 +836,7 @@ AABB3.prototype.intersectFrustumDegree = function (frustum) {
 
     let i = 0;
     let result = 2;
-    for (i = 0; i < 6; i++) {
+    for (; i < 6; i++) {
 
         const plane = planes[i];
 
@@ -848,6 +850,16 @@ AABB3.prototype.intersectFrustumDegree = function (frustum) {
     }
     return result;
 };
+/**
+ *
+ * @param {number[]} frustum
+ * @returns {number}
+ */
+AABB3.prototype.intersectFrustumDegree_array = function (frustum) {
+    return aabb3_intersects_frustum_degree(
+        this.x0, this.y0, this.z0, this.x1, this.y1, this.z1, frustum
+    );
+};
 
 /**
  *
@@ -866,6 +878,40 @@ AABB3.prototype.intersectFrustum = function intersectFrustum(frustum) {
     return true;
 };
 
+/**
+ *
+ * @param {ArrayLike<number>|number[]|Float32Array}frustum
+ * @returns {boolean}
+ */
+AABB3.prototype.intersectFrustum_array = function intersectFrustum(frustum) {
+    const x0 = this.x0;
+    const y0 = this.y0;
+    const z0 = this.z0;
+    const x1 = this.x1;
+    const y1 = this.y1;
+    const z1 = this.z1;
+
+    for (let i = 0; i < 24; i += 4) {
+
+        const p_nx = frustum[i];
+        const p_ny = frustum[i + 1];
+        const p_nz = frustum[i + 2];
+        const p_c = frustum[i + 3];
+
+        if (aabb3_computeDistanceAbovePlane(
+            p_nx, p_ny, p_nz, p_c,
+            x0, y0, z0,
+            x1, y1, z1
+        ) < 0) {
+            // below plane, i.e. outside of the frustum
+            return false;
+        }
+
+    }
+    return true;
+};
+
+
 /**
  *
  * @param {number} v

package/core/bvh2/aabb3/AABB3.spec.js

@@ -1,5 +1,11 @@
 import { BinaryBuffer } from "../../binary/BinaryBuffer.js";
-import { AABB3, deserializeAABB3, deserializeAABB3Quantized16Uint, serializeAABB3, serializeAABB3Quantized16Uint } from "./AABB3.js";
+import {
+    AABB3,
+    deserializeAABB3,
+    deserializeAABB3Quantized16Uint,
+    serializeAABB3,
+    serializeAABB3Quantized16Uint
+} from "./AABB3.js";
 
 
 function compareBounds(expected, actual, numDigits = 10) {
@@ -182,3 +188,23 @@ test('isBelowPlane negative space and orthogonal planes', () => {
     expect(a._isBelowPlane(0, 0, -1, -4)).toBeTruthy();
 });
 
+test('readFrom/writeTo Array consistency', () => {
+    const s = new AABB3(
+        1, 2, 3, 4, 5, 6
+    );
+
+    const a = [];
+
+    s.writeToArray(a, 0);
+
+    expect(a).toEqual([1, 2, 3, 4, 5, 6]);
+
+    s.readFromArray(a, 0);
+
+    expect(s.x0).toEqual(1);
+    expect(s.y0).toEqual(2);
+    expect(s.z0).toEqual(3);
+    expect(s.x1).toEqual(4);
+    expect(s.y1).toEqual(5);
+    expect(s.z1).toEqual(6);
+});

package/core/bvh2/aabb3/AABB3Math.js

@@ -540,7 +540,7 @@ function boxSurfaceArea(x0, y0, z0, x1, y1, z1) {
     const dx = x1 - x0;
     const dy = y1 - y0;
     const dz = z1 - z0;
-    return (dx * dy + dy * dz + dz * dx) * 2; //2 of each side
+    return (dy * (dx + dz) + dz * dx) * 2; //2 of each side
 }
 
 /**

package/core/bvh2/aabb3/aabb3_from_v3_array.js

@@ -0,0 +1,34 @@
+import { min2 } from "../../math/min2.js";
+import { max2 } from "../../math/max2.js";
+
+/**
+ *
+ * @param {AABB3} result
+ * @param {number[]|ArrayLike<number>} input
+ * @param {number} input_length
+ */
+export function aabb3_from_v3_array(result, input, input_length) {
+    let x0 = Infinity;
+    let y0 = Infinity;
+    let z0 = Infinity;
+
+    let x1 = -Infinity;
+    let y1 = -Infinity;
+    let z1 = -Infinity;
+
+    for (let i = 0; i < input_length; i += 3) {
+        const x = input[i];
+        const y = input[i + 1];
+        const z = input[i + 2];
+
+        x0 = min2(x, x0);
+        y0 = min2(y, y0);
+        z0 = min2(z, z0);
+
+        x1 = max2(x, x1);
+        y1 = max2(y, y1);
+        z1 = max2(z, z1);
+    }
+
+    result.setBounds(x0, y0, z0, x1, y1, z1);
+}

package/core/bvh2/aabb3/aabb3_from_v3_array_transformed.js

@@ -0,0 +1,39 @@
+import { min2 } from "../../math/min2.js";
+import { max2 } from "../../math/max2.js";
+
+/**
+ *
+ * @param {AABB3} result
+ * @param {number[]|ArrayLike<number>} input
+ * @param {number} input_length
+ * @param {ArrayLike<number>|number[]|Float32Array} e 4x4 transformation matrix
+ */
+export function aabb3_from_v3_array_transformed(result, input, input_length, e) {
+    let x0 = Infinity;
+    let y0 = Infinity;
+    let z0 = Infinity;
+
+    let x1 = -Infinity;
+    let y1 = -Infinity;
+    let z1 = -Infinity;
+
+    for (let i = 0; i < input_length; i += 3) {
+        const x = input[i];
+        const y = input[i + 1];
+        const z = input[i + 2];
+
+        const _x = e[0] * x + e[4] * y + e[8] * z + e[12];
+        const _y = e[1] * x + e[5] * y + e[9] * z + e[13];
+        const _z = e[2] * x + e[6] * y + e[10] * z + e[14];
+
+        x0 = min2(_x, x0);
+        y0 = min2(_y, y0);
+        z0 = min2(_z, z0);
+
+        x1 = max2(_x, x1);
+        y1 = max2(_y, y1);
+        z1 = max2(_z, z1);
+    }
+
+    result.setBounds(x0, y0, z0, x1, y1, z1);
+}