@woosh/meep-engine 2.34.35 → 2.34.36

package/core/binary/BitSet.js

@@ -533,6 +533,11 @@ BitSet.prototype.shift = function (distance, start_index, end_index) {
  * Sets all of the bits in this BitSet to false.
  */
 BitSet.prototype.reset = function () {
+    if (this.__length <= 0) {
+        // no action required
+        return;
+    }
+
     this.__data_uint32.fill(0, 0, Math.ceil(this.__length / 32));
     this.__length = 0;
 };

package/core/bvh2/BinaryNode.js

@@ -672,37 +672,37 @@ BinaryNode.prototype.computeSAH = function () {
 };
 
 BinaryNode.prototype.updateLeafNodeCount = function () {
-    let n = 0;
+    let node = this;
 
-    const right = this.right;
+    while (node !== null) {
+        let n = 0;
 
-    if (right !== null) {
-        if (right.isLeafNode) {
-            n++;
-        } else {
-            n += right.leafNodeCount;
+        const right = node.right;
+
+        if (right !== null) {
+            if (right.isLeafNode) {
+                n++;
+            } else {
+                n += right.leafNodeCount;
+            }
         }
-    }
 
-    const left = this.left;
+        const left = this.left;
 
-    if (left !== null) {
-        if (left.isLeafNode) {
-            n++;
-        } else {
-            n += left.leafNodeCount;
+        if (left !== null) {
+            if (left.isLeafNode) {
+                n++;
+            } else {
+                n += left.leafNodeCount;
+            }
         }
-    }
-
-    this.leafNodeCount = n;
 
-    // propagate update up the tree
-    let parentNode = this.parentNode;
+        node.leafNodeCount = n;
 
-    if (parentNode !== null) {
-        // bubble up
-        parentNode.updateLeafNodeCount();
+        // propagate update up the tree
+        node = node.parentNode;
     }
+
 }
 
 
@@ -1150,19 +1150,18 @@ BinaryNode.prototype.computeBalanceFactor = function () {
 };
 
 /**
- *
+ * @template T
  * @param {number} x0
  * @param {number} y0
  * @param {number} z0
  * @param {number} x1
  * @param {number} y1
  * @param {number} z1
- * @param {*} value
+ * @param {T} value
  * @returns {LeafNode}
  */
 BinaryNode.prototype.insert = function (x0, y0, z0, x1, y1, z1, value) {
-    const leaf = new LeafNode(value);
-    leaf.setBounds(x0, y0, z0, x1, y1, z1);
+    const leaf = new LeafNode(value, x0, y0, z0, x1, y1, z1);
     this.insertNode(leaf);
     return leaf;
 };
@@ -1196,7 +1195,6 @@ function transplantNewCommonParent(node, child) {
     return bNode;
 }
 
-
 /**
  *
  * @param {Node|BinaryNode|LeafNode} child
@@ -1251,55 +1249,6 @@ BinaryNode.prototype.insertNode = function (child) {
     }
 }
 
-/**
- * @deprecated
- * @param {Node|BinaryNode|LeafNode} child
- */
-BinaryNode.prototype.insertNode_old = function (child) {
-    assert.notNull(child, "child");
-    assert.defined(child, "child");
-    assert.isInstanceOf(child, Node, 'child', "Node");
-    assert.equal(child.parentNode, null, "parentNode must be null, otherwise Node still belongs to another tree");
-
-    const node = this.findParentFor(child);
-
-    let bNode;
-
-    if (
-        node.isBinaryNode &&
-        !(node.isProtected() && node !== this) // protected node, can't insert into this subtree
-    ) {
-
-        if (node.left === null) {
-            node.left = child;
-            child.parentNode = node;
-            node.bubbleExpandToFit(child);
-
-        } else if (node.right === null) {
-
-            node.right = child;
-            child.parentNode = node;
-            node.bubbleExpandToFit(child);
-
-        } else {
-            //take right child and insert another binary node there
-            bNode = new BinaryNode();
-            bNode.setChildren(node.right, child);
-            //
-            node.right = bNode;
-            bNode.parentNode = node;
-            node.bubbleExpandToFit(bNode);
-        }
-
-        node.updateLeafNodeCount();
-    } else {
-        //need to do transplanting and introduce a new common parent
-        transplantNewCommonParent(node, child);
-
-    }
-
-};
-
 /**
  * @param {boolean} deep
  * @returns {BinaryNode}

package/core/bvh2/aabb3/AABB3.js

@@ -9,6 +9,7 @@ import computeMortonCode from "../../geom/3d/morton/Morton.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";
 
 
 /**
@@ -835,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];
 
@@ -849,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
+    );
+};
 
 /**
  *
@@ -867,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_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);
+}

package/core/bvh2/aabb3/aabb3_intersects_frustum_degree.js

@@ -0,0 +1,46 @@
+//
+
+import { computeAABB3PlaneSide } from "../../geom/3d/aabb/computeAABB3PlaneSide.js";
+
+/**
+ *
+ * @param {number} x0
+ * @param {number} y0
+ * @param {number} z0
+ * @param {number} x1
+ * @param {number} y1
+ * @param {number} z1
+ * @param {number[]} frustum
+ * @return {number}
+ */
+export function aabb3_intersects_frustum_degree(
+    x0, y0, z0,
+    x1, y1, z1,
+    frustum
+) {
+
+    let i = 0;
+    let result = 2;
+
+    for (; 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];
+
+        const plane_side = computeAABB3PlaneSide(
+            p_nx, p_ny, p_nz, p_c,
+            x0, y0, z0, x1, y1, z1
+        );
+
+        if (plane_side < 0) {
+            // completely outside
+            return 0;
+        } else if (plane_side === 0) {
+            result = 1;
+        }
+    }
+
+    return result;
+}

package/core/bvh2/traversal/ThreeFrustumsIntersectionBVHVisitor.js

@@ -6,13 +6,11 @@ export class ThreeFrustumsIntersectionBVHVisitor extends BVHVisitor {
         super();
 
         /**
-         * Collection of THREE.js Frustums
+         * [plane_x, plane_y, plane_z, constant] collection, defining a frustum
          * @private
-         * @type {Frustum[]}
+         * @type {ArrayLike<number>|number[]}
          */
-        this.frustums = [];
-
-        this.frustumCount = 0;
+        this.frustum = [];
 
         /**
          *
@@ -23,49 +21,32 @@ export class ThreeFrustumsIntersectionBVHVisitor extends BVHVisitor {
 
     /**
      *
-     * @param {Frustum[]} frustums
+     * @param {ArrayLike<number>|number[]|Float32Array} frustum
      */
-    setFrustums(frustums) {
-        this.frustums = frustums;
-        this.frustumCount = frustums.length;
+    setFrustum(frustum) {
+        this.frustum = frustum;
     }
 
     visitLeaf(node) {
 
-        const n = this.frustumCount;
-
-        for (let i = 0; i < n; i++) {
+        const degree = node.intersectFrustumDegree_array(this.frustum);
 
-            const degree = node.intersectFrustumDegree(this.frustums[i]);
-
-            if (degree !== 0) {
-                this.collector.visitLeaf(node);
-                return;
-            }
+        if (degree !== 0) {
+            // at least partially visible
+            this.collector.visitLeaf(node);
         }
-
     }
 
     visitBinary(node) {
-        let flag = false;
-
-        const n = this.frustumCount;
-
-        for (let i = 0; i < n; i++) {
-
-            const degree = node.intersectFrustumDegree(this.frustums[i]);
 
-            if (degree === 2) {
-                //completely inside
-                traverseBinaryNodeUsingVisitor(node, this.collector);
-                return false;
-            } else if (degree === 1) {
-                //partially inside, continue traversal
-                flag = true;
-            }
+        const degree = node.intersectFrustumDegree_array(this.frustum);
 
+        if (degree === 2) {
+            //completely inside, do fast traversal
+            traverseBinaryNodeUsingVisitor(node, this.collector);
+            return false;
         }
 
-        return flag;
+        return degree === 1;
     }
 }

package/core/bvh2/traversal/queryBinaryNode_FrustumIntersections.js

@@ -0,0 +1,52 @@
+/**
+ *
+ * @type {(BinaryNode|LeafNode)[]}
+ */
+const stack = [];
+
+
+/**
+ * @template T
+ * @param {T[]} destination
+ * @param {number} destinationOffset
+ * @param {BinaryNode<T>} root
+ * @param {ArrayLike<number>|number[]|Float32Array} frustum
+ * @returns {number} Number of results
+ */
+export function queryBinaryNode_FrustumIntersections_Data(destination, destinationOffset, root, frustum) {
+    let n;
+    let i = 0;
+    let stackPointer = 1;
+
+    stack[0] = root;
+
+    while (stackPointer > 0) {
+        stackPointer--;
+
+        n = stack[stackPointer];
+
+        if (!n.intersectFrustum_array(frustum)) {
+            continue;
+        }
+
+        if (n.isBinaryNode) {
+
+            if (n.right !== null) {
+                stack[stackPointer++] = n.right;
+            }
+
+            if (n.left !== null) {
+                stack[stackPointer++] = n.left;
+            }
+
+        } else {
+
+            destination[destinationOffset + i] = n.object;
+
+            i++;
+        }
+
+    }
+
+    return i;
+}

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

@@ -1,8 +1,7 @@
-
 /**
  * NOTE: Based on Transforming Axis-Aligned Bounding Boxes by Jim Arvo from "Graphics Gems", Academic Press, 1990
- * @param {number[]} result
- * @param {number[]} aabb
+ * @param {ArrayLike<number>|number[]|Float32Array} result
+ * @param {ArrayLike<number>|number[]|Float32Array} aabb
  * @param {number[]} matrix 4x4 matrix
  */
 export function aabb3_matrix4_project(result, aabb, matrix) {

package/core/geom/Quaternion.d.ts

@@ -22,4 +22,6 @@ export default class Quaternion {
     threeSetRotationMatrix(result: Matrix4): void
 
     setFromRotationMatrix(m: Matrix4): void
+
+    decodeFromUint32(uint: number): void
 }

package/engine/ecs/attachment/TransformAttachmentBinding.js

@@ -8,7 +8,6 @@ const scratch_m4_2 = new Float32Array(16);
 export class TransformAttachmentBinding extends AttachmentBinding {
     constructor() {
         super();
-
     }
 
     /**

package/engine/ecs/foliage/FoliageVisibilitySetBuilder.js

@@ -5,28 +5,13 @@ export class FoliageVisibilitySetBuilder extends BVHVisitor {
     constructor() {
         super();
 
-        /**
-         * Visibility filters
-         * @type {(function(LeafNode):boolean)[]}
-         */
-        this.filters = [];
-
         /**
          *
          * @type {BitSet}
          */
         this.visibleSet = new BitSet();
         //prevent re-allocation
-        this.visibleSet.__shrinkFactor = 0;
-    }
-
-    /**
-     *
-     * @param {(function(LeafNode):boolean)[]} filters
-     */
-    setFilters(filters) {
-        this.filters = filters;
-        this.filterCount = filters.length;
+        this.visibleSet.preventShrink();
     }
 
     initialize() {
@@ -34,21 +19,6 @@ export class FoliageVisibilitySetBuilder extends BVHVisitor {
     }
 
     visitLeaf(node) {
-
-        const n = this.filterCount;
-
-        const filters = this.filters;
-
-        for (let i = 0; i < n; i++) {
-            const visibilityFilter = filters[i];
-
-            if (!visibilityFilter(node)) {
-                //not visible
-                return;
-            }
-
-        }
-
         const index = node.object;
 
         //TODO check screen space size to decide if element should be seen or not