@woosh/meep-engine 2.34.38 → 2.34.39

package/core/bvh2/BinaryNode.js

@@ -34,7 +34,7 @@ let stackPointer = 0;
  */
 const stack = [];
 
-export class BinaryNode extends Node{
+export class BinaryNode extends Node {
     constructor() {
         super();
 
@@ -58,10 +58,17 @@ export class BinaryNode extends Node{
 
         /**
          * Number of leaf nodes in the hierarchy
+         * @deprecated
          * @type {number}
          * @private
          */
         this.leafNodeCount = 0;
+
+        /**
+         * Leaf node will have height 0, root node will have height equal to maximum depth of the tree
+         * @type {number}
+         */
+        this.height = 0;
     }
 
     /**
@@ -107,38 +114,38 @@ export class BinaryNode extends Node{
      * @param {*} [thisArg]
      */
     traverseLeavesPreOrderUsingStack(visitor, thisArg) {
-            let visitCount = 0;
+        let visitCount = 0;
 
-            const stackOffset = stackPointer;
+        const stackOffset = stackPointer;
 
-            stack[stackPointer++] = this;
+        stack[stackPointer++] = this;
 
-            let n;
+        let n;
 
-            while (stackPointer-- > stackOffset) {
+        while (stackPointer-- > stackOffset) {
 
-                visitCount++;
+            visitCount++;
 
-                n = stack[stackPointer];
+            n = stack[stackPointer];
 
-                if (n.isLeafNode) {
-                    visitor.call(thisArg, n);
-                } else {
-                    //a binary node
-                    if (n.right !== null) {
-                        stack[stackPointer++] = n.right;
-                    }
-                    if (n.left !== null) {
-                        stack[stackPointer++] = n.left;
-                    }
+            if (n.isLeafNode) {
+                visitor.call(thisArg, n);
+            } else {
+                //a binary node
+                if (n.right !== null) {
+                    stack[stackPointer++] = n.right;
+                }
+                if (n.left !== null) {
+                    stack[stackPointer++] = n.left;
                 }
             }
+        }
 
         // drop stack frame
         stackPointer = stackOffset;
 
-            return visitCount;
-        }
+        return visitCount;
+    }
 
 
     /**
@@ -154,6 +161,7 @@ export class BinaryNode extends Node{
         this.right = null;
 
         this.leafNodeCount = 0;
+        this.height = 0;
 
         this.setNegativelyInfiniteBounds();
     }
@@ -167,10 +175,6 @@ export class BinaryNode extends Node{
         this.left = left;
         this.right = right;
 
-        this.updateLeafNodeCount()
-
-        this.refitFor2();
-
         left.parentNode = this;
         right.parentNode = this;
     }
@@ -183,11 +187,6 @@ export class BinaryNode extends Node{
         assert.isNull(this.left, 'left');
 
         this.left = child;
-
-        this.updateLeafNodeCount();
-
-        this.refit();
-
         child.parentNode = this;
     }
 
@@ -199,16 +198,12 @@ export class BinaryNode extends Node{
         assert.isNull(this.right, 'right');
 
         this.right = child;
-
-        this.updateLeafNodeCount();
-
-        this.refit();
-
         child.parentNode = this;
     }
 
     /**
      * For incremental insertion, a sibling needs to be found, newly inserted node will be parented together with this sibling
+     * @see https://github.com/erincatto/box2d/blob/9dc24a6fd4f32442c4bcf80791de47a0a7d25afb/src/collision/b2_dynamic_tree.cpp#L197
      * @param {AABB3} box
      * @returns {BinaryNode|LeafNode}
      */
@@ -503,6 +498,35 @@ export class BinaryNode extends Node{
         return surfaceAreaHeuristic(thisArea, leftArea, rightArea, leftLeaves, rightLeaves);
     }
 
+    updateHeight() {
+        let node = this;
+        let n = 0;
+
+        while (node !== null) {
+            n = 0;
+
+            const right = node.right;
+
+            if (right !== null) {
+                n = right.height;
+            }
+
+            const left = this.left;
+
+            if (left !== null) {
+                n = max2(n, left.height);
+            }
+
+            node.height = n + 1;
+
+            // propagate update up the tree
+            node = node.parentNode;
+        }
+    }
+
+    /**
+     * @deprecated
+     */
     updateLeafNodeCount() {
         let node = this;
 
@@ -568,6 +592,7 @@ export class BinaryNode extends Node{
         r.right = rL;
 
         r.updateLeafNodeCount();
+        r.updateHeight();
 
         r.bubbleRefit();
     }
@@ -575,25 +600,26 @@ export class BinaryNode extends Node{
     rotateRight() {
         const r = this.right;
 
-        const l = this.left;
+        const left = this.left;
 
-        const lL = l.left;
-        const lR = l.right;
+        const lL = left.left;
+        const lR = left.right;
 
         if (lL !== null) {
             lL.parentNode = this;
         }
 
-        l.right = r;
+        left.right = r;
         if (r !== null) {
-            r.parentNode = l;
+            r.parentNode = left;
         }
 
-        l.left = lR;
+        left.left = lR;
 
-        l.updateLeafNodeCount();
+        left.updateLeafNodeCount();
+        left.updateHeight();
 
-        l.bubbleRefit();
+        left.bubbleRefit();
     }
 
     /**
@@ -624,8 +650,14 @@ export class BinaryNode extends Node{
             for (i = 0; i < remaining_nodes - 1; i += 2) {
                 const a = nodes[i];
                 const b = nodes[i + 1];
+
                 n = new BinaryNode();
+
                 n.setChildren(a, b);
+
+                n.updateHeight();
+                n.refitFor2();
+
                 nodes[i >> 1] = n;
             }
 
@@ -994,15 +1026,19 @@ export class BinaryNode extends Node{
         const sibling = this.__insertion_findSiblingFor(child);
 
         const sibling_parent = sibling.parentNode;
+        let parent = sibling_parent;
+
         if (sibling_parent === null) {
-            // root node
+            // "sibling" is the root node
+
+            parent = sibling;
 
             if (sibling.left === null) {
                 sibling.setChildLeft(child);
             } else if (sibling.right === null) {
                 sibling.setChildRight(child);
             } else {
-                const parent = new BinaryNode();
+                parent = new BinaryNode();
 
                 parent.setChildren(sibling.right, child);
                 sibling.right = parent;
@@ -1025,12 +1061,23 @@ export class BinaryNode extends Node{
 
             } else {
 
-                transplantNewCommonParent(sibling, child)
+                parent = transplantNewCommonParent(sibling, child)
 
             }
 
-            sibling_parent.bubbleRefit();
+        }
+
+        // walk back up the tree fixing heights and bounds
+        while (parent !== null) {
+            // parent = this.balance();
+
+            const left = parent.left;
+            const right = parent.right;
 
+            parent.height = 1 + max2(left !== null ? left.height : 0, right !== null ? right.height : 0);
+            parent.refit();
+
+            parent = parent.parentNode;
         }
     }
 
@@ -1116,38 +1163,6 @@ function inclusion_cost_lower_bound(node, addition) {
 }
 
 
-/**
- *
- * @param {Node} n0
- * @param {Node} n1
- * @return {number}
- */
-function sortMortonCodes(n0, n1) {
-    return n0._mortonCode - n1._mortonCode;
-}
-
-
-/**
- *
- * @param node
- */
-function countLeaves(node) {
-    if (isLeaf(node)) {
-        return 1;
-    }
-
-    let result = 0;
-
-    node.traversePreOrderUsingStack(function (node) {
-        if (isLeaf(node)) {
-            result++;
-        }
-    });
-
-    return result;
-}
-
-
 /**
  * @private
  * Used in intersection traversal methods. Should be invoked via Function.apply and Function.call only and not be called directly
@@ -1179,10 +1194,6 @@ function transplantNewCommonParent(node, child) {
     bNode.setChildren(node, child);
     bNode.parentNode = parent;
 
-    parent.bubbleExpandToFit(bNode);
-
-    parent.updateLeafNodeCount();
-
     return bNode;
 }
 

package/core/bvh2/LeafNode.js

@@ -39,17 +39,6 @@ export class LeafNode extends Node {
         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;
     }
 
     /**
@@ -105,6 +94,26 @@ export class LeafNode extends Node {
     }
 }
 
+/**
+ *
+ * @type {boolean}
+ */
+LeafNode.prototype.isLeafNode = true;
+
+/**
+ * Leaf node will have height 0, root node will have height equal to maximum depth of the tree
+ * @type {number}
+ */
+LeafNode.prototype.height = 0;
+
+/**
+ * Useful shortcut, to avoid having to distinguish between leaf and intermediate nodes
+ * @readonly
+ * @deprecated
+ * @type {number}
+ */
+LeafNode.prototype.leafNodeCount = 1;
+
 /**
  *
  * @param {BinaryBuffer} buffer

package/core/bvh2/Node.js

@@ -132,6 +132,7 @@ export class Node extends AABB3 {
         }
 
         node.updateLeafNodeCount();
+        node.updateHeight();
     }
 
     /**

package/package.json

@@ -5,7 +5,7 @@
   "productName": "Meep",
   "description": "production-ready JavaScript game engine based on Entity Component System Architecture",
   "author": "Alexander Goldring",
-  "version": "2.34.38",
+  "version": "2.34.39",
   "dependencies": {
     "gl-matrix": "3.4.3",
     "fast-levenshtein": "2.0.6",