@woosh/meep-engine 2.34.32 → 2.34.36

package/core/bvh2/transform/RotationOptimizer.js

@@ -1,8 +1,7 @@
-import { boxSurfaceArea2 as computeArea, scoreBoxesSAH as computeAreaFor2 } from "../aabb3/AABB3Math.js";
 import { BinaryNode } from "../BinaryNode.js";
 import { isLeaf } from "../LeafNode.js";
-import { surfaceAreaHeuristic as sah } from "../sah/surfaceAreaHeuristic.js";
 import { StacklessTraverser } from "../StacklessTraverser.js";
+import { tryRotateSingleNode } from "./tryRotateSingleNode.js";
 
 
 /**
@@ -73,266 +72,12 @@ function getLeafCount(node, leafCounts) {
     return result;
 }
 
-/**
- *
- * @param {Node} node
- * @param {BinaryNode} parent
- */
-function setParent(node, parent) {
-    node.parentNode = parent;
-}
-
-/**
- * Based on paper "Fast, Effective BVH Updates for Animated Scenes" Kopta et. al. (url: http://www.cs.utah.edu/~thiago/papers/rotations.pdf)
- * @param {BinaryNode} node
- * @param {Map.<NodeDescription,int>} leafCounts
- * @returns {int} value from 0 to 6, 0 means no rotation has taken place
- */
-function tryRotateSingleNode(node, leafCounts) {
-
-
-    const left = node.left;
-    const right = node.right;
-
-    if (left === null || right === null) {
-        return 0;
-    }
-
-    let bestRotation = 0;
-
-
-    const nodeArea = computeArea(node);
-    const leftArea = computeArea(left);
-    const rightArea = computeArea(right);
-
-    const leftLeaves = left.leafNodeCount;
-    const rightLeaves = right.leafNodeCount;
-
-
-    let bestCost = sah(
-        nodeArea,
-        leftArea,
-        rightArea,
-        leftLeaves,
-        rightLeaves
-    );
-
-    let candidateCost;
-
-    let leftLeftArea,
-        leftRightArea,
-        rightLeftArea,
-        rightRightArea;
-
-    let leftLeft,
-        leftRight,
-        rightLeft,
-        rightRight;
-
-    let leftLeftLeaves,
-        leftRightLeaves,
-        rightLeftLeaves,
-        rightRightLeaves;
-
-    let considerLeft = !isLeaf(left);
-
-    if (considerLeft) {
-        leftLeft = left.left;
-        leftRight = left.right;
-
-        considerLeft = (leftLeft !== null && leftRight !== null);
-        if (considerLeft) {
-
-            leftLeftArea = computeArea(leftLeft);
-            leftRightArea = computeArea(leftRight);
-
-            leftLeftLeaves = leftLeft.leafNodeCount;
-            leftRightLeaves = leftRight.leafNodeCount;
-
-            // (1)    N                     N      //
-            //       / \                   / \     //
-            //      L   R     ----->      L   LL   //
-            //     / \                   / \       //
-            //   LL   LR                R   LR     //
-            candidateCost = sah(nodeArea, computeAreaFor2(right, leftRight), leftLeftArea, rightLeaves + leftRightLeaves, leftLeftLeaves);
-
-            if (candidateCost < bestCost) {
-                bestRotation = 1;
-                bestCost = candidateCost;
-            }
-
-            // (2)    N                     N      //
-            //       / \                   / \     //
-            //      L   R     ----->      L   LR   //
-            //     / \                   / \       //
-            //   LL   LR               LL   R      //
-            candidateCost = sah(nodeArea, computeAreaFor2(leftLeft, right), leftRightArea, leftLeftLeaves + rightLeaves, leftRightLeaves);
-
-
-            if (candidateCost < bestCost) {
-                bestRotation = 2;
-                bestCost = candidateCost;
-            }
-        }
-    }
-    if (!isLeaf(right)) {
-        rightLeft = right.left;
-        rightRight = right.right;
-        if (rightLeft !== null && rightRight !== null) {
-
-            rightLeftArea = computeArea(rightLeft);
-            rightRightArea = computeArea(rightRight);
-
-            rightLeftLeaves = rightLeft.leafNodeCount;
-            rightRightLeaves = rightRight.leafNodeCount;
-
-            // (3)    N                     N        //
-            //       / \                   / \       //
-            //      L   R     ----->     RL   R      //
-            //         / \                   / \     //
-            //       RL   RR                L   RR   //
-            candidateCost = sah(nodeArea, rightLeftArea, computeAreaFor2(left, rightRight), rightLeftLeaves, leftLeaves + rightRightLeaves);
-
-            if (candidateCost < bestCost) {
-                bestRotation = 3;
-                bestCost = candidateCost;
-            }
-
-            // (4)    N                     N       //
-            //       / \                   / \      //
-            //      L   R     ----->     RR   R     //
-            //         / \                   / \    //
-            //       RL   RR               RL   L   //
-            candidateCost = sah(nodeArea, rightRightArea, computeAreaFor2(rightLeft, left), rightRightLeaves, rightLeftLeaves + leftLeaves);
-
-
-            if (candidateCost < bestCost) {
-                bestRotation = 4;
-                bestCost = candidateCost;
-            }
-
-            if (considerLeft) {
-                //both child nodes are not leaf
-
-                // (5)       N                      N        //
-                //         /   \                  /   \      //
-                //        L     R     ----->     L     R     //
-                //       / \   / \              / \   / \    //
-                //      LL LR RL RR            LL RL LR RR   //
-                candidateCost = sah(
-                    nodeArea,
-                    computeAreaFor2(leftLeft, rightLeft),
-                    computeAreaFor2(leftRight, rightRight),
-                    leftLeftLeaves + rightLeftLeaves,
-                    leftRightLeaves + rightRightLeaves
-                );
-
-
-                if (candidateCost < bestCost) {
-                    bestRotation = 5;
-                    bestCost = candidateCost;
-                }
-
-                // (6)       N                      N        //
-                //         /   \                  /   \      //
-                //        L     R     ----->     L     R     //
-                //       / \   / \              / \   / \    //
-                //      LL LR RL RR            LL RR RL LR   //
-                candidateCost = sah(
-                    nodeArea,
-                    computeAreaFor2(leftLeft, rightRight),
-                    computeAreaFor2(rightLeft, leftRight),
-                    leftLeftLeaves + rightRightLeaves,
-                    rightLeftLeaves + leftRightLeaves
-                );
-
-                if (candidateCost < bestCost) {
-                    bestRotation = 6;
-                }
-            }
-        }
-    }
-
-    switch (bestRotation) {
-        case 0:
-            //no rotation
-            break;
-        case 1:
-            node.right = leftLeft;
-            setParent(leftLeft, node);
-            left.left = right;
-            setParent(right, left);
-
-            left.refit();
-            //update leaf count
-            node.left.updateLeafNodeCount();
-            break;
-        case 2:
-            node.right = leftRight;
-            setParent(leftRight, node);
-            left.right = right;
-            setParent(right, left);
-
-            left.refit();
-            //update leaf count
-            node.left.updateLeafNodeCount();
-            break;
-        case 3:
-            node.left = rightLeft;
-            setParent(rightLeft, node);
-            right.left = left;
-            setParent(left, right);
-
-            right.refit();
-            //update leaf count
-            node.right.updateLeafNodeCount();
-            break;
-        case 4:
-            node.left = rightRight;
-            setParent(rightRight, node);
-            right.right = left;
-            setParent(left, right);
-
-            right.refit();
-            //update leaf count
-            node.right.updateLeafNodeCount();
-            break;
-        case 5:
-            left.right = rightLeft;
-            setParent(rightLeft, left);
-            right.left = leftRight;
-            setParent(leftRight, right);
-
-            left.refit();
-            right.refit();
-
-            //update leaf count
-            node.left.updateLeafNodeCount();
-            node.right.updateLeafNodeCount();
-            break;
-        case 6:
-            left.right = rightRight;
-            setParent(rightRight, left);
-            right.right = leftRight;
-            setParent(leftRight, right);
-
-            left.refit();
-            right.refit();
-            //update leaf count
-            node.left.updateLeafNodeCount();
-            node.right.updateLeafNodeCount();
-            break;
-    }
-
-    return bestRotation;
-}
-
 /**
  *
  * @param {BinaryNode} root
  * @param {int} maxIterations
  */
-function optimize(root, maxIterations = 1000) {
+export function optimize(root, maxIterations = 1000) {
     const traverser = new StacklessTraverser();
 
     traverser.init(root);
@@ -376,8 +121,3 @@ function optimize(root, maxIterations = 1000) {
 
     return changeCounter;
 }
-
-export {
-    optimize,
-    tryRotateSingleNode
-};

package/core/bvh2/transform/tryRotateSingleNode.js

@@ -0,0 +1,259 @@
+import { boxSurfaceArea2 as computeArea, scoreBoxesSAH as computeAreaFor2 } from "../aabb3/AABB3Math.js";
+import { surfaceAreaHeuristic as sah } from "../sah/surfaceAreaHeuristic.js";
+import { isLeaf } from "../LeafNode.js";
+
+/**
+ *
+ * @param {Node} node
+ * @param {BinaryNode} parent
+ */
+function setParent(node, parent) {
+    node.parentNode = parent;
+}
+
+/**
+ * Based on paper "Fast, Effective BVH Updates for Animated Scenes" Kopta et. al. (url: http://www.cs.utah.edu/~thiago/papers/rotations.pdf)
+ * @param {BinaryNode} node
+ * @returns {int} value from 0 to 6, 0 means no rotation has taken place
+ */
+export function tryRotateSingleNode(node) {
+
+    const left = node.left;
+    const right = node.right;
+
+    if (left === null || right === null) {
+        return 0;
+    }
+
+    /*
+     First we compute best rotation to apply, enumerated by 0-6
+     */
+
+    let bestRotation = 0;
+
+
+    const nodeArea = computeArea(node);
+    const leftArea = computeArea(left);
+    const rightArea = computeArea(right);
+
+    const leftLeaves = left.leafNodeCount;
+    const rightLeaves = right.leafNodeCount;
+
+
+    let bestCost = sah(
+        nodeArea,
+        leftArea,
+        rightArea,
+        leftLeaves,
+        rightLeaves
+    );
+
+    let candidateCost;
+
+    let leftLeftArea,
+        leftRightArea,
+        rightLeftArea,
+        rightRightArea;
+
+    let leftLeft,
+        leftRight,
+        rightLeft,
+        rightRight;
+
+    let leftLeftLeaves,
+        leftRightLeaves,
+        rightLeftLeaves,
+        rightRightLeaves;
+
+    let considerLeft = !isLeaf(left);
+
+    if (considerLeft) {
+        leftLeft = left.left;
+        leftRight = left.right;
+
+        considerLeft = (leftLeft !== null && leftRight !== null);
+        if (considerLeft) {
+
+            leftLeftArea = computeArea(leftLeft);
+            leftRightArea = computeArea(leftRight);
+
+            leftLeftLeaves = leftLeft.leafNodeCount;
+            leftRightLeaves = leftRight.leafNodeCount;
+
+            // (1)    N                     N      //
+            //       / \                   / \     //
+            //      L   R     ----->      L   LL   //
+            //     / \                   / \       //
+            //   LL   LR                R   LR     //
+            candidateCost = sah(nodeArea, computeAreaFor2(right, leftRight), leftLeftArea, rightLeaves + leftRightLeaves, leftLeftLeaves);
+
+            if (candidateCost < bestCost) {
+                bestRotation = 1;
+                bestCost = candidateCost;
+            }
+
+            // (2)    N                     N      //
+            //       / \                   / \     //
+            //      L   R     ----->      L   LR   //
+            //     / \                   / \       //
+            //   LL   LR               LL   R      //
+            candidateCost = sah(nodeArea, computeAreaFor2(leftLeft, right), leftRightArea, leftLeftLeaves + rightLeaves, leftRightLeaves);
+
+
+            if (candidateCost < bestCost) {
+                bestRotation = 2;
+                bestCost = candidateCost;
+            }
+        }
+    }
+    if (!isLeaf(right)) {
+        rightLeft = right.left;
+        rightRight = right.right;
+        if (rightLeft !== null && rightRight !== null) {
+
+            rightLeftArea = computeArea(rightLeft);
+            rightRightArea = computeArea(rightRight);
+
+            rightLeftLeaves = rightLeft.leafNodeCount;
+            rightRightLeaves = rightRight.leafNodeCount;
+
+            // (3)    N                     N        //
+            //       / \                   / \       //
+            //      L   R     ----->     RL   R      //
+            //         / \                   / \     //
+            //       RL   RR                L   RR   //
+            candidateCost = sah(nodeArea, rightLeftArea, computeAreaFor2(left, rightRight), rightLeftLeaves, leftLeaves + rightRightLeaves);
+
+            if (candidateCost < bestCost) {
+                bestRotation = 3;
+                bestCost = candidateCost;
+            }
+
+            // (4)    N                     N       //
+            //       / \                   / \      //
+            //      L   R     ----->     RR   R     //
+            //         / \                   / \    //
+            //       RL   RR               RL   L   //
+            candidateCost = sah(nodeArea, rightRightArea, computeAreaFor2(rightLeft, left), rightRightLeaves, rightLeftLeaves + leftLeaves);
+
+
+            if (candidateCost < bestCost) {
+                bestRotation = 4;
+                bestCost = candidateCost;
+            }
+
+            if (considerLeft) {
+                //both child nodes are not leaf
+
+                // (5)       N                      N        //
+                //         /   \                  /   \      //
+                //        L     R     ----->     L     R     //
+                //       / \   / \              / \   / \    //
+                //      LL LR RL RR            LL RL LR RR   //
+                candidateCost = sah(
+                    nodeArea,
+                    computeAreaFor2(leftLeft, rightLeft),
+                    computeAreaFor2(leftRight, rightRight),
+                    leftLeftLeaves + rightLeftLeaves,
+                    leftRightLeaves + rightRightLeaves
+                );
+
+
+                if (candidateCost < bestCost) {
+                    bestRotation = 5;
+                    bestCost = candidateCost;
+                }
+
+                // (6)       N                      N        //
+                //         /   \                  /   \      //
+                //        L     R     ----->     L     R     //
+                //       / \   / \              / \   / \    //
+                //      LL LR RL RR            LL RR RL LR   //
+                candidateCost = sah(
+                    nodeArea,
+                    computeAreaFor2(leftLeft, rightRight),
+                    computeAreaFor2(rightLeft, leftRight),
+                    leftLeftLeaves + rightRightLeaves,
+                    rightLeftLeaves + leftRightLeaves
+                );
+
+                if (candidateCost < bestCost) {
+                    bestRotation = 6;
+                }
+            }
+        }
+    }
+
+    switch (bestRotation) {
+        case 0:
+            //no rotation
+            break;
+        case 1:
+            node.right = leftLeft;
+            setParent(leftLeft, node);
+            left.left = right;
+            setParent(right, left);
+
+            left.refit();
+            //update leaf count
+            node.left.updateLeafNodeCount();
+            break;
+        case 2:
+            node.right = leftRight;
+            setParent(leftRight, node);
+            left.right = right;
+            setParent(right, left);
+
+            left.refit();
+            //update leaf count
+            node.left.updateLeafNodeCount();
+            break;
+        case 3:
+            node.left = rightLeft;
+            setParent(rightLeft, node);
+            right.left = left;
+            setParent(left, right);
+
+            right.refit();
+            //update leaf count
+            node.right.updateLeafNodeCount();
+            break;
+        case 4:
+            node.left = rightRight;
+            setParent(rightRight, node);
+            right.right = left;
+            setParent(left, right);
+
+            right.refit();
+            //update leaf count
+            node.right.updateLeafNodeCount();
+            break;
+        case 5:
+            left.right = rightLeft;
+            setParent(rightLeft, left);
+            right.left = leftRight;
+            setParent(leftRight, right);
+
+            left.refit();
+            right.refit();
+
+            //update leaf count
+            node.left.updateLeafNodeCount();
+            node.right.updateLeafNodeCount();
+            break;
+        case 6:
+            left.right = rightRight;
+            setParent(rightRight, left);
+            right.right = leftRight;
+            setParent(leftRight, right);
+
+            left.refit();
+            right.refit();
+            //update leaf count
+            node.left.updateLeafNodeCount();
+            node.right.updateLeafNodeCount();
+            break;
+    }
+
+    return bestRotation;
+}

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;
+}