@woosh/meep-engine 2.34.36 → 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.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.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/geom/3d/aabb/aabb3_matrix4_project.js

@@ -14,7 +14,7 @@ export function aabb3_matrix4_project(result, aabb, matrix) {
     for (let i = 0; i < 3; i++) {
         for (let j = 0; j < 3; j++) {
 
-            const m_a = i * 4 + j;
+            const m_a = i + j * 4;
             const m_v = matrix[m_a];
 
             const a = m_v * aabb[j];

package/core/geom/3d/aabb/aabb3_matrix4_project.spec.js

@@ -1,4 +1,7 @@
 import { aabb3_matrix4_project } from "./aabb3_matrix4_project.js";
+import { compose_matrix4_array } from "../../../../engine/graphics/util/composeMatrix4.js";
+import Vector3 from "../../Vector3.js";
+import Quaternion from "../../Quaternion.js";
 
 test('identity', () => {
     const r = [];
@@ -39,3 +42,13 @@ test('scale case', () => {
 
     expect(r).toEqual([-5, 4, -27, -1, 14, -9]);
 });
+
+test('translation + scale case', () => {
+    const m4 = [];
+    compose_matrix4_array(m4, new Vector3(-1, 2, -3), Quaternion.identity, new Vector3(7, -11, 13));
+
+    const r = [];
+    aabb3_matrix4_project(r, [1, 2, 3, 5, 7, 9], m4);
+
+    expect(r).toEqual([6, -75, 36, 34, -20, 114]);
+});

package/core/geom/3d/triangle/computeTriangleRayIntersection.js

@@ -95,9 +95,8 @@ export function computeTriangleRayIntersection(
     // Line intersects triangle, check if ray does.
     const QdN = -sign * v3_dot(diff_x, diff_y, diff_z, normal_x, normal_y, normal_z);
 
-    // t < 0, no intersection
     if (QdN < 0) {
-
+        // t < 0, no intersection
         return false;
 
     }

package/core/geom/Vector3.js

@@ -523,21 +523,25 @@ class Vector3 {
     /**
      *
      * @param {THREE.Matrix4} matrix4
-     * @returns {Vector3}
      */
     applyMatrix4_three(matrix4) {
+        this.applyMatrix4(matrix4.elements);
+    }
 
+    /**
+     *
+     * @param {ArrayList<number>|number[]|Float32Array} m4
+     */
+    applyMatrix4(m4) {
         const x = this.x;
         const y = this.y;
         const z = this.z;
 
-        const e = matrix4.elements;
-
-        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];
+        const _x = m4[0] * x + m4[4] * y + m4[8] * z + m4[12];
+        const _y = m4[1] * x + m4[5] * y + m4[9] * z + m4[13];
+        const _z = m4[2] * x + m4[6] * y + m4[10] * z + m4[14];
 
-        return this.set(_x, _y, _z);
+        this.set(_x, _y, _z);
     }
 
     /**
@@ -589,11 +593,18 @@ class Vector3 {
      * @param {THREE.Matrix4} matrix4
      */
     threejs_setFromMatrixPosition(matrix4) {
-        const e = matrix4.elements;
+        this.setFromMatrixPosition(matrix4.elements);
+    }
+
+    /**
+     *
+     * @param {ArrayLike<number>|number[]|Float32Array} matrix4 4x4 transform matrix
+     */
+    setFromMatrixPosition(matrix4) {
 
-        const _x = e[12];
-        const _y = e[13];
-        const _z = e[14];
+        const _x = matrix4[12];
+        const _y = matrix4[13];
+        const _z = matrix4[14];
 
         this.set(_x, _y, _z);
     }

package/engine/ecs/foliage/InstancedFoliage.js

@@ -314,8 +314,12 @@ export class InstancedFoliage {
 
         state.__view = view;
 
-        state.instances.setGeometry(this.geometry);
-        state.instances.setMaterial(this.__material);
+        if (this.geometry !== null) {
+            state.instances.setGeometry(this.geometry);
+        }
+        if (this.__material !== null) {
+            state.instances.setMaterial(this.__material);
+        }
 
         state.instances.mesh.castShadow = this.castShadow;
         state.instances.mesh.receiveShadow = this.receiveShadow;

package/engine/ecs/foliage/ecs/Foliage2System.js

@@ -26,13 +26,8 @@ function cleanupLayer(layerData, renderLayer) {
 export function loadFoliageLayer(layer, assetManager) {
     const instancedFoliage = layer.data;
 
-    /**
-     * @type {THREE.Mesh}
-     */
-    const threeMesh = instancedFoliage.instances.mesh;
-
-    threeMesh.castShadow = layer.castShadow.getValue();
-    threeMesh.receiveShadow = layer.receiveShadow.getValue();
+    instancedFoliage.castShadow = layer.castShadow.getValue();
+    instancedFoliage.receiveShadow = layer.receiveShadow.getValue();
 
     const modelURL = layer.modelURL.getValue();
 

package/engine/graphics/GraphicsEngine.js

@@ -538,7 +538,7 @@ function classifyPassTypeFromObject(object) {
          * @type {THREE.Material}
          */
         const material = object.material;
-        if (material.transparent) {
+        if (material.depthWrite === false && material.depthTest === false) {
             return RenderPassType.Transparent;
         }
     }