@woosh/meep-engine 2.34.42 → 2.34.46

package/core/bvh2/BinaryNode.js

@@ -8,12 +8,14 @@ import { arrayQuickSort } from "../collection/array/arrayQuickSort.js";
 import { max2 } from "../math/max2.js";
 import { min2 } from "../math/min2.js";
 import { computeSampleStandardDeviation } from "../math/statistics/computeSampleStandardDeviation.js";
-import { _boxSurfaceArea2, aabb3_intersect_aabb3, boxSurfaceArea2 } from "./aabb3/AABB3Math.js";
 import { isLeaf, LeafNode } from "./LeafNode.js";
 import { Node } from "./Node.js";
 import { surfaceAreaHeuristic } from "./sah/surfaceAreaHeuristic.js";
 import { BVHVisitor } from "./traversal/BVHVisitor.js";
 import { traverseBinaryNodeUsingVisitor } from "./traversal/traverseBinaryNodeUsingVisitor.js";
+import { aabb3_intersect_aabb3 } from "./aabb3/aabb3_intersect_aabb3.js";
+import { aabb3_box_surface_area_2 } from "./aabb3/aabb3_box_surface_area_2.js";
+import { aabb3_compute_half_surface_area } from "./aabb3/aabb3_compute_half_surface_area.js";
 
 
 /**
@@ -209,44 +211,60 @@ export class BinaryNode extends Node {
      */
     __insertion_findSiblingFor(box) {
 
-        const open_set = [this];
-        let cursor = 1;
+        let node = this;
+        let cost_left = 0;
+        let cost_right = 0;
 
-        let best_cost = Infinity;
-        let best_node = this;
+        while (node.isBinaryNode) {
+            const left = node.left;
+            const right = node.right;
 
-        while (cursor > 0) {
-            const node = open_set[--cursor];
+            const area = aabb3_box_surface_area_2(node);
 
-            const cost = inclusion_surface_area_heuristic(node, box);
+            const combined_area = combined_surface_area(node, box);
 
-            if (cost < best_cost) {
-                best_cost = cost;
-                best_node = node;
-            }
+            //cost of creating a new parent for this node and the new leaf
+            const cost = combined_area;
 
-            if (node.isBinaryNode) {
+            // minimum cost of pushing the leaf further down the tree
+            const inheritance_cost = combined_area - area;
 
-                // consider pushing children into the queue
+            // cost of descending left
+            if (left !== null) {
+                if (left.isLeafNode) {
+                    cost_left = combined_surface_area(left, box) + inheritance_cost;
+                } else {
+                    cost_left = combined_surface_area(left, box) - aabb3_box_surface_area_2(left) + inheritance_cost;
+                }
+            } else {
+                cost_left = Infinity;
+            }
 
-                // compute lower bound for cost
-                const c_low = inclusion_cost_lower_bound(node, box);
+            // cost of descending right
+            if (right !== null) {
 
-                if (c_low < best_cost) {
-                    // worth-while to explore children
-                    if (node.left !== null) {
-                        open_set[cursor++] = node.left;
-                    }
-                    if (node.right !== null) {
-                        open_set[cursor++] = node.right
-                    }
+                if (right.isLeafNode) {
+                    cost_right = combined_surface_area(right, box) + inheritance_cost;
+                } else {
+                    cost_right = combined_surface_area(right, box) - aabb3_box_surface_area_2(right) + inheritance_cost;
                 }
+            } else {
+                cost_right = Infinity;
             }
 
+            if (cost < cost_left && cost < cost_right) {
+                // descending either branch is too expensive
+                break;
+            }
 
+            if (cost_left < cost_right) {
+                node = left;
+            } else {
+                node = right;
+            }
         }
 
-        return best_node;
+        return node;
     }
 
     /**
@@ -288,8 +306,8 @@ export class BinaryNode extends Node {
                 }
 
                 //change costs to be based on balance
-                aCost = a.leafNodeCount / boxSurfaceArea2(a);
-                bCost = b.leafNodeCount / boxSurfaceArea2(b);
+                aCost = a.leafNodeCount / aabb3_box_surface_area_2(a);
+                bCost = b.leafNodeCount / aabb3_box_surface_area_2(b);
             }
 
             if (aCost === bCost) {
@@ -480,7 +498,7 @@ export class BinaryNode extends Node {
             leftArea = 0;
             leftLeaves = 0;
         } else {
-            leftArea = boxSurfaceArea2(left);
+            leftArea = aabb3_box_surface_area_2(left);
             leftLeaves = left.leafNodeCount;
         }
 
@@ -489,11 +507,11 @@ export class BinaryNode extends Node {
             rightArea = 0;
             rightLeaves = 0;
         } else {
-            rightArea = boxSurfaceArea2(right);
+            rightArea = aabb3_box_surface_area_2(right);
             rightLeaves = right.leafNodeCount;
         }
 
-        const thisArea = boxSurfaceArea2(this);
+        const thisArea = aabb3_box_surface_area_2(this);
 
         return surfaceAreaHeuristic(thisArea, leftArea, rightArea, leftLeaves, rightLeaves);
     }
@@ -1132,6 +1150,16 @@ BinaryNode.prototype.isBinaryNode = true;
  * @returns {number}
  */
 function inclusion_surface_area_heuristic(node, addition) {
+    return combined_surface_area(node, addition) - aabb3_box_surface_area_2(node);
+}
+
+/**
+ *
+ * @param {AABB3} node
+ * @param {AABB3} addition
+ * @returns {number}
+ */
+function combined_surface_area(node, addition) {
     const x0 = min2(node.x0, addition.x0);
     const y0 = min2(node.y0, addition.y0);
     const z0 = min2(node.z0, addition.z0);
@@ -1140,7 +1168,7 @@ function inclusion_surface_area_heuristic(node, addition) {
     const y1 = max2(node.y1, addition.y1);
     const z1 = max2(node.z1, addition.z1);
 
-    return _boxSurfaceArea2(x0, y0, z0, x1, y1, z1) - boxSurfaceArea2(node);
+    return aabb3_compute_half_surface_area(x0, y0, z0, x1, y1, z1);
 }
 
 /**
@@ -1150,7 +1178,7 @@ function inclusion_surface_area_heuristic(node, addition) {
  */
 function inclusion_cost_lower_bound(node, addition) {
     let n = node;
-    let r = boxSurfaceArea2(addition);
+    let r = aabb3_box_surface_area_2(addition);
 
     while (n !== null) {
 

package/core/bvh2/LeafNode.js

@@ -1,8 +1,9 @@
 /**
  * Created by Alex on 17/11/2014.
  */
-import { deserializeAABB3, serializeAABB3 } from "./aabb3/AABB3.js";
 import { Node } from "./Node.js";
+import { serializeAABB3 } from "./aabb3/serializeAABB3.js";
+import { deserializeAABB3 } from "./aabb3/deserializeAABB3.js";
 
 
 /**