@woosh/meep-engine 2.66.0 → 2.68.0

package/build/meep.cjs

@@ -37522,8 +37522,8 @@ function middleInside( a, b ) {
 // if one belongs to the outer ring and another to a hole, it merges it into a single ring
 function splitPolygon( a, b ) {
 
-	const a2 = new Node$1( a.i, a.x, a.y ),
-		b2 = new Node$1( b.i, b.x, b.y ),
+	const a2 = new Node( a.i, a.x, a.y ),
+		b2 = new Node( b.i, b.x, b.y ),
 		an = a.next,
 		bp = b.prev;
 
@@ -37546,7 +37546,7 @@ function splitPolygon( a, b ) {
 // create a node and optionally link it with previous one (in a circular doubly linked list)
 function insertNode( i, x, y, last ) {
 
-	const p = new Node$1( i, x, y );
+	const p = new Node( i, x, y );
 
 	if ( ! last ) {
 
@@ -37576,7 +37576,7 @@ function removeNode( p ) {
 
 }
 
-function Node$1( i, x, y ) {
+function Node( i, x, y ) {
 
 	// vertex index in coordinates array
 	this.i = i;
@@ -54878,7 +54878,7 @@ function aabb3_intersects_ray(
     return f2 <= extents_x * abs_direction_y + extents_y * abs_direction_x;
 }
 
-const stack$b = SCRATCH_UINT32_TRAVERSAL_STACK;
+const stack$9 = SCRATCH_UINT32_TRAVERSAL_STACK;
 
 
 /**
@@ -54911,9 +54911,9 @@ function bvh_query_leaves_ray(
      *
      * @type {number}
      */
-    const stack_top = stack$b.pointer++;
+    const stack_top = stack$9.pointer++;
 
-    stack$b[stack_top] = root;
+    stack$9[stack_top] = root;
 
     let result_cursor = result_offset;
 
@@ -54924,13 +54924,13 @@ function bvh_query_leaves_ray(
     const uint32 = bvh.__data_uint32;
 
     do {
-        stack$b.pointer--;
+        stack$9.pointer--;
 
         /**
          *
          * @type {number}
          */
-        const node = stack$b[stack$b.pointer];
+        const node = stack$9[stack$9.pointer];
 
         const address = node * ELEMENT_WORD_COUNT;
 
@@ -54952,15 +54952,15 @@ function bvh_query_leaves_ray(
         if (child_1 !== NULL_NODE) {
 
             // this is not a leaf node, push children onto traversal stack
-            stack$b[stack$b.pointer++] = child_1;
-            stack$b[stack$b.pointer++] = uint32[address + COLUMN_CHILD_2];
+            stack$9[stack$9.pointer++] = child_1;
+            stack$9[stack$9.pointer++] = uint32[address + COLUMN_CHILD_2];
 
         } else {
             // leaf node
 
             result[result_cursor++] = node;
         }
-    } while (stack$b.pointer > stack_top);
+    } while (stack$9.pointer > stack_top);
 
     return result_cursor - result_offset;
 }
@@ -56870,7 +56870,7 @@ function build_morton(data, address, matrix) {
 }
 
 const scratch_box_0 = new Float32Array(18);
-const stack$a = [];
+const stack$8 = [];
 
 class BinaryUint32BVH {
     /**
@@ -57150,16 +57150,16 @@ class BinaryUint32BVH {
         let stackPointer = 2;
         let i, j;
 
-        stack$a[0] = 0; // first node
-        stack$a[1] = this.__node_count_leaf - 1; // last node
+        stack$8[0] = 0; // first node
+        stack$8[1] = this.__node_count_leaf - 1; // last node
 
         const data = this.__data_float32;
 
         while (stackPointer > 0) {
             stackPointer -= 2;
 
-            const right = stack$a[stackPointer + 1];
-            const left = stack$a[stackPointer];
+            const right = stack$8[stackPointer + 1];
+            const left = stack$8[stackPointer];
 
             i = left;
             j = right;
@@ -57194,12 +57194,12 @@ class BinaryUint32BVH {
 
             /* recursion */
             if (left < j) {
-                stack$a[stackPointer++] = left;
-                stack$a[stackPointer++] = j;
+                stack$8[stackPointer++] = left;
+                stack$8[stackPointer++] = j;
             }
             if (i < right) {
-                stack$a[stackPointer++] = i;
-                stack$a[stackPointer++] = right;
+                stack$8[stackPointer++] = i;
+                stack$8[stackPointer++] = right;
             }
         }
     }
@@ -57325,7 +57325,7 @@ function aabb3_array_intersects_ray(
     );
 }
 
-const stack$9 = SCRATCH_UINT32_TRAVERSAL_STACK;
+const stack$7 = SCRATCH_UINT32_TRAVERSAL_STACK;
 
 /**
  *
@@ -57359,13 +57359,13 @@ function bvh32_query_user_data_ray(
      *
      * @type {number}
      */
-    const stack_top = stack$9.pointer++;
+    const stack_top = stack$7.pointer++;
 
     /**
      * After performing empirical tests, stack-based depth-first traversal turns out faster than using a queue
      * @type {number}
      */
-    stack$9[stack_top] = 0;
+    stack$7[stack_top] = 0;
 
     const last_valid_index = binary_node_count + bvh.getLeafNodeCount();
 
@@ -57373,10 +57373,10 @@ function bvh32_query_user_data_ray(
     const uint32 = bvh.uint32;
 
     do {
-        stack$9.pointer--;
+        stack$7.pointer--;
 
         // query_bvh_frustum_from_objects.iteration_count++;
-        const node_index = stack$9[stack$9.pointer];
+        const node_index = stack$7[stack$7.pointer];
 
         if (node_index < binary_node_count) {
             // is intermediate node
@@ -57395,11 +57395,11 @@ function bvh32_query_user_data_ray(
 
             // left node ends up on top of the stack, which aligns with the desired access sequence
             if (right_index < last_valid_index) {
-                stack$9[stack$9.pointer++] = right_index;
+                stack$7[stack$7.pointer++] = right_index;
                 // micro-optimization, since we know that right node is valid and left appears before that, left is valid too
-                stack$9[stack$9.pointer++] = left_index;
+                stack$7[stack$7.pointer++] = left_index;
             } else if (left_index < last_valid_index) {
-                stack$9[stack$9.pointer++] = left_index;
+                stack$7[stack$7.pointer++] = left_index;
             }
 
 
@@ -57415,7 +57415,7 @@ function bvh32_query_user_data_ray(
             hit_count++;
         }
 
-    } while (stack$9.pointer > stack_top)
+    } while (stack$7.pointer > stack_top)
 
     return hit_count;
 }
@@ -67447,16 +67447,16 @@ class IndexedBinaryBVH {
      */
     traversePreOrderStack(visitor, startIndex) {
 
-        const stackOffset = stackPointer$2;
+        const stackOffset = stackPointer;
 
-        stack$8[stackPointer$2++] = startIndex;
+        stack$6[stackPointer++] = startIndex;
 
         const nodeThreshold = this.binaryNodeCount * 6;
         const endAddress = this.boxCount * 6;
 
-        while (stackPointer$2-- > stackOffset) {
+        while (stackPointer-- > stackOffset) {
 
-            const index = stack$8[stackPointer$2];
+            const index = stack$6[stackPointer];
 
             const address = index * 6;
 
@@ -67472,7 +67472,7 @@ class IndexedBinaryBVH {
                 //right
                 if (rightAddress < endAddress) {
                     if (rightAddress < nodeThreshold) {
-                        stack$8[stackPointer$2++] = rightIndex;
+                        stack$6[stackPointer++] = rightIndex;
                     } else {
                         visitor.visit(rightAddress, NodeType.LEAF);
                     }
@@ -67481,7 +67481,7 @@ class IndexedBinaryBVH {
                 //left
                 if (leftAddress < endAddress) {
                     if (leftAddress < nodeThreshold) {
-                        stack$8[stackPointer$2++] = leftIndex;
+                        stack$6[stackPointer++] = leftIndex;
                     } else {
                         visitor.visit(leftAddress, NodeType.LEAF);
                     }
@@ -67490,7 +67490,7 @@ class IndexedBinaryBVH {
         }
 
         //drop stack
-        stackPointer$2 = stackOffset;
+        stackPointer = stackOffset;
     }
 
     /**
@@ -67657,8 +67657,8 @@ function binaryNodeRefit(array, binaryNode, childNode0, childNode1) {
 }
 
 
-const stack$8 = [];
-let stackPointer$2 = 0;
+const stack$6 = [];
+let stackPointer = 0;
 
 const rayLeafIntersectionVisitor = new RayLeafIntersectionVisitor();
 
@@ -68779,7 +68779,6 @@ class ShadedGeometry {
 
     /**
      * @deprecated
-     * @returns {LeafNode<ShadedGeometry>}
      */
     get bvh() {
         throw new Error('Deprecated, use #getBoundingBox method instead');
@@ -69208,7 +69207,7 @@ function aabb3_array_intersects_frustum_degree(aabb, frustum) {
 
 //
 
-const stack$7 = SCRATCH_UINT32_TRAVERSAL_STACK;
+const stack$5 = SCRATCH_UINT32_TRAVERSAL_STACK;
 
 /**
  *
@@ -69231,20 +69230,20 @@ function bvh_collect_user_data(
      *
      * @type {number}
      */
-    const stack_top = stack$7.pointer++;
+    const stack_top = stack$5.pointer++;
 
-    stack$7[stack_top] = root;
+    stack$5[stack_top] = root;
 
     let result_cursor = destination_offset;
 
-    while (stack$7.pointer > stack_top) {
-        stack$7.pointer--;
+    while (stack$5.pointer > stack_top) {
+        stack$5.pointer--;
 
         /**
          *
          * @type {number}
          */
-        const node = stack$7[stack$7.pointer];
+        const node = stack$5[stack$5.pointer];
 
         const node_is_leaf = bvh.node_is_leaf(node);
 
@@ -69255,8 +69254,8 @@ function bvh_collect_user_data(
             const child2 = bvh.node_get_child2(node);
 
             // write to stack in reverse order, so that fist child ends up being visited first
-            stack$7[stack$7.pointer++] = child1;
-            stack$7[stack$7.pointer++] = child2;
+            stack$5[stack$5.pointer++] = child1;
+            stack$5[stack$5.pointer++] = child2;
 
         } else {
             // leaf root
@@ -69272,7 +69271,7 @@ function bvh_collect_user_data(
 
 //
 
-const stack$6 = SCRATCH_UINT32_TRAVERSAL_STACK;
+const stack$4 = SCRATCH_UINT32_TRAVERSAL_STACK;
 
 const scratch_aabb$1 = new Float32Array(6);
 
@@ -69299,20 +69298,20 @@ function bvh_query_user_data_overlaps_frustum(
      *
      * @type {number}
      */
-    const stack_top = stack$6.pointer++;
+    const stack_top = stack$4.pointer++;
 
-    stack$6[stack_top] = root;
+    stack$4[stack_top] = root;
 
     let result_cursor = result_offset;
 
-    while (stack$6.pointer > stack_top) {
-        stack$6.pointer--;
+    while (stack$4.pointer > stack_top) {
+        stack$4.pointer--;
 
         /**
          *
          * @type {number}
          */
-        const node = stack$6[stack$6.pointer];
+        const node = stack$4[stack$4.pointer];
 
         // test node against the ray
         bvh.node_get_aabb(node, scratch_aabb$1);
@@ -69339,8 +69338,8 @@ function bvh_query_user_data_overlaps_frustum(
             const child2 = bvh.node_get_child2(node);
 
             // write to stack in reverse order, so that fist child ends up being visited first
-            stack$6[stack$6.pointer++] = child1;
-            stack$6[stack$6.pointer++] = child2;
+            stack$4[stack$4.pointer++] = child1;
+            stack$4[stack$4.pointer++] = child2;
         }
     }
 
@@ -76229,7 +76228,7 @@ class SGMeshSystem extends System {
     }
 }
 
-const stack$5 = SCRATCH_UINT32_TRAVERSAL_STACK;
+const stack$3 = SCRATCH_UINT32_TRAVERSAL_STACK;
 
 /**
  *
@@ -76253,20 +76252,20 @@ function bvh_query_leaves_generic(
      *
      * @type {number}
      */
-    const stack_top = stack$5.pointer++;
+    const stack_top = stack$3.pointer++;
 
-    stack$5[stack_top] = root;
+    stack$3[stack_top] = root;
 
     let result_cursor = result_offset;
 
-    while (stack$5.pointer > stack_top) {
-        stack$5.pointer--;
+    while (stack$3.pointer > stack_top) {
+        stack$3.pointer--;
 
         /**
          *
          * @type {number}
          */
-        const node = stack$5[stack$5.pointer];
+        const node = stack$3[stack$3.pointer];
 
         // test node against the ray
         const pass = query.evaluate(node, bvh);
@@ -76284,8 +76283,8 @@ function bvh_query_leaves_generic(
             const child2 = bvh.node_get_child2(node);
 
             // write to stack in reverse order, so that fist child ends up being visited first
-            stack$5[stack$5.pointer++] = child2;
-            stack$5[stack$5.pointer++] = child1;
+            stack$3[stack$3.pointer++] = child2;
+            stack$3[stack$3.pointer++] = child1;
 
         } else {
             // leaf node
@@ -76683,7 +76682,7 @@ class RuntimeDrawMethodOptimizer {
     }
 }
 
-const stack$4 = [];
+const stack$2 = [];
 
 /**
  * @template T
@@ -76709,14 +76708,14 @@ function arrayQuickSort(
     let stackPointer = 2;
     let i, j;
 
-    stack$4[0] = start;
-    stack$4[1] = end;
+    stack$2[0] = start;
+    stack$2[1] = end;
 
     while (stackPointer > 0) {
         stackPointer -= 2;
 
-        const right = stack$4[stackPointer + 1];
-        const left = stack$4[stackPointer];
+        const right = stack$2[stackPointer + 1];
+        const left = stack$2[stackPointer];
 
         i = left;
         j = right;
@@ -76749,12 +76748,12 @@ function arrayQuickSort(
 
         /* recursion */
         if (left < j) {
-            stack$4[stackPointer++] = left;
-            stack$4[stackPointer++] = j;
+            stack$2[stackPointer++] = left;
+            stack$2[stackPointer++] = j;
         }
         if (i < right) {
-            stack$4[stackPointer++] = i;
-            stack$4[stackPointer++] = right;
+            stack$2[stackPointer++] = i;
+            stack$2[stackPointer++] = right;
         }
     }
 }
@@ -76780,14 +76779,14 @@ function array_quick_sort_by_comparator(
     let stackPointer = 2;
     let i, j;
 
-    stack$4[0] = start;
-    stack$4[1] = end;
+    stack$2[0] = start;
+    stack$2[1] = end;
 
     while (stackPointer > 0) {
         stackPointer -= 2;
 
-        const right = stack$4[stackPointer + 1];
-        const left = stack$4[stackPointer];
+        const right = stack$2[stackPointer + 1];
+        const left = stack$2[stackPointer];
 
         i = left;
         j = right;
@@ -76823,12 +76822,12 @@ function array_quick_sort_by_comparator(
 
         /* recursion */
         if (left < j) {
-            stack$4[stackPointer++] = left;
-            stack$4[stackPointer++] = j;
+            stack$2[stackPointer++] = left;
+            stack$2[stackPointer++] = j;
         }
         if (i < right) {
-            stack$4[stackPointer++] = i;
-            stack$4[stackPointer++] = right;
+            stack$2[stackPointer++] = i;
+            stack$2[stackPointer++] = right;
         }
     }
 }
@@ -89353,1637 +89352,6 @@ class BinarySerializationRegistry {
  */
 BinarySerializationRegistry.prototype.isBinarySerializationRegistry = true;
 
-/**
- *
- * @param {AABB3} node
- * @returns {number}
- */
-function aabb3_box_surface_area_2(node) {
-    return aabb3_compute_half_surface_area(node.x0, node.y0, node.z0, node.x1, node.y1, node.z1);
-}
-
-/**
- *
- * @param {AABB3} a
- * @param {AABB3} b
- * @returns {number}
- */
-function aabb3_combined_surface_area(a, b) {
-    const x0 = min2(a.x0, b.x0);
-    const y0 = min2(a.y0, b.y0);
-    const z0 = min2(a.z0, b.z0);
-
-    const x1 = max2(a.x1, b.x1);
-    const y1 = max2(a.y1, b.y1);
-    const z1 = max2(a.z1, b.z1);
-
-    return aabb3_compute_half_surface_area(x0, y0, z0, x1, y1, z1);
-}
-
-/**
- * Returns true if two 1D lines intersect, touch is treated as intersection
- * Parameters are assumed to be ordered, a1 >= a0, b1 >= b0
- * @param {Number} a0
- * @param {Number} a1
- * @param {Number} b0
- * @param {Number} b1
- * @returns {boolean}
- */
-function intersects1D(a0, a1, b0, b1) {
-    assert.isNumber(a0, "a0");
-    assert.isNumber(a1, "a1");
-    assert.isNumber(b0, "b0");
-    assert.isNumber(b1, "b1");
-
-    return a1 >= b0 && b1 >= a0;
-}
-
-/**
- *
- * @param {number} ax0
- * @param {number} ay0
- * @param {number} az0
- * @param {number} ax1
- * @param {number} ay1
- * @param {number} az1
- * @param {number} bx0
- * @param {number} by0
- * @param {number} bz0
- * @param {number} bx1
- * @param {number} by1
- * @param {number} bz1
- * @returns {boolean}
- */
-function aabb3_intersects_aabb3(
-    ax0, ay0, az0,
-    ax1, ay1, az1,
-    bx0, by0, bz0,
-    bx1, by1, bz1
-) {
-    return intersects1D(ax0, ax1, bx0, bx1)
-        && intersects1D(ay0, ay1, by0, by1)
-        && intersects1D(az0, az1, bz0, bz1);
-}
-
-/**
- *
- * @param {number[]} sample
- * @returns {number}
- */
-function computeSampleStandardDeviation(sample) {
-    //compute sample mean
-    const mean = computeStatisticalMean(sample);
-
-    const N = sample.length;
-
-    let SUM = 0;
-    for (let i = 0; i < N; i++) {
-        const x = sample[i];
-
-        const delta = x - mean;
-
-        const delta2 = delta * delta;
-
-        SUM += delta2;
-    }
-
-    const variance = SUM / (N - 1);
-
-    return Math.sqrt(variance);
-}
-
-/**
- * Created by Alex on 17/11/2014.
- */
-
-
-class Node extends AABB3 {
-    constructor() {
-        super();
-
-        /**
-         *
-         * @type {BinaryNode|null}
-         */
-        this.parentNode = null;
-        this._mortonCode = void 0;
-    }
-
-    /**
-     * @return {boolean}
-     */
-    validateAncestorChain() {
-        //check containment
-        const parent = this.parentNode;
-        if (parent === null) {
-            //nothing to do
-            return true;
-        }
-
-        if (!parent.containsBox(this)) {
-            //bounds violated
-            return false;
-        }
-
-        if (parent.left === this || parent.right === this) ; else {
-            return false;
-        }
-
-        return true;
-    }
-
-    /**
-     *
-     * @returns {number}
-     */
-    computeDepth() {
-        let d = 0;
-        let node = this.parentNode;
-
-        while (node !== null) {
-            node = node.parentNode;
-
-            d++;
-        }
-
-        return d;
-    }
-
-    /**
-     *
-     * @returns {Node}
-     */
-    computeRoot() {
-        let p = this;
-
-        while (p.parentNode !== null) {
-            p = p.parentNode;
-        }
-
-        return p;
-    }
-
-    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 = mortonEncode_magicbits(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
-     */
-    bubbleExpandToFit(box) {
-        let node = this;
-        while (node.expandToFit(box)) {
-            node = node.parentNode;
-            if (node === null) {
-                break;
-            }
-        }
-    }
-
-    /**
-     * @deprecated
-     */
-    remove() {
-        console.error("This method is deprecated, use 'disconnect' instead.");
-        this.disconnect();
-    }
-
-    /**
-     * 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 (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.updateHeight();
-    }
-
-    /**
-     * traverses all siblings up to the root
-     */
-    traverseSiblingsUp() {
-        throw new Error('Not Implemented');
-    }
-}
-
-/**
- * Created by Alex on 17/11/2014.
- */
-
-
-/**
- *
- * @param {Node|LeafNode} node
- * @returns {boolean}
- */
-function isLeaf(node) {
-    return node.isLeafNode;
-}
-
-/**
- * @deprecated use {@link BVH} and {@link BvhClient} respectively
- */
-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;
-
-    }
-
-    /**
-     *
-     * @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();
-        }
-    }
-
-    /**
-     *
-     * @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();
-    }
-
-    bubbleRefit() {
-
-        if (this.parentNode !== null) {
-            this.parentNode.bubbleRefit();
-        }
-    }
-
-    /**
-     *
-     * @return {LeafNode}
-     */
-    clone() {
-        const clone = new LeafNode(this.object, this.x0, this.y0, this.z0, this.x1, this.y1, this.z1);
-
-        clone.parentNode = this.parentNode;
-
-        return clone;
-    }
-}
-
-/**
- *
- * @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;
-
-/**
- * Surface Area Heuristic
- * @param {number} saV Surface Area of the volume being split
- * @param {number} saVL Surface Area of Left Volume
- * @param {number} saVR Surface Area of Right Volume
- * @param {number|int} nL Number of leaf nodes in Left Volume
- * @param {number|int} nR Number of leaf nodes in Right Volume
- * @param {number} kT constant for the estimated cost of a traversal step
- * @param {number} kI constant for the estimated cost of a intersection
- * @returns {number}
- */
-function surfaceAreaHeuristicFull(saV, saVL, saVR, nL, nR, kT, kI) {
-    return kT + kI * (saVL * nL / saV + saVR * nR / saV);
-}
-
-/**
- * Surface Area Heuristic
- * @param {number} saV Surface Area of the volume being split
- * @param {number} saVL Surface Area of Left Volume
- * @param {number} saVR Surface Area of Right Volume
- * @param {number|int} nL Number of leaf nodes in Left Volume
- * @param {number|int} nR Number of leaf nodes in Right Volume
- * @returns {number}
- */
-function surfaceAreaHeuristic(saV, saVL, saVR, nL, nR) {
-    return surfaceAreaHeuristicFull(saV, saVL, saVR, nL, nR, 1, 1);
-}
-
-class BVHVisitor {
-    constructor() {
-
-    }
-
-    initialize() {
-
-    }
-
-    finalize() {
-
-    }
-
-    /**
-     *
-     * @param {LeafNode} node
-     */
-    visitLeaf(node) {
-
-    }
-
-    /**
-     *
-     * @param {BinaryNode} node
-     * @returns {boolean} true if traversal should go deeper, false to exclude descendants from traversal
-     */
-    visitBinary(node) {
-        return true;
-    }
-}
-
-const stack$3 = [];
-let stackPointer$1 = 0;
-
-/**
- *
- * @param {BinaryNode} node
- * @param {BVHVisitor} visitor
- */
-function traverseBinaryNodeUsingVisitor(node, visitor) {
-    let n;
-
-    const stackOffset = stackPointer$1;
-
-    stack$3[stackPointer$1++] = node;
-
-    while (stackPointer$1-- > stackOffset) {
-
-        n = stack$3[stackPointer$1];
-
-        if (n.isBinaryNode) {
-            const traverseDeeper = visitor.visitBinary(n);
-
-            if (traverseDeeper !== false) {
-
-                if (n.left !== null) {
-
-                    // has a LEFT child
-
-                    stack$3[stackPointer$1++] = n.left;
-
-                }
-
-                if (n.right !== null) {
-
-                    // has a RIGHT child
-
-                    stack$3[stackPointer$1++] = n.right;
-
-                }
-
-            }
-        } else {
-            visitor.visitLeaf(n);
-        }
-
-    }
-
-    //drop the stack frame
-    stackPointer$1 = stackOffset;
-}
-
-/**
- * Created by Alex on 17/11/2014.
- */
-
-
-/**
- * @callback BinaryNode~Visitor
- * @param {Node} node
- * @returns {boolean} flag, controls traversal of descendants. If false - no traversal is done over descendants
- */
-
-
-/**
- *
- * @type {number}
- */
-let stackPointer = 0;
-/**
- *
- * @type {Node[]}
- */
-const stack$2 = [];
-
-/**
- * @deprecated use {@link BVH} instead
- */
-class BinaryNode extends Node {
-    constructor() {
-        super();
-
-        /**
-         *
-         * @type {null|BinaryNode|LeafNode}
-         */
-        this.parentNode = null;
-
-        /**
-         *
-         * @type {null|Node|LeafNode|BinaryNode}
-         */
-        this.left = null;
-
-        /**
-         *
-         * @type {null|Node|LeafNode|BinaryNode}
-         */
-        this.right = null;
-
-        /**
-         * 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;
-    }
-
-    /**
-     * Same as traversePreOrder but without recursion. This runs faster thanks to avoidance of function call overhead. Especially useful for deeper trees.
-     * @param {BinaryNode~Visitor} visitor
-     * @param [thisArg]
-     * @deprecated use visitor-based traversal instead of callback-based
-     */
-    traversePreOrderUsingStack(visitor, thisArg) {
-        let visitCount = 0;
-
-        const stackOffset = stackPointer;
-
-        stack$2[stackPointer++] = this;
-        let n;
-        while (stackPointer-- > stackOffset) {
-
-            visitCount++;
-
-            n = stack$2[stackPointer];
-
-            const traverseDeeper = visitor.call(thisArg, n);
-
-            if (traverseDeeper !== false && n.isBinaryNode) {
-                if (n.right !== null) {
-                    stack$2[stackPointer++] = n.right;
-                }
-                if (n.left !== null) {
-                    stack$2[stackPointer++] = n.left;
-                }
-            }
-        }
-
-        // drop stack frame
-        stackPointer = stackOffset;
-
-        return visitCount;
-    }
-
-    /**
-     * Traverse leaf nodes in a fast manner
-     * @param {function(node:LeafNode)} visitor
-     * @param {*} [thisArg]
-     */
-    traverseLeavesPreOrderUsingStack(visitor, thisArg) {
-        let visitCount = 0;
-
-        const stackOffset = stackPointer;
-
-        stack$2[stackPointer++] = this;
-
-        let n;
-
-        while (stackPointer-- > stackOffset) {
-
-            visitCount++;
-
-            n = stack$2[stackPointer];
-
-            if (n.isLeafNode) {
-                visitor.call(thisArg, n);
-            } else {
-                //a binary node
-                if (n.right !== null) {
-                    stack$2[stackPointer++] = n.right;
-                }
-                if (n.left !== null) {
-                    stack$2[stackPointer++] = n.left;
-                }
-            }
-        }
-
-        // drop stack frame
-        stackPointer = stackOffset;
-
-        return visitCount;
-    }
-
-
-    /**
-     * Contains no children
-     * @returns {boolean}
-     */
-    isEmpty() {
-        return this.left === null && this.right === null;
-    }
-
-    reset() {
-        this.left = null;
-        this.right = null;
-
-        this.leafNodeCount = 0;
-        this.height = 0;
-
-        this.setNegativelyInfiniteBounds();
-    }
-
-    /**
-     *
-     * @param {Node|BinaryNode} left
-     * @param {Node|BinaryNode} right
-     */
-    setChildren(left, right) {
-        this.left = left;
-        this.right = right;
-
-        left.parentNode = this;
-        right.parentNode = this;
-    }
-
-    /**
-     *
-     * @param {Node} child
-     */
-    setChildLeft(child) {
-        assert.isNull(this.left, 'left');
-
-        this.left = child;
-        child.parentNode = this;
-    }
-
-    /**
-     *
-     * @param {Node} child
-     */
-    setChildRight(child) {
-        assert.isNull(this.right, 'right');
-
-        this.right = child;
-        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
-     * @private
-     * @param {AABB3} box
-     * @returns {BinaryNode|LeafNode}
-     */
-    __insertion_findSiblingFor(box) {
-
-        let node = this;
-        let cost_left = 0;
-        let cost_right = 0;
-
-        while (node.isBinaryNode === true) {
-            const left = node.left;
-            const right = node.right;
-
-            const area = aabb3_box_surface_area_2(node);
-
-            const combined_area = aabb3_combined_surface_area(node, box);
-
-            //cost of creating a new parent for this node and the new leaf
-            const cost = combined_area;
-
-            // minimum cost of pushing the leaf further down the tree
-            const inheritance_cost = combined_area - area;
-
-            // cost of descending left
-            if (left !== null) {
-                const combined_left = aabb3_combined_surface_area(left, box);
-                if (left.isLeafNode) {
-                    cost_left = combined_left + inheritance_cost;
-                } else {
-                    cost_left = combined_left - aabb3_box_surface_area_2(left) + inheritance_cost;
-                }
-            } else {
-                cost_left = Infinity;
-            }
-
-            // cost of descending right
-            if (right !== null) {
-
-                const combined_right = aabb3_combined_surface_area(right, box);
-                if (right.isLeafNode) {
-                    cost_right = combined_right + inheritance_cost;
-                } else {
-                    cost_right = combined_right - 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 && left !== null) {
-                node = left;
-            } else if (right !== null) {
-                node = right;
-            } else {
-                break;
-            }
-        }
-
-        return node;
-    }
-
-    /**
-     *
-     * @param {AABB3} box
-     * @returns {Node|BinaryNode|LeafNode}
-     */
-    findParentFor(box) {
-        let n = this;
-        let aCost = 0;
-        let bCost = 0;
-
-        for (; ;) {
-
-            const a = n.left;
-            const b = n.right;
-
-            if (a === null || b === null) {
-                //unbalanced node, good candidate already
-                return n;
-            }
-
-            const aIsBinary = a.isBinaryNode;
-            const bIsBinary = b.isBinaryNode;
-
-            aCost = a.costForInclusion(box);
-            bCost = b.costForInclusion(box);
-
-            if (aCost === bCost) {
-
-                if (a.isLeafNode) {
-
-                    return a;
-
-                } else if (b.isLeafNode) {
-
-                    return b;
-
-                }
-
-                //change costs to be based on balance
-                aCost = a.leafNodeCount / aabb3_box_surface_area_2(a);
-                bCost = b.leafNodeCount / aabb3_box_surface_area_2(b);
-            }
-
-            if (aCost === bCost) {
-                //still the same, toss a coin
-                aCost = Math.random();
-                bCost = 1 - aCost;
-            }
-
-            if (aCost < bCost) {
-                if (aIsBinary) {
-                    n = a;
-                } else {
-                    return a;
-                }
-            } else {
-                if (bIsBinary) {
-                    n = b;
-                } else {
-                    return b;
-                }
-            }
-        }
-    }
-
-    traverse(visitor) {
-        if (this.left !== null) {
-            const cA = visitor(this.left);
-            if (cA !== false) {
-                this.left.traverse(visitor);
-            }
-        }
-        if (this.right !== null) {
-            const cB = visitor(this.right);
-            if (cB !== false) {
-                this.right.traverse(visitor);
-            }
-        }
-    }
-
-    /**
-     * Bottom-up tree traversal, children first
-     * @param visitor
-     */
-    traversePostOrder(visitor) {
-        //left
-        if (this.left instanceof BinaryNode) {
-            this.left.traversePostOrder(visitor);
-        } else if (this.left instanceof LeafNode) {
-            visitor(this.left);
-        }
-        //right
-        if (this.right instanceof BinaryNode) {
-            this.right.traversePostOrder(visitor);
-        } else if (this.right instanceof LeafNode) {
-            visitor(this.right);
-        }
-        visitor(this);
-    }
-
-    traversePreOrder(visitor) {
-        const carryOn = visitor(this);
-        if (carryOn !== false) {
-            //left
-            if (this.left instanceof BinaryNode) {
-                this.left.traversePreOrder(visitor);
-            } else if (this.left instanceof LeafNode) {
-                visitor(this.left);
-            }
-            //right
-            if (this.right instanceof BinaryNode) {
-                this.right.traversePreOrder(visitor);
-            } else if (this.right instanceof LeafNode) {
-                visitor(this.right);
-            }
-        }
-    }
-
-    refitFor2() {
-        const a = this.left;
-        const b = this.right;
-
-        const x0 = min2(a.x0, b.x0);
-        const y0 = min2(a.y0, b.y0);
-        const z0 = min2(a.z0, b.z0);
-
-        const x1 = max2(a.x1, b.x1);
-        const y1 = max2(a.y1, b.y1);
-        const z1 = max2(a.z1, b.z1);
-
-        this.setBounds(x0, y0, z0, x1, y1, z1);
-    }
-
-    bubbleRefit() {
-        let n = this;
-
-        n.refit();
-
-        //bubble up
-        for (; ;) {
-            //record old node size
-            const _x0 = n.x0;
-            const _y0 = n.y0;
-            const _z0 = n.z0;
-            const _x1 = n.x1;
-            const _y1 = n.y1;
-            const _z1 = n.z1;
-
-            n = n.parentNode;
-
-            if (n === null) {
-                // hit the root
-                return;
-            }
-
-
-            //check if this node violates bounds of the parent
-            let flag = false;
-
-            if (_x0 < n.x0) {
-                n.x0 = _x0;
-                flag = true;
-            }
-            if (_y0 < n.y0) {
-                n.y0 = _y0;
-                flag = true;
-            }
-            if (_z0 < n.z0) {
-                n.z0 = _z0;
-                flag = true;
-            }
-
-            if (_x1 > n.x1) {
-                n.x1 = _x1;
-                flag = true;
-            }
-            if (_y1 > n.y1) {
-                n.y1 = _y1;
-                flag = true;
-            }
-            if (_z1 > n.z1) {
-                n.z1 = _z1;
-                flag = true;
-            }
-
-            if (!flag) {
-                //no violation, we can stop here
-                break;
-            }
-        }
-    }
-
-    refit() {
-        if (this.left !== null && this.right !== null) {
-            this.refitFor2();
-        } else if (this.left !== null) {
-            this.copy(this.left);
-        } else if (this.right !== null) {
-            this.copy(this.right);
-        }
-    }
-
-    sumSurfaceArea() {
-        let result = 0;
-        this.traversePreOrderUsingStack(function (node) {
-            const nodeArea = node.computeSurfaceArea();
-            result += nodeArea;
-        });
-
-        return result;
-    }
-
-    countDescendants() {
-        let result = 0;
-        this.traversePreOrderUsingStack(function (node) {
-            result++;
-        });
-        return result;
-    }
-
-    /**
-     * @deprecated Incorrect usage of SAH
-     * @return {number}
-     */
-    computeSAH() {
-        let leftLeaves, rightLeaves, leftArea, rightArea;
-
-        const left = this.left;
-
-        if (left === null) {
-            leftArea = 0;
-            leftLeaves = 0;
-        } else {
-            leftArea = aabb3_box_surface_area_2(left);
-            leftLeaves = left.leafNodeCount;
-        }
-
-        const right = this.right;
-        if (right === null) {
-            rightArea = 0;
-            rightLeaves = 0;
-        } else {
-            rightArea = aabb3_box_surface_area_2(right);
-            rightLeaves = right.leafNodeCount;
-        }
-
-        const thisArea = aabb3_box_surface_area_2(this);
-
-        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;
-
-        while (node !== null) {
-            let n = 0;
-
-            const right = node.right;
-
-            if (right !== null) {
-                if (right.isLeafNode) {
-                    n++;
-                } else {
-                    n += right.leafNodeCount;
-                }
-            }
-
-            const left = this.left;
-
-            if (left !== null) {
-                if (left.isLeafNode) {
-                    n++;
-                } else {
-                    n += left.leafNodeCount;
-                }
-            }
-
-            node.leafNodeCount = n;
-
-            // propagate update up the tree
-            node = node.parentNode;
-        }
-
-    }
-
-    /**
-     * As a result of rotation, this node 'becomes' the right node, and left node get's replaced by the right node with necessary adjustments
-     */
-    rotateLeft() {
-
-        /**
-         *
-         * @type {BinaryNode}
-         */
-        const r = this.right;
-
-        const l = this.left;
-
-        const rL = r.left;
-        const rR = r.right;
-
-        this.left = r;
-        this.right = rR;
-
-        if (rR !== null) {
-            rR.parentNode = this;
-        }
-
-        r.left = l;
-        if (l !== null) {
-            l.parentNode = r;
-        }
-
-        r.right = rL;
-
-        r.updateLeafNodeCount();
-        r.updateHeight();
-
-        r.bubbleRefit();
-    }
-
-    rotateRight() {
-        const r = this.right;
-
-        const left = this.left;
-
-        const lL = left.left;
-        const lR = left.right;
-
-        if (lL !== null) {
-            lL.parentNode = this;
-        }
-
-        left.right = r;
-        if (r !== null) {
-            r.parentNode = left;
-        }
-
-        left.left = lR;
-
-        left.updateLeafNodeCount();
-        left.updateHeight();
-
-        left.bubbleRefit();
-    }
-
-    /**
-     *
-     * @param {function(index:int):LeafNode} leafFactory
-     * @param {int} numNodes
-     */
-    insertManyBoxes2(leafFactory, numNodes) {
-        let i, n;
-        //create leaf nodes
-        const nodes = new Array(numNodes);
-
-        for (i = 0; i < numNodes; i++) {
-            //leaf needs to be set up inside the callback
-            n = leafFactory(i);
-
-            nodes[i] = n;
-        }
-
-        //sort leaves
-        arrayQuickSort(nodes, n => n.computeMortonCode(), null, 0, max2(0, numNodes - 1));
-
-        let remaining_nodes = numNodes;
-
-        while (remaining_nodes > 2) {
-
-            //pair
-            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;
-            }
-
-            const numNodesMod2 = remaining_nodes & 1; //faster version of %2
-
-            if (numNodesMod2 !== 0) {
-                //shift remaining node up so it will be considered later
-                nodes[i >> 1] = nodes[i];
-            }
-
-            remaining_nodes = (remaining_nodes >> 1) + numNodesMod2;
-        }
-
-        //finally insert these boxes from this node
-        for (i = 0; i < remaining_nodes; i++) {
-            n = nodes[i];
-            this.insertNode(n);
-        }
-    }
-
-    /**
-     *
-     * @param {LeafNode[]} result destination
-     * @param {number} x0
-     * @param {number} y0
-     * @param {number} z0
-     * @param {number} x1
-     * @param {number} y1
-     * @param {number} z1
-     * @returns {number} number of objects added to the result
-     */
-    requestLeafIntersectionsAABB3(result, x0, y0, z0, x1, y1, z1) {
-        const startOffset = stackPointer;
-
-        stack$2[stackPointer++] = this;
-
-        let count = 0;
-
-        while (stackPointer > startOffset) {
-            stackPointer--;
-            const node = stack$2[stackPointer];
-
-            if (!aabb3_intersects_aabb3(
-                x0, y0, z0, x1, y1, z1,
-                node.x0, node.y0, node.z0, node.x1, node.y1, node.z1
-            )) {
-                //no overlap
-                continue;
-            }
-
-            if (node.isLeafNode) {
-                result[count++] = node;
-
-                count++;
-            } else {
-                const left = node.left;
-                if (left !== null) {
-                    stack$2[stackPointer++] = left;
-                }
-
-                const right = node.right;
-                if (right !== null) {
-                    stack$2[stackPointer++] = right;
-                }
-            }
-        }
-
-        return count;
-    }
-
-    traverseSegmentLeafIntersections(startX, startY, startZ, endX, endY, endZ, visitor) {
-        this.traversePreOrder(function (node) {
-            let b = node.intersectSegment(startX, startY, startZ, endX, endY, endZ);
-            if (!b) {
-                return false;
-            }
-            if (node instanceof LeafNode) {
-                visitor(node);
-                return false;
-            } else {
-                return true;
-            }
-        });
-    }
-
-    /**
-     *
-     * @param {Frustum[]} frustums Collection of THREE.js Frustums
-     * @param {function(node:LeafNode, boolean)} visitor
-     * @returns {number}
-     * @deprecated Use {@link ThreeFrustumsIntersectionBVHVisitor}
-     */
-    threeTraverseFrustumsIntersections(frustums, visitor) {
-        const numFrustums = frustums.length;
-
-        /**
-         *
-         * @param {LeafNode|BinaryNode} node
-         * @returns {boolean}
-         */
-        function visitNode(node) {
-            let b = false;
-            let i = 0;
-
-            for (; i < numFrustums; i++) {
-
-                const degree = node.intersectFrustumDegree(frustums[i]);
-
-                if (degree === 2) {
-                    //completely inside frustum
-
-                    if (node.isLeafNode) {
-                        visitor(node, true);
-                    } else {
-                        node.traverseLeavesPreOrderUsingStack(fastVisitLeafNodeIntersection, visitor);
-                    }
-
-                    //prevent further traversal
-                    return false;
-
-                } else if (degree === 1) {
-
-                    //partially inside frustum
-                    b = true;
-
-                }
-            }
-
-            if (!b) {
-                return false;
-            }
-
-            if (node.isLeafNode) {
-                visitor(node, false);
-            }
-
-            return true;
-        }
-
-        return this.traversePreOrderUsingStack(visitNode);
-    }
-
-    /**
-     * As recursion goes on, we remove frustums and planes from checks reducing total number of checks necessary
-     * @param {Array.<THREE.Frustum>} frustums
-     * @param {function} visitor
-     * @returns {number}
-     */
-    threeTraverseFrustumsIntersections2(frustums, visitor) {
-        const numFrustums = frustums.length;
-
-        function visitLeaves(node) {
-            if (node instanceof LeafNode) {
-                visitor(node);
-                return false;
-            } else {
-                return true;
-            }
-        }
-
-        function fastTraverseLeaves(node) {
-            if (node instanceof LeafNode) {
-                visitor(node);
-            } else {
-                node.traversePreOrderUsingStack(visitLeaves);
-            }
-        }
-
-        function removeElementFromClone(original, clone, mask, originalIndex) {
-            if (clone === original) {
-                //clone planes
-                clone = clone.slice();
-            }
-            //remove the plane from new set
-            clone.splice(originalIndex, 1);
-            return clone;
-        }
-
-        function processVolumesIntersections(node, planeSets, planeSetCount) {
-            let newPlaneSets = planeSets;
-            for (let iPS = planeSetCount - 1; iPS >= 0; iPS--) {
-
-                const planes = planeSets[iPS];
-                let newPlanes = planes;
-                const numPlanes = planes.length;
-
-                //check plane set
-                for (let i = numPlanes - 1; i >= 0; i--) {
-                    const plane = planes[i];
-                    const planeSide = node.computePlaneSide(plane);
-                    if (planeSide < 0) {
-                        //completely inside
-                        newPlanes = removeElementFromClone(planes, newPlanes);
-                    } else if (planeSide > 0) {
-                        //on the wrong side of the plane
-                        //drop plane set
-                        newPlaneSets = removeElementFromClone(planeSets, newPlaneSets);
-
-                        break;
-                    }
-                }
-
-                //update plane sets as needed
-                if (newPlanes !== planes && newPlaneSets.indexOf(planes) !== -1) {
-                    //replace
-                    if (newPlaneSets === planeSets) {
-                        //clone if needed
-                        newPlaneSets = newPlaneSets.slice();
-                    }
-                    newPlaneSets[iPS] = newPlanes;
-                }
-            }
-
-            return newPlaneSets;
-        }
-
-        function traverseVolumeIntersections(node, planeSets, numPlaneSets) {
-            function internalVisitor(node) {
-                let newPlaneSet = processVolumesIntersections(node, planeSets, numPlaneSets);
-                if (newPlaneSet !== planeSets) {
-                    let newPlaneSetCount = newPlaneSet.length;
-                    if (newPlaneSetCount !== 0) {
-                        //some intersections
-
-                        //check if all plane sets are trivial (contain no test planes)
-                        let trivialPlaneSets = 0;
-                        for (let i = 0; i < newPlaneSetCount; i++) {
-                            if (newPlaneSet[i].length === 0) {
-                                trivialPlaneSets++;
-                            }
-                        }
-
-                        if (isLeaf(node)) {
-                            visitor(node);
-                        } else {
-                            if (trivialPlaneSets === newPlaneSetCount) {
-                                fastTraverseLeaves(node);
-                            } else {
-                                traverseVolumeIntersections(node, newPlaneSet, newPlaneSetCount);
-                            }
-                        }
-                    }
-                } else {
-                    if (isLeaf(node)) {
-                        visitor(node);
-                    } else {
-                        return true;
-                    }
-                }
-
-                return false;
-            }
-
-            node.traversePreOrderUsingStack(internalVisitor);
-        }
-
-        function startTraversal(node) {
-            let planeSets = [];
-            for (let i = 0; i < numFrustums; i++) {
-                const frustum = frustums[i];
-                const planes = frustum.planes;
-                planeSets.push(planes);
-            }
-            traverseVolumeIntersections(node, planeSets, numFrustums);
-        }
-
-        startTraversal(this);
-    }
-
-    /**
-     *
-     * @param {number} startX
-     * @param {number} startY
-     * @param {number} startZ
-     * @param {number} directionX
-     * @param {number} directionY
-     * @param {number} directionZ
-     * @param {function(node:LeafNode)} visitor
-     * @param thisArg
-     * @deprecated use {@link RaycastBVHVisitor} instead
-     */
-    traverseRayLeafIntersections(startX, startY, startZ, directionX, directionY, directionZ, visitor, thisArg) {
-        this.traversePreOrderUsingStack(function (node) {
-            let b = node.intersectRay(startX, startY, startZ, directionX, directionY, directionZ);
-
-            if (!b) {
-                //no intersection, terminate this branch
-                return false;
-            }
-
-            if (isLeaf(node)) {
-                //leaf node, supply to visitor
-                visitor.call(thisArg, node);
-                return false;
-            } else {
-                //intermediate node, continue traversal
-                return true;
-            }
-        });
-    }
-
-    /**
-     * Fraction of balanced nodes in the tree (those that have both children)
-     * @returns {number}
-     */
-    computeBalanceFactor() {
-
-        const bvhVisitor = new BVHVisitor();
-
-
-        const depths = [];
-
-        bvhVisitor.visitLeaf = (leaf) => {
-            const depth = leaf.computeDepth();
-
-            depths.push(depth);
-        };
-
-        traverseBinaryNodeUsingVisitor(this, bvhVisitor);
-
-        if (depths.length === 0) {
-            return 1;
-        } else {
-            return computeSampleStandardDeviation(depths);
-        }
-
-    }
-
-    /**
-     * @template T
-     * @param {number} x0
-     * @param {number} y0
-     * @param {number} z0
-     * @param {number} x1
-     * @param {number} y1
-     * @param {number} z1
-     * @param {T} value
-     * @returns {LeafNode}
-     */
-    insert(x0, y0, z0, x1, y1, z1, value) {
-        const leaf = new LeafNode(value, x0, y0, z0, x1, y1, z1);
-        this.insertNode(leaf);
-        return leaf;
-    }
-
-    /**
-     *
-     * @param {Node|BinaryNode|LeafNode} child
-     */
-    insertNode(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 sibling = this.__insertion_findSiblingFor(child);
-
-        let parent = sibling.parentNode;
-
-        if (parent === null) {
-            // "sibling" is the root node
-
-            parent = sibling;
-
-            if (sibling.left === null) {
-                sibling.setChildLeft(child);
-            } else if (sibling.right === null) {
-                sibling.setChildRight(child);
-            } else {
-                parent = new BinaryNode();
-
-                parent.setChildren(sibling.right, child);
-                sibling.right = parent;
-                parent.parentNode = sibling;
-            }
-
-        } else {
-
-            // non-root
-
-            if (parent.left === sibling && parent.right === null) {
-
-                // right node is free, take it
-                parent.setChildRight(child);
-
-            } else if (parent.right === sibling && parent.left === null) {
-
-                // left node is free, take it
-                parent.setChildLeft(child);
-
-            } else {
-
-                parent = transplantNewCommonParent(sibling, child);
-
-            }
-
-        }
-
-        // walk back up the tree fixing heights and bounds
-        do {
-            // 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;
-        } while (parent !== null);
-    }
-
-    /**
-     * @param {boolean} deep
-     * @returns {BinaryNode}
-     */
-    clone(deep = false) {
-        const clone = new BinaryNode();
-
-        clone.x0 = this.x0;
-        clone.y0 = this.y0;
-        clone.z0 = this.z0;
-        clone.x1 = this.x1;
-        clone.y1 = this.y1;
-        clone.z1 = this.z1;
-
-        clone.leafNodeCount = this.leafNodeCount;
-
-        clone.parentNode = this.parentNode;
-
-        if (deep === true) {
-            if (this.left !== null) {
-                clone.left = this.left.clone(true);
-                clone.left.parentNode = clone;
-            }
-            if (this.right !== null) {
-                clone.right = this.right.clone(true);
-                clone.right.parentNode = clone;
-            }
-        } else {
-            clone.left = this.left;
-            clone.right = this.right;
-        }
-
-        clone.modifiers = this.modifiers;
-
-        return clone;
-    }
-}
-
-/**
- * @readonly
- * @type {boolean}
- */
-BinaryNode.prototype.isBinaryNode = true;
-
-/**
- * @private
- * Used in intersection traversal methods. Should be invoked via Function.apply and Function.call only and not be called directly
- * @param {LeafNode} node
- */
-function fastVisitLeafNodeIntersection(node) {
-    this(node, true);
-}
-
-/**
- *
- * @param {Node} node
- * @param {Node} child
- * @return {BinaryNode}
- */
-function transplantNewCommonParent(node, child) {
-    const bNode = new BinaryNode();
-
-    //
-    const parent = node.parentNode;
-    if (node === parent.left) {
-        parent.left = bNode;
-    } else if (node === parent.right) {
-        parent.right = bNode;
-    } else {
-        throw new Error("Not a child of specified parent node(impostor)");
-    }
-
-    bNode.setChildren(node, child);
-    bNode.parentNode = parent;
-
-    return bNode;
-}
-
 class MetricsGateway {
     constructor() {
 
@@ -92663,47 +91031,39 @@ class RenderLayerState {
  */
 
 class RenderLayer {
-    constructor() {
-        /**
-         * @deprecated
-         * @type {BinaryNode}
-         */
-        this.bvh = new BinaryNode();
-        this.bvh.setNegativelyInfiniteBounds();
 
-        /**
-         *
-         * @type {RenderLayerState}
-         */
-        this.state = new RenderLayerState();
+    /**
+     *
+     * @type {RenderLayerState}
+     */
+    state = new RenderLayerState();
 
-        /**
-         *
-         * @type {String|null}
-         */
-        this.name = null;
+    /**
+     *
+     * @type {String|null}
+     */
+    name = null;
 
-        /**
-         * Layer is managed externally, visibility will not be updated in the rendering engine
-         * @deprecated
-         * @type {boolean}
-         */
-        this.managed = false;
+    /**
+     * Layer is managed externally, visibility will not be updated in the rendering engine
+     * @deprecated
+     * @type {boolean}
+     */
+    managed = false;
 
-        /**
-         *
-         * @type {function(*): Object3D}
-         */
-        this.extractRenderable = passThrough$1;
+    /**
+     *
+     * @type {function(*): Object3D}
+     */
+    extractRenderable = passThrough$1;
 
-        /**
-         * @deprecated use CameraView's visible set instead
-         * Contains visible elements across all views, if element is in at least one view - it will be here
-         * @deprecated
-         * @type {IncrementalDeltaSet<THREE.Object3D>}
-         */
-        this.visibleSet = new IncrementalDeltaSet(compare_three_objects);
-    }
+    /**
+     * @deprecated use CameraView's visible set instead
+     * Contains visible elements across all views, if element is in at least one view - it will be here
+     * @deprecated
+     * @type {IncrementalDeltaSet<THREE.Object3D>}
+     */
+    visibleSet = new IncrementalDeltaSet(compare_three_objects);
 
     /**
      * @deprecated
@@ -92736,7 +91096,7 @@ class RenderLayer {
     }
 
     /**
-     @deprecated
+     * @deprecated
      * @param {THREE.Object3D[]} destination
      * @param {number} destination_offset
      * @param {CameraView} view
@@ -93858,13 +92218,6 @@ class GraphicsEngine {
          */
         this.layers = new RenderLayerManager();
 
-        /**
-         *
-         * @type {BinaryNode}
-         */
-        this.bvh = new BinaryNode();
-        this.bvh.setNegativelyInfiniteBounds();
-
         //renderer setup
         const scene = new Scene$1();
         //prevent automatic updates to all descendants of the scene, such updates are very wasteful
@@ -104893,6 +103246,24 @@ class TooltipManager {
 
 }
 
+/**
+ * Returns true if two 1D lines intersect, touch is treated as intersection
+ * Parameters are assumed to be ordered, a1 >= a0, b1 >= b0
+ * @param {Number} a0
+ * @param {Number} a1
+ * @param {Number} b0
+ * @param {Number} b1
+ * @returns {boolean}
+ */
+function intersects1D(a0, a1, b0, b1) {
+    assert.isNumber(a0, "a0");
+    assert.isNumber(a1, "a1");
+    assert.isNumber(b0, "b0");
+    assert.isNumber(b1, "b1");
+
+    return a1 >= b0 && b1 >= a0;
+}
+
 /**
  * Created by Alex on 14/03/2016.
  */