@woosh/meep-engine 2.68.0 → 2.70.0

package/build/meep.module.js

@@ -1762,6 +1762,27 @@ function clamp$1(value, min, max) {
     }
 }
 
+/**
+ * Very small value, used for comparison when compensation for rounding error is required
+ * @type {number}
+ */
+const EPSILON = 0.000001;
+
+/**
+ * Comparison of two numbers with a given tolerance
+ * @param {number} a
+ * @param {number} b
+ * @param {number} tolerance
+ * @returns {boolean}
+ */
+function epsilonEquals(a, b, tolerance) {
+    assert.isNumber(a, 'a');
+    assert.isNumber(b, 'b');
+    assert.isNumber(tolerance, 'tolerance');
+
+    return Math.abs(a - b) <= tolerance;
+}
+
 /**
  * Linear interpolation between two values controlled by a given fraction
  * @param {number} a
@@ -1773,13 +1794,191 @@ function lerp$1(a, b, fraction) {
     return (b - a) * fraction + a;
 }
 
+/**
+ * Returns lowest value out of 2 supplied
+ * @param {number} a
+ * @param {number} b
+ * @returns {number}
+ */
+function min2(a, b) {
+    return a < b ? a : b;
+}
+
 /**
  *
  * @param {number} v
- * @returns {number} +1 if v>0, 0 if v == 0, -1 if v<0
+ * @returns {number}
  */
-function sign$1(v) {
-    return v > 0 ? 1 : (v < 0 ? -1 : 0);
+function computeHashFloat(v) {
+    //we break the number up into fractional and whole parts
+    const whole = v | 0;
+
+    const fraction = v - whole;
+
+    //fractional part is scaled up into int32 range, this inexact method, as it will produce 0 hash for values below a certain threshold
+    const fractionHash = fraction * 1367130550;
+
+    //take XOR of both parts
+    return fractionHash ^ whole;
+}
+
+const K = Math.SQRT1_2 / 511;
+
+/**
+ * Based on GDC talk from Bungie on destiny, compressing quaternions for animation
+ * @param {number[]} output
+ * @param {number} output_offset
+ * @param {number} value
+ */
+function quat_decode_from_uint32(output, output_offset, value) {
+    //read components
+    const max = value & 0x3;
+
+    const iv0 = (value >> 2) & 0x3FF;
+    const iv1 = (value >> 12) & 0x3FF;
+    const iv2 = (value >> 22) & 0x3FF;
+
+    //scale components back to quaternion range
+    const v0 = iv0 * K - Math.SQRT1_2;
+    const v1 = iv1 * K - Math.SQRT1_2;
+    const v2 = iv2 * K - Math.SQRT1_2;
+
+    //restore dropped component using quaternion identity: x^2 + y^2 + z^2 + w^2 = 1
+    const dropped_2 = 1 - v0 * v0 - v1 * v1 - v2 * v2;
+    const dropped = Math.sqrt(dropped_2);
+
+    let x, y, z, w;
+    if (max === 0) {
+        x = dropped;
+        y = v0;
+        z = v1;
+        w = v2;
+    } else if (max === 1) {
+        x = v0;
+        y = dropped;
+        z = v1;
+        w = v2;
+    } else if (max === 2) {
+        x = v0;
+        y = v1;
+        z = dropped;
+        w = v2;
+    } else {
+        x = v0;
+        y = v1;
+        z = v2;
+        w = dropped;
+    }
+
+    output[output_offset] = x;
+    output[output_offset + 1] = y;
+    output[output_offset + 2] = z;
+    output[output_offset + 3] = w;
+}
+
+/**
+ * Based on GDC talk from Bungie on destiny, compressing quaternions for animation
+ * @param {number} x
+ * @param {number} y
+ * @param {number} z
+ * @param {number} w
+ * @returns {number}
+ */
+function quat_encode_to_uint32(x, y, z, w) {
+
+    const absX = Math.abs(x);
+    const absY = Math.abs(y);
+    const absZ = Math.abs(z);
+    const absW = Math.abs(w);
+
+    let max = 0;
+
+    //pick max component
+    if (absY > absX) {
+        if (absY > absZ) {
+            if (absY > absW) {
+                //absY is max
+                max = 1;
+            } else {
+                //absW is max
+                max = 3;
+            }
+        } else if (absZ > absW) {
+            //absZ is max
+            max = 2;
+        } else {
+            //absW is max
+            max = 3;
+        }
+    } else if (absX > absZ) {
+        if (absX > absW) {
+            max = 0;
+        } else {
+            max = 3;
+        }
+    } else if (absZ > absW) {
+        max = 2;
+    } else {
+        max = 3;
+    }
+
+    let v0, v1, v2, dropped;
+
+    //max will be dropped
+    if (max === 0) {
+        //dropping x
+        v0 = y;
+        v1 = z;
+        v2 = w;
+
+        dropped = x;
+    } else if (max === 1) {
+        //dropping y
+        v0 = x;
+        v1 = z;
+        v2 = w;
+
+        dropped = y;
+    } else if (max === 2) {
+        //dropping z
+        v0 = x;
+        v1 = y;
+        v2 = w;
+
+        dropped = z;
+    } else {
+        //dropping w
+        v0 = x;
+        v1 = y;
+        v2 = z;
+
+        dropped = w;
+    }
+
+    if (dropped < 0) {
+        //reconstructing dropped value is only possible if it is positive, so we invert the quaternion to make dropped value positive
+        v0 = -v0;
+        v1 = -v1;
+        v2 = -v2;
+    }
+
+    const l = Math.sqrt(x * x + y * y + z * z + w * w);
+    const m = 511 / (l * Math.SQRT1_2);
+
+    //re-normalize the remaining components to 10 bit UINT value
+    const oV0 = Math.round(v0 * m + 511);
+    const oV1 = Math.round(v1 * m + 511);
+    const oV2 = Math.round(v2 * m + 511);
+
+    assert.ok(oV0 <= 1023 && oV0 >= 0, `expected 0 <= ov0 <= 1023, instead was '${oV0}'`);
+    assert.ok(oV1 <= 1023 && oV1 >= 0, `expected 0 <= ov1 <= 1023, instead was '${oV1}'`);
+    assert.ok(oV2 <= 1023 && oV2 >= 0, `expected 0 <= ov2 <= 1023, instead was '${oV2}'`);
+
+
+    return (max & 0x3)
+        | ((oV0 & 0x3FF) << 2)
+        | ((oV1 & 0x3FF) << 12)
+        | ((oV2 & 0x3FF) << 22);
 }
 
 /**
@@ -1798,13 +1997,11 @@ function v3_dot(x0, y0, z0, x1, y1, z1) {
 
 /**
  *
- * @param {number} x
- * @param {number} y
- * @param {number} z
- * @return {number}
+ * @param {number} v
+ * @returns {number} +1 if v>0, 0 if v == 0, -1 if v<0
  */
-function v3_length_sqr(x, y, z) {
-    return x * x + y * y + z * z;
+function sign$1(v) {
+    return v > 0 ? 1 : (v < 0 ? -1 : 0);
 }
 
 /**
@@ -1860,6 +2057,110 @@ function v3_angle_cos_between(x0, y0, z0, x1, y1, z1){
     return clamp$1(d / l, -1, 1);
 }
 
+/**
+ *
+ * @param {BinaryBuffer} buffer
+ * @param {number[]} result
+ * @param {number} result_offset
+ */
+function v3_binary_equality_decode(buffer, result, result_offset) {
+    const header = buffer.readUint8();
+
+    let x = 0;
+    let y = 0;
+    let z = 0;
+
+    if ((header & 7) === 7) {
+        //all scale components are the same
+        x = buffer.readFloat32();
+        y = x;
+        z = x;
+    } else if ((header & 1) === 1) {
+        //X and Y are the same, Z is different
+        x = buffer.readFloat32();
+        y = x;
+        z = buffer.readFloat32();
+    } else if ((header & 2) === 2) {
+        //Y and Z are the same, X is different
+        x = buffer.readFloat32();
+        y = buffer.readFloat32();
+        z = y;
+    } else if ((header & 4) === 4) {
+        //X and Z are the same, Y is different
+        x = buffer.readFloat32();
+        y = buffer.readFloat32();
+        z = x;
+    } else {
+        //scale components are different
+        x = buffer.readFloat32();
+        y = buffer.readFloat32();
+        z = buffer.readFloat32();
+    }
+
+    result[result_offset] = x;
+    result[result_offset + 1] = y;
+    result[result_offset + 2] = z;
+}
+
+/**
+ *
+ * @param {BinaryBuffer} buffer
+ * @param {number} x
+ * @param {number} y
+ * @param {number} z
+ */
+function v3_binary_equality_encode(buffer, x, y, z){
+
+    let header = 0;
+
+    if (x === y) {
+        header |= 1;
+    }
+
+    if (y === z) {
+        header |= 2;
+    }
+
+    if (x === z) {
+        header |= 4;
+    }
+
+    buffer.writeUint8(header);
+
+    if ((header & 7) === 7) {
+        //all components are the same
+        buffer.writeFloat32(x);
+    } else if (header === 1) {
+        //X and Y are the same, Z is different
+        buffer.writeFloat32(x);
+        buffer.writeFloat32(z);
+    } else if (header === 2) {
+        //Y and Z are the same, X is different
+        buffer.writeFloat32(x);
+        buffer.writeFloat32(y);
+    } else if (header === 4) {
+        //X and Z are the same, Y is different
+        buffer.writeFloat32(x);
+        buffer.writeFloat32(y);
+    } else {
+        //scale components are different
+        buffer.writeFloat32(x);
+        buffer.writeFloat32(y);
+        buffer.writeFloat32(z);
+    }
+}
+
+/**
+ *
+ * @param {number} x
+ * @param {number} y
+ * @param {number} z
+ * @return {number}
+ */
+function v3_length_sqr(x, y, z) {
+    return x * x + y * y + z * z;
+}
+
 /**
  *
  * @param {Vector3} result
@@ -1931,45 +2232,6 @@ function v3_slerp(
     result.set(x, y, z);
 }
 
-/**
- *
- * @param {number} v
- * @returns {number}
- */
-function computeHashFloat(v) {
-    //we break the number up into fractional and whole parts
-    const fraction = v % 1;
-
-    const whole = v | 0;
-
-    //fractional part is scaled up into int32 range, this inexact method, as it will produce 0 hash for values below a certain threshold
-    const fractionHash = fraction * 1367130550;
-
-    //take XOR of both parts
-    return fractionHash ^ whole;
-}
-
-/**
- * Comparison of two numbers with a given tolerance
- * @param {number} a
- * @param {number} b
- * @param {number} tolerance
- * @returns {boolean}
- */
-function epsilonEquals(a, b, tolerance) {
-    assert.isNumber(a, 'a');
-    assert.isNumber(b, 'b');
-    assert.isNumber(tolerance, 'tolerance');
-
-    return Math.abs(a - b) <= tolerance;
-}
-
-/**
- * Very small value, used for comparison when compensation for rounding error is required
- * @type {number}
- */
-const EPSILON = 0.000001;
-
 /**
  * @author Alex Goldring
  * @copyright Alex Goldring 2015
@@ -2814,100 +3076,31 @@ let Vector3$1 = class Vector3 {
     /**
      *
      * @param {BinaryBuffer} buffer
+     * @deprecated use dedicated method directly instead
      */
     toBinaryBufferFloat32_EqualityEncoded(buffer) {
         const x = this.x;
         const y = this.y;
         const z = this.z;
 
-        let header = 0;
-
-        if (x === y) {
-            header |= 1;
-        }
-
-        if (y === z) {
-            header |= 2;
-        }
-
-        if (x === z) {
-            header |= 4;
-        }
-
-        buffer.writeUint8(header);
-
-        if ((header & 7) === 7) {
-            //all components are the same
-            buffer.writeFloat32(x);
-        } else if (header === 1) {
-            //X and Y are the same, Z is different
-            buffer.writeFloat32(x);
-            buffer.writeFloat32(z);
-        } else if (header === 2) {
-            //Y and Z are the same, X is different
-            buffer.writeFloat32(x);
-            buffer.writeFloat32(y);
-        } else if (header === 4) {
-            //X and Z are the same, Y is different
-            buffer.writeFloat32(x);
-            buffer.writeFloat32(y);
-        } else {
-            //scale components are different
-            buffer.writeFloat32(x);
-            buffer.writeFloat32(y);
-            buffer.writeFloat32(z);
-        }
+        v3_binary_equality_encode(buffer, x, y, z);
     }
 
     /**
      * Uses an extra byte for a header. Only writes unique components. Useful for things like scale where all components usually have the same value
      * @param {BinaryBuffer} buffer
+     * @deprecated use dedicated method directly instead
      */
     fromBinaryBufferFloat32_EqualityEncoded(buffer) {
-        const header = buffer.readUint8();
-
-        let x = 0;
-        let y = 0;
-        let z = 0;
-
-        if ((header & 7) === 7) {
-            //all scale components are the same
-            x = buffer.readFloat32();
-            y = x;
-            z = x;
-        } else if ((header & 1) === 1) {
-            //X and Y are the same, Z is different
-            x = buffer.readFloat32();
-            y = x;
-            z = buffer.readFloat32();
-        } else if ((header & 2) === 2) {
-            //Y and Z are the same, X is different
-            x = buffer.readFloat32();
-            y = buffer.readFloat32();
-            z = y;
-        } else if ((header & 4) === 4) {
-            //X and Z are the same, Y is different
-            x = buffer.readFloat32();
-            y = buffer.readFloat32();
-            z = x;
-        } else {
-            //scale components are different
-            x = buffer.readFloat32();
-            y = buffer.readFloat32();
-            z = buffer.readFloat32();
-        }
-
-        this.set(x, y, z);
+        v3_binary_equality_decode(buffer, this, 0);
     }
 
     hash() {
-        let hash = computeHashFloat(this.x);
-
-        hash = ((hash << 5) - hash) + computeHashFloat(this.y);
-
-        hash = ((hash << 5) - hash) + computeHashFloat(this.z);
+        const x = computeHashFloat(this.x);
+        const y = computeHashFloat(this.y);
+        const z = computeHashFloat(this.z);
 
-        return hash;
+        return x ^ (y << 1) ^ (z << 2);
     }
 
 
@@ -3065,16 +3258,6 @@ Vector3$1.typeName = "Vector3";
  */
 Vector3$1._dot = v3_dot;
 
-/**
- * Returns lowest value out of 2 supplied
- * @param {number} a
- * @param {number} b
- * @returns {number}
- */
-function min2(a, b) {
-    return a < b ? a : b;
-}
-
 /**
  * Created by Alex on 10/03/14.
  */
@@ -3084,18 +3267,6 @@ const forward = new Vector3$1();
 const up = new Vector3$1();
 const right = new Vector3$1();
 
-/**
- * just in case you need that function also
- * @param {Vector3} axis
- * @param {number} angle
- * @param {Quaternion} result
- */
-function quat3_createFromAxisAngle(axis, angle, result) {
-    const halfAngle = angle * .5;
-    const s = Math.sin(halfAngle);
-    result.set(axis.x * s, axis.y * s, axis.z * s, Math.cos(halfAngle));
-}
-
 let Quaternion$1 = class Quaternion {
     /**
      *
@@ -4518,31 +4689,7 @@ let Quaternion$1 = class Quaternion {
      * @param {number} value
      */
     decodeFromUint32(value) {
-        //read components
-        const max = value & 0x3;
-
-        const iv0 = (value >> 2) & 0x3FF;
-        const iv1 = (value >> 12) & 0x3FF;
-        const iv2 = (value >> 22) & 0x3FF;
-
-        //scale components back to quaternion range
-        const v0 = (iv0 / 511 - 1) * K_CONST;
-        const v1 = (iv1 / 511 - 1) * K_CONST;
-        const v2 = (iv2 / 511 - 1) * K_CONST;
-
-        //restore dropped component using quaternion identity: x^2 + y^2 + z^2 + w^2 = 1
-        const dropped_2 = 1 - v0 * v0 - v1 * v1 - v2 * v2;
-        const dropped = Math.sqrt(dropped_2);
-
-        if (max === 0) {
-            this.set(dropped, v0, v1, v2);
-        } else if (max === 1) {
-            this.set(v0, dropped, v1, v2);
-        } else if (max === 2) {
-            this.set(v0, v1, dropped, v2);
-        } else {
-            this.set(v0, v1, v2, dropped);
-        }
+        quat_decode_from_uint32(this, 0, value);
     }
 
     /**
@@ -4550,107 +4697,7 @@ let Quaternion$1 = class Quaternion {
      * @returns {number}
      */
     encodeToUint32() {
-        const x = this.x;
-        const y = this.y;
-        const z = this.z;
-        const w = this.w;
-
-        const absX = Math.abs(x);
-        const absY = Math.abs(y);
-        const absZ = Math.abs(z);
-        const absW = Math.abs(w);
-
-        let max = 0;
-
-        //pick max component
-        if (absY > absX) {
-            if (absY > absZ) {
-                if (absY > absW) {
-                    //absY is max
-                    max = 1;
-                } else {
-                    //absW is max
-                    max = 3;
-                }
-            } else if (absZ > absW) {
-                //absZ is max
-                max = 2;
-            } else {
-                //absW is max
-                max = 3;
-            }
-        } else if (absX > absZ) {
-            if (absX > absW) {
-                max = 0;
-            } else {
-                max = 3;
-            }
-        } else if (absZ > absW) {
-            max = 2;
-        } else {
-            max = 3;
-        }
-
-        let v0, v1, v2, dropped;
-
-        //max will be dropped
-        if (max === 0) {
-            //dropping x
-            v0 = y;
-            v1 = z;
-            v2 = w;
-
-            dropped = x;
-        } else if (max === 1) {
-            //dropping y
-            v0 = x;
-            v1 = z;
-            v2 = w;
-
-            dropped = y;
-        } else if (max === 2) {
-            //dropping z
-            v0 = x;
-            v1 = y;
-            v2 = w;
-
-            dropped = z;
-        } else {
-            //dropping w
-            v0 = x;
-            v1 = y;
-            v2 = z;
-
-            dropped = w;
-        }
-
-        if (dropped < 0) {
-            //reconstructing dropped value is only possible if it is positive, so we invert the quaternion to make dropped value positive
-            v0 = -v0;
-            v1 = -v1;
-            v2 = -v2;
-        }
-
-        const l = Math.sqrt(x * x + y * y + z * z + w * w);
-        const m = 1 / (l * K_CONST);
-
-        //re-normalize the remaining components to 10 bit UINT value
-        const oV0 = Math.round((v0 * m + 1) * 511);
-        const oV1 = Math.round((v1 * m + 1) * 511);
-        const oV2 = Math.round((v2 * m + 1) * 511);
-
-        assert.ok(oV0 <= 1023 && oV0 >= 0, `expected 0 <= ov0 <= 1023, instead was '${oV0}'`);
-        assert.ok(oV1 <= 1023 && oV1 >= 0, `expected 0 <= ov1 <= 1023, instead was '${oV1}'`);
-        assert.ok(oV2 <= 1023 && oV2 >= 0, `expected 0 <= ov2 <= 1023, instead was '${oV2}'`);
-
-
-        const result = (max & 0x3)
-            | ((oV0 & 0x3FF) << 2)
-            | ((oV1 & 0x3FF) << 12)
-            | ((oV2 & 0x3FF) << 22)
-        ;
-
-        return result;
+        return quat_encode_to_uint32(this.x, this.y, this.z, this.w);
     }
 
     /**
@@ -4837,13 +4884,7 @@ Quaternion$1.identity = Object.freeze(new Quaternion$1(0, 0, 0, 1));
 const axis = new Vector3$1();
 
 
-const tempvec3 = new Vector3$1();
-
-/**
- * Used in UINT32 packing
- * @type {number}
- */
-const K_CONST = 0.70710678118; // 1/sqrt(2)
+const tempvec3 = new Vector3$1();
 
 /**
  * @readonly
@@ -5110,8 +5151,7 @@ class Transform {
      * @returns {boolean}
      */
     equals(other) {
-        return other.isTransform
-            && this.position.equals(other.position)
+        return this.position.equals(other.position)
             && this.rotation.equals(other.rotation)
             && this.scale.equals(other.scale);
     }
@@ -48945,11 +48985,7 @@ class Vector2 {
         const x = computeHashFloat(this.x);
         const y = computeHashFloat(this.y);
 
-        let hash = ((x << 5) - x) + y;
-
-        hash |= 0; //convert to 32bit int
-
-        return hash;
+        return ((x << 5) - x) + y;
     }
 
     /**
@@ -48960,8 +48996,11 @@ class Vector2 {
         const sin = Math.sin(angle);
         const cos = Math.cos(angle);
 
-        const x = this.x * cos - this.y * sin;
-        const y = this.x * sin + this.y * cos;
+        const _x = this.x;
+        const _y = this.y;
+
+        const x = _x * cos - _y * sin;
+        const y = _x * sin + _y * cos;
 
         this.set(x, y);
     }
@@ -56784,6 +56823,39 @@ function mortonEncode_magicbits(x, y, z) {
     return x_bits | y_bits | z_bits;
 }
 
+/**
+ * @param {number} x
+ * @param {number} y
+ * @param {number} z
+ * @param {number[]} bounds
+ * @returns {number}
+ */
+function v3_morton_encode_bounded(x, y, z, bounds) {
+
+    const bounds_x0 = bounds[0];
+    const bounds_y0 = bounds[1];
+    const bounds_z0 = bounds[2];
+
+    const bounds_x1 = bounds[3];
+    const bounds_y1 = bounds[4];
+    const bounds_z1 = bounds[5];
+
+    const bounds_span_x = bounds_x1 - bounds_x0;
+    const bounds_span_y = bounds_y1 - bounds_y0;
+    const bounds_span_z = bounds_z1 - bounds_z0;
+
+    // scale to 10 bits
+    const ndc_x = 1023 * (x - bounds_x0) / bounds_span_x;
+    const ndc_y = 1023 * (y - bounds_y0) / bounds_span_y;
+    const ndc_z = 1023 * (z - bounds_z0) / bounds_span_z;
+
+    return mortonEncode_magicbits(
+        Math.round(ndc_x),
+        Math.round(ndc_y),
+        Math.round(ndc_z)
+    );
+}
+
 /**
  * Returns highest value out of 3 supplied
  * @param {number} a
@@ -56846,10 +56918,10 @@ function copy_box_zero_size(data, destination, source) {
  * Assumes data will be normalized to 0...1 value range
  * @param {Float32Array} data
  * @param {number} address
- * @param {number[]} matrix
+ * @param {number[]} bounds
  * @returns {number}
  */
-function build_morton(data, address, matrix) {
+function build_morton(data, address, bounds) {
 
     const x0 = data[address];
     const y0 = data[address + 1];
@@ -56858,17 +56930,15 @@ function build_morton(data, address, matrix) {
     const y1 = data[address + 4];
     const z1 = data[address + 5];
 
-    const cx = (x0 + x1) / 2;
-    const cy = (y0 + y1) / 2;
-    const cz = (z0 + z1) / 2;
+    const cx = (x0 + x1) * 0.5;
+    const cy = (y0 + y1) * 0.5;
+    const cz = (z0 + z1) * 0.5;
 
-    return mortonEncode_magicbits(cx, cy, cz);
-    // return v3_morton_encode_transformed(cx, cy, cz, matrix);
+    return v3_morton_encode_bounded(cx, cy, cz, bounds);
 
 }
 
-const scratch_box_0 = new Float32Array(18);
-const stack$8 = [];
+const stack$8 = SCRATCH_UINT32_TRAVERSAL_STACK;
 
 class BinaryUint32BVH {
     /**
@@ -56892,34 +56962,41 @@ class BinaryUint32BVH {
      */
     __data_uint32;
 
-    constructor() {
-
-        /**
-         *
-         * @type {number}
-         * @private
-         */
-        this.__node_count_binary = 0;
+    /**
+     *
+     * @type {number}
+     * @private
+     */
+    __node_count_binary = 0;
 
-        /**
-         *
-         * @type {number}
-         * @private
-         */
-        this.__node_count_leaf = 0;
+    /**
+     *
+     * @type {number}
+     * @private
+     */
+    __node_count_leaf = 0;
 
+    constructor() {
         this.data = new ArrayBuffer(320);
     }
 
+    /**
+     * In bytes
+     * @returns {number}
+     */
+    estimateByteSize() {
+        return this.data.byteLength + 248;
+    }
+
     getTotalBoxCount() {
         return this.__node_count_binary + this.__node_count_leaf;
     }
 
-    getBinaryNodeCount() {
+    get binary_node_count() {
         return this.__node_count_binary;
     }
 
-    getLeafNodeCount() {
+    get leaf_node_count() {
         return this.__node_count_leaf;
     }
 
@@ -56941,10 +57018,12 @@ class BinaryUint32BVH {
 
     /**
      *
-     * @param {ArrayBuffer} v
+     * @param {ArrayBuffer} buffer
      */
-    set data(v) {
-        this.__data_buffer = v;
+    set data(buffer) {
+        assert.defined(buffer, 'buffer');
+
+        this.__data_buffer = buffer;
 
         this.__data_float32 = new Float32Array(this.__data_buffer);
         this.__data_uint32 = new Uint32Array(this.__data_buffer);
@@ -56954,6 +57033,24 @@ class BinaryUint32BVH {
         return this.__data_buffer;
     }
 
+    /**
+     * Resolve index of the node to address where the node data starts, this is required to know where AABB is stored in memory
+     * @param {number} node_index
+     * @returns {number}
+     */
+    getNodeAddress(node_index) {
+        const binary_node_count = this.__node_count_binary;
+        const leaf_node_index = node_index - binary_node_count;
+
+        if (leaf_node_index < 0) {
+            // binary node
+            return node_index * BVH_BINARY_NODE_SIZE;
+        } else {
+            // leaf node
+            return binary_node_count * BVH_BINARY_NODE_SIZE + leaf_node_index * BVH_LEAF_NODE_SIZE;
+        }
+    }
+
     initialize_structure() {
         // compute memory requirements
         const word_count = this.__node_count_binary * BVH_BINARY_NODE_SIZE + this.__node_count_leaf * BVH_LEAF_NODE_SIZE;
@@ -57072,17 +57169,15 @@ class BinaryUint32BVH {
      * @private
      */
     __compute_bounds_area_of_3_boxes(a, b, c) {
-        this.readBounds(a, scratch_box_0, 0);
-        this.readBounds(b, scratch_box_0, 6);
-        this.readBounds(c, scratch_box_0, 12);
+        const float32 = this.__data_float32;
 
-        const x0 = min3(scratch_box_0[0], scratch_box_0[6], scratch_box_0[12]);
-        const y0 = min3(scratch_box_0[1], scratch_box_0[7], scratch_box_0[13]);
-        const z0 = min3(scratch_box_0[2], scratch_box_0[8], scratch_box_0[14]);
+        const x0 = min3(float32[a + 0], float32[b + 0], float32[c + 0]);
+        const y0 = min3(float32[a + 1], float32[b + 1], float32[c + 1]);
+        const z0 = min3(float32[a + 2], float32[b + 2], float32[c + 2]);
 
-        const x1 = max3(scratch_box_0[3], scratch_box_0[9], scratch_box_0[15]);
-        const y1 = max3(scratch_box_0[4], scratch_box_0[10], scratch_box_0[16]);
-        const z1 = max3(scratch_box_0[5], scratch_box_0[11], scratch_box_0[17]);
+        const x1 = max3(float32[a + 3], float32[b + 3], float32[c + 3]);
+        const y1 = max3(float32[a + 4], float32[b + 4], float32[c + 4]);
+        const z1 = max3(float32[a + 5], float32[b + 5], float32[c + 5]);
 
         return aabb3_compute_half_surface_area(x0, y0, z0, x1, y1, z1);
     }
@@ -57134,9 +57229,9 @@ class BinaryUint32BVH {
 
     /**
      * Sort leaf nodes according to their morton codes
-     * @param {number[]} projection
+     * @param {number[]} bounds
      */
-    sort_morton(projection) {
+    sort_morton(bounds) {
 
         const leaf_block_address = this.__node_count_binary * BVH_BINARY_NODE_SIZE;
 
@@ -57166,15 +57261,15 @@ class BinaryUint32BVH {
 
             const pivot_address = pivotIndex * BVH_LEAF_NODE_SIZE + leaf_block_address;
 
-            const pivot = build_morton(data, pivot_address);
+            const pivot = build_morton(data, pivot_address, bounds);
 
             /* partition */
             while (i <= j) {
-                while (build_morton(data, i * BVH_LEAF_NODE_SIZE + leaf_block_address) < pivot) {
+                while (build_morton(data, i * BVH_LEAF_NODE_SIZE + leaf_block_address, bounds) < pivot) {
                     i++;
                 }
 
-                while (build_morton(data, j * BVH_LEAF_NODE_SIZE + leaf_block_address) > pivot) {
+                while (build_morton(data, j * BVH_LEAF_NODE_SIZE + leaf_block_address, bounds) > pivot) {
                     j--;
                 }
 
@@ -57244,22 +57339,22 @@ class BinaryUint32BVH {
 
         // build bottom-most level, just above the leaves
         for (i = 0; i < level_node_count; i++) {
-            const leafIndex0 = i * 2;
-            const leafIndex1 = leafIndex0 + 1;
+            const leaf_index_0 = i * 2;
+            const leaf_index_1 = leaf_index_0 + 1;
 
-            const leafOffset0 = leaf_node_block_address + leafIndex0 * BVH_LEAF_NODE_SIZE;
-            const leafOffset1 = leaf_node_block_address + leafIndex1 * BVH_LEAF_NODE_SIZE;
+            const leaf_offset_0 = leaf_node_block_address + leaf_index_0 * BVH_LEAF_NODE_SIZE;
+            const leaf_offset_1 = leaf_node_block_address + leaf_index_1 * BVH_LEAF_NODE_SIZE;
 
-            if (leafIndex1 < node_count_leaf) {
+            if (leaf_index_1 < node_count_leaf) {
                 // both children nodes are valid
                 aabb3_array_combine(
                     float32, offset,
-                    float32, leafOffset0,
-                    float32, leafOffset1
+                    float32, leaf_offset_0,
+                    float32, leaf_offset_1
                 );
-            } else if (leafIndex0 < node_count_leaf) {
+            } else if (leaf_index_0 < node_count_leaf) {
                 // only left child node is valid
-                array_copy(float32, leafOffset0, float32, offset, 6);
+                array_copy(float32, leaf_offset_0, float32, offset, 6);
             } else {
                 //initialize to 0-size box same position as previous node
                 copy_box_zero_size(this.__data_float32, offset, (offset - BVH_BINARY_NODE_SIZE));
@@ -57299,127 +57394,6 @@ class BinaryUint32BVH {
 
 //
 
-/**
- *
- * @param {ArrayLike<number>|number[]|Float32Array} aabb bounding box, order: x0,y0,z0,x1,y1,z1
- * @param {number} aabb_offset
- * @param {number} origin_x
- * @param {number} origin_y
- * @param {number} origin_z
- * @param {number} direction_x
- * @param {number} direction_y
- * @param {number} direction_z
- */
-function aabb3_array_intersects_ray(
-    aabb, aabb_offset,
-    origin_x, origin_y, origin_z,
-    direction_x, direction_y, direction_z
-) {
-    return aabb3_intersects_ray(
-        aabb[aabb_offset], aabb[aabb_offset+1], aabb[aabb_offset+2],
-        aabb[aabb_offset+3], aabb[aabb_offset+4], aabb[aabb_offset+5],
-        origin_x, origin_y, origin_z,
-        direction_x, direction_y, direction_z
-    );
-}
-
-const stack$7 = SCRATCH_UINT32_TRAVERSAL_STACK;
-
-/**
- *
- * @param {BinaryUint32BVH} bvh
- * @param {number[]} result
- * @param {number} result_offset
- * @param {number} origin_x
- * @param {number} origin_y
- * @param {number} origin_z
- * @param {number} direction_x
- * @param {number} direction_y
- * @param {number} direction_z
- * @returns {number}
- */
-function bvh32_query_user_data_ray(
-    bvh,
-    result, result_offset,
-    origin_x, origin_y, origin_z,
-    direction_x, direction_y, direction_z
-) {
-    let hit_count = 0;
-
-    const binary_node_count = bvh.getBinaryNodeCount();
-
-    if (binary_node_count <= 0) {
-        // this should not happen
-        return 0;
-    }
-
-    /**
-     *
-     * @type {number}
-     */
-    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$7[stack_top] = 0;
-
-    const last_valid_index = binary_node_count + bvh.getLeafNodeCount();
-
-    const float32 = bvh.float32;
-    const uint32 = bvh.uint32;
-
-    do {
-        stack$7.pointer--;
-
-        // query_bvh_frustum_from_objects.iteration_count++;
-        const node_index = stack$7[stack$7.pointer];
-
-        if (node_index < binary_node_count) {
-            // is intermediate node
-            const node_address = node_index * BVH_BINARY_NODE_SIZE;
-
-            if (!aabb3_array_intersects_ray(
-                float32, node_address,
-                origin_x, origin_y, origin_z,
-                direction_x, direction_y, direction_z
-            )) {
-                continue;
-            }
-
-            const left_index = (node_index << 1) + 1;
-            const right_index = left_index + 1;
-
-            // left node ends up on top of the stack, which aligns with the desired access sequence
-            if (right_index < last_valid_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$7[stack$7.pointer++] = left_index;
-            } else if (left_index < last_valid_index) {
-                stack$7[stack$7.pointer++] = left_index;
-            }
-
-
-        } else {
-            // leaf node
-            const leaf_index = node_index - binary_node_count;
-
-            const node_address = leaf_index * BVH_LEAF_NODE_SIZE + binary_node_count * BVH_BINARY_NODE_SIZE;
-
-            // write to output
-            result[result_offset + hit_count] = uint32[node_address + 6];
-
-            hit_count++;
-        }
-
-    } while (stack$7.pointer > stack_top)
-
-    return hit_count;
-}
-
-//
-
 /**
  *
  * @param {ArrayLike<number>|number[]|AABB3} aabb
@@ -57598,23 +57572,37 @@ function aabb3_compute_plane_side(
 }
 
 /**
- *
+ * Tests whether AABB intersects a clipping volume defined by a set of planes
+ * Mainly useful for frustum checks
  * @param {number} x0
  * @param {number} y0
  * @param {number} z0
  * @param {number} x1
  * @param {number} y1
  * @param {number} z1
- * @param {ArrayLike<number>|number[]|Float32Array|Float64Array} frustum
+ * @param {ArrayLike<number>|number[]|Float32Array|Float64Array} planes
+ * @param {number} planes_offset
+ * @param {number} plane_count
  * @return {boolean}
  */
-function aabb3_intersects_frustum_array(x0, y0, z0, x1, y1, z1, frustum) {
-    for (let i = 0; i < 24; i += 4) {
+function aabb3_intersects_clipping_volume_array(
+    x0, y0, z0,
+    x1, y1, z1,
+    planes, planes_offset, plane_count
+) {
+
+    assert.isNonNegativeInteger(planes_offset, 'frustum_offset');
+
+    const limit = plane_count * 4;
+
+    for (let i = 0; i < limit; i += 4) {
+
+        const offset = planes_offset + i;
 
-        const plane_x = frustum[i];
-        const plane_y = frustum[i + 1];
-        const plane_z = frustum[i + 2];
-        const plane_w = frustum[i + 3];
+        const plane_x = planes[offset];
+        const plane_y = planes[offset + 1];
+        const plane_z = planes[offset + 2];
+        const plane_w = planes[offset + 3];
 
         const plane_distance = aabb3_compute_distance_above_plane_max(
             plane_x, plane_y, plane_z, plane_w,
@@ -57629,6 +57617,7 @@ function aabb3_intersects_frustum_array(x0, y0, z0, x1, y1, z1, frustum) {
     }
 
     return true;
+
 }
 
 //
@@ -58708,7 +58697,7 @@ class AABB3 {
         const y1 = this.y1;
         const z1 = this.z1;
 
-        return aabb3_intersects_frustum_array(x0, y0, z0, x1, y1, z1, frustum);
+        return aabb3_intersects_clipping_volume_array(x0, y0, z0, x1, y1, z1, frustum, 0, 6);
     }
 
     /**
@@ -58843,6 +58832,127 @@ function ray3_array_compose(output, origin_x, origin_y, origin_z, direction_x, d
     output[5] = direction_z;
 }
 
+//
+
+/**
+ *
+ * @param {ArrayLike<number>|number[]|Float32Array} aabb bounding box, order: x0,y0,z0,x1,y1,z1
+ * @param {number} aabb_offset
+ * @param {number} origin_x
+ * @param {number} origin_y
+ * @param {number} origin_z
+ * @param {number} direction_x
+ * @param {number} direction_y
+ * @param {number} direction_z
+ */
+function aabb3_array_intersects_ray(
+    aabb, aabb_offset,
+    origin_x, origin_y, origin_z,
+    direction_x, direction_y, direction_z
+) {
+    return aabb3_intersects_ray(
+        aabb[aabb_offset], aabb[aabb_offset+1], aabb[aabb_offset+2],
+        aabb[aabb_offset+3], aabb[aabb_offset+4], aabb[aabb_offset+5],
+        origin_x, origin_y, origin_z,
+        direction_x, direction_y, direction_z
+    );
+}
+
+const stack$7 = SCRATCH_UINT32_TRAVERSAL_STACK;
+
+/**
+ *
+ * @param {number[]} result
+ * @param {number} result_offset
+ * @param {BinaryUint32BVH} bvh
+ * @param {number} origin_x
+ * @param {number} origin_y
+ * @param {number} origin_z
+ * @param {number} direction_x
+ * @param {number} direction_y
+ * @param {number} direction_z
+ * @returns {number}
+ */
+function bvh32_query_user_data_ray(
+    result, result_offset,
+    bvh,
+    origin_x, origin_y, origin_z,
+    direction_x, direction_y, direction_z
+) {
+    let hit_count = 0;
+
+    const binary_node_count = bvh.binary_node_count;
+
+    if (binary_node_count <= 0) {
+        // this should not happen
+        return 0;
+    }
+
+    /**
+     *
+     * @type {number}
+     */
+    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$7[stack_top] = 0;
+
+    const last_valid_index = binary_node_count + bvh.leaf_node_count;
+
+    const float32 = bvh.float32;
+    const uint32 = bvh.uint32;
+
+    do {
+        stack$7.pointer--;
+
+        // query_bvh_frustum_from_objects.iteration_count++;
+        const node_index = stack$7[stack$7.pointer];
+
+        const node_address = bvh.getNodeAddress(node_index);
+
+        if (!aabb3_array_intersects_ray(
+            float32, node_address,
+            origin_x, origin_y, origin_z,
+            direction_x, direction_y, direction_z
+        )) {
+            continue;
+        }
+
+        const is_intermediate_node = node_index < binary_node_count;
+
+        if (is_intermediate_node) {
+            // is intermediate node
+
+            const left_index = (node_index << 1) + 1;
+            const right_index = left_index + 1;
+
+            // left node ends up on top of the stack, which aligns with the desired access sequence
+            if (right_index < last_valid_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$7[stack$7.pointer++] = left_index;
+            } else if (left_index < last_valid_index) {
+                stack$7[stack$7.pointer++] = left_index;
+            }
+
+
+        } else {
+            // leaf node
+
+            // write to output
+            result[result_offset + hit_count] = uint32[node_address + 6];
+
+            hit_count++;
+        }
+
+    } while (stack$7.pointer > stack_top)
+
+    return hit_count;
+}
+
 /**
  * NOTE: adapted from http://www.geometrictools.com/GTEngine/Include/Mathematics/GteIntrRay3Triangle3.h
  * @source https://en.wikipedia.org/wiki/M%C3%B6ller%E2%80%93Trumbore_intersection_algorithm (Möller and Trumbore, « Fast, Minimum Storage Ray-Triangle Intersection », Journal of Graphics Tools, vol. 2,‎ 1997, p. 21–28)
@@ -59000,6 +59110,110 @@ function computeTriangleRayIntersection(
     return true;
 }
 
+const scratch_array$4 = [];
+const scratch_hit = new SurfacePoint3();
+
+/**
+ *
+ * @param {SurfacePoint3} result
+ * @param {BinaryUint32BVH} bvh
+ * @param {number[]|ArrayLike<number>} vertices
+ * @param {number} vertex_offset Unless you're using an interleaved buffer of some kind, this will be 0
+ * @param {number} vertex_stride Unless you're using an interleaved buffer, this should be 3
+ * @param {number[]|ArrayLike<number>|undefined} indices if this is set to undefined - implicit indexing will be used
+ * @param {number} originX
+ * @param {number} originY
+ * @param {number} originZ
+ * @param {number} directionX
+ * @param {number} directionY
+ * @param {number} directionZ
+ * @returns {boolean}
+ */
+function bvh32_geometry_raycast(
+    result,
+    bvh,
+    vertices, vertex_offset, vertex_stride,
+    indices,
+    originX, originY, originZ,
+    directionX, directionY, directionZ
+) {
+    let hit_found = false;
+
+    const hit_count = bvh32_query_user_data_ray(
+        scratch_array$4, 0,
+        bvh,
+        originX, originY, originZ,
+        directionX, directionY, directionZ
+    );
+
+    let best_distance = Infinity;
+
+    let a, b, c;
+
+    for (let i = 0; i < hit_count; i++) {
+        const triangle_index = scratch_array$4[i];
+
+        const index3 = triangle_index * 3;
+
+        if (indices !== undefined) {
+            assert.lessThan(index3 + 2, indices.length, 'triangle index overflow, possibly geometry changed but tree was not rebuilt?');
+
+            a = indices[index3];
+            b = indices[index3 + 1];
+            c = indices[index3 + 2];
+        } else {
+            // implicit indices
+            a = index3;
+            b = index3 + 1;
+            c = index3 + 2;
+        }
+
+        const a_address = a * vertex_stride + vertex_offset;
+        const b_address = b * vertex_stride + vertex_offset;
+        const c_address = c * vertex_stride + vertex_offset;
+
+        assert.lessThan(a_address + 2, vertices.length, 'a-vertex overflow');
+        assert.lessThan(b_address + 2, vertices.length, 'b-vertex overflow');
+        assert.lessThan(c_address + 2, vertices.length, 'c-vertex overflow');
+
+        const ax = vertices[a_address];
+        const ay = vertices[a_address + 1];
+        const az = vertices[a_address + 2];
+
+        const bx = vertices[b_address];
+        const by = vertices[b_address + 1];
+        const bz = vertices[b_address + 2];
+
+        const cx = vertices[c_address];
+        const cy = vertices[c_address + 1];
+        const cz = vertices[c_address + 2];
+
+        const triangle_hit_found = computeTriangleRayIntersection(
+            scratch_hit,
+            originX, originY, originZ,
+            directionX, directionY, directionZ,
+            ax, ay, az,
+            bx, by, bz,
+            cx, cy, cz
+        );
+
+        if (!triangle_hit_found) {
+            continue;
+        }
+
+        hit_found = true;
+
+        const distance_sqr = scratch_hit.position._distanceSqrTo(originX, originY, originZ);
+
+        if (distance_sqr < best_distance) {
+            best_distance = distance_sqr;
+            result.copy(scratch_hit);
+        }
+    }
+
+    return hit_found;
+}
+
 /**
  * Created by Alex on 28/01/2017.
  */
@@ -59081,9 +59295,6 @@ var ThreeFactory = {
 const EMPTY_GEOMETRY = new BufferGeometry();
 const DEFAULT_MATERIAL = new MeshBasicMaterial();
 
-const scratch_array$3 = [];
-const scratch_hit = new SurfacePoint3();
-
 const ray_tmp = [];
 const m4_tmp = [];
 
@@ -59239,52 +59450,19 @@ class TerrainTile {
         const _directionY = ray_tmp[4];
         const _directionZ = ray_tmp[5];
 
-        const hit_count = bvh32_query_user_data_ray(
-            this.bvh,
-            scratch_array$3, 0,
-            _originX, _originY, _originZ,
-            _directionX, _directionY, _directionZ
-        );
-
-        let best_distance = Infinity;
-        let hit_found = false;
-
         const geometry = this.geometry;
 
         const geometryIndices = geometry.getIndex().array;
         const geometryPositions = geometry.getAttribute('position').array;
 
-        for (let i = 0; i < hit_count; i++) {
-            const triangle_index = scratch_array$3[i];
-
-            const index3 = triangle_index * 3;
-
-            const a = geometryIndices[index3] * 3;
-            const b = geometryIndices[index3 + 1] * 3;
-            const c = geometryIndices[index3 + 2] * 3;
-
-            const triangle_hit_found = computeTriangleRayIntersection(
-                scratch_hit,
-                _originX, _originY, _originZ,
-                _directionX, _directionY, _directionZ,
-                geometryPositions[a], geometryPositions[a + 1], geometryPositions[a + 2],
-                geometryPositions[b], geometryPositions[b + 1], geometryPositions[b + 2],
-                geometryPositions[c], geometryPositions[c + 1], geometryPositions[c + 2],
-            );
-
-            if (!triangle_hit_found) {
-                continue;
-            }
-
-            hit_found = true;
-
-            const distance_sqr = scratch_hit.position._distanceSqrTo(_originX, _originY, _originZ);
-
-            if (distance_sqr < best_distance) {
-                best_distance = distance_sqr;
-                result.copy(scratch_hit);
-            }
-        }
+        let hit_found = bvh32_geometry_raycast(
+            result,
+            this.bvh,
+            geometryPositions, 0, 3,
+            geometryIndices,
+            _originX, _originY, _originZ,
+            _directionX, _directionY, _directionZ
+        );
 
         if (hit_found) {
             result.applyMatrix4(m4);
@@ -59706,7 +59884,7 @@ class TerrainTile {
  *
  * @type {number[]}
  */
-const scratch_array$2 = [];
+const scratch_array$3 = [];
 const scratch_contact = new SurfacePoint3();
 
 class TerrainTileManager {
@@ -60282,7 +60460,7 @@ class TerrainTileManager {
         const hit_count = bvh_query_leaves_ray(
             this.bvh,
             this.bvh.root,
-            scratch_array$2, 0,
+            scratch_array$3, 0,
             originX, originY, originZ,
             directionX, directionY, directionZ
         );
@@ -60291,7 +60469,7 @@ class TerrainTileManager {
         let hit_found = false;
 
         for (let i = 0; i < hit_count; i++) {
-            const node_id = scratch_array$2[i];
+            const node_id = scratch_array$3[i];
 
             const tile_index = this.bvh.node_get_user_data(node_id);
 
@@ -65199,7 +65377,7 @@ function makeTerrainWorkerProxy() {
                     resolve({
                         geometry: geometry,
                         bvh: {
-                            leaf_count: bvh.getLeafNodeCount(),
+                            leaf_count: bvh.leaf_node_count,
                             data: bvh.data
                         }
                     });
@@ -67183,598 +67361,283 @@ function aabb3_from_threejs_geometry(result, geometry) {
     aabb3_from_min_max(result, min, max);
 }
 
-class IndexedBinaryBVHVisitor {
-    /**
-     *
-     * @param {number} address
-     * @param {NodeType} type
-     * @returns {boolean}
-     */
-    visit(address, type) {
-
-    }
-}
-
 /**
  *
- * @enum {number}
+ * @param {Plane[]} planes
+ * @param {ArrayLike<number>|number[]|Float32Array|Float64Array} array
  */
-const NodeType = {
-    LEAF: 0,
-    BINARY: 1
-};
-
-class RayLeafIntersectionVisitor extends IndexedBinaryBVHVisitor {
-    constructor() {
-        super();
-        this.callback = noop;
-        this.callbackThisArg = null;
-
-        this.originX = 0;
-        this.originY = 0;
-        this.originZ = 0;
+function read_three_planes_to_array(planes, array) {
+    const plane_count = planes.length;
 
-        this.directionX = 0;
-        this.directionY = 0;
-        this.directionZ = 0;
+    assert.greaterThanOrEqual(array.length, plane_count * 4, 'target array is too small');
 
-        /**
-         *
-         * @type {IndexedBinaryBVH}
-         */
-        this.root = null;
-    }
-
-    visit(address, type) {
-        const root = this.root;
-
-        const data = root.data;
-        const binaryNodeCount = root.binaryNodeCount;
-
-        const x0 = data[address];
-        const y0 = data[address + 1];
-        const z0 = data[address + 2];
-        const x1 = data[address + 3];
-        const y1 = data[address + 4];
-        const z1 = data[address + 5];
-
-        const intersectionFound = aabb3_intersects_ray(x0, y0, z0, x1, y1, z1,
-            this.originX, this.originY, this.originZ,
-            this.directionX, this.directionY, this.directionZ
-        );
+    for (let i = 0; i < plane_count; i++) {
+        const plane = planes[i];
 
-        if (!intersectionFound) {
-            return false;
-        }
+        const offset = i * 4;
 
-        if (type === NodeType.LEAF) {
-            const value = address / 6 - binaryNodeCount;
+        const normal = plane.normal;
 
-            this.callback.call(this.callbackThisArg, value, address, type);
+        array[offset] = normal.x;
+        array[offset + 1] = normal.y;
+        array[offset + 2] = normal.z;
 
-            return false;
-        } else {
-            return true;
-        }
+        array[offset + 3] = plane.constant;
     }
 }
 
-/**
- * Created by Alex on 29/05/2016.
- */
-
-
 /**
  *
- * @type {Float32Array|number[]}
+ * @param {BinaryUint32BVH} bvh
+ * @param {number} triangle_index
+ * @param {number[]|Float32Array} vertices
+ * @param {number} a_index
+ * @param {number} b_index
+ * @param {number} c_index
  */
-const scratch_aabb_0 = new Float32Array(6);
-
-
-class IndexedBinaryBVH {
-    /**
-     *
-     * @constructor
-     */
-    constructor() {
-        /**
-         *
-         * @type {number}
-         */
-        this.leafNodeCount = 0;
-
-        /**
-         *
-         * @type {number}
-         */
-        this.binaryNodeCount = 0;
-
-        /**
-         * Total number of boxes contained in the tree, some might be unused
-         * @type {number}
-         */
-        this.boxCount = 0;
-
-        /**
-         *
-         * @type {Float32Array|number[]}
-         */
-        this.data = new Float32Array(16);
-    }
-
-    /**
-     *
-     * @returns {number}
-     */
-    estimateByteSize(){
-        return this.data.buffer.byteLength + 248;
-    }
-
-    /**
-     *
-     * @param {int} leafCount
-     */
-    initialize(leafCount) {
-
-        const twoLog = Math.log(leafCount) / Math.log(2);
-
-        const twoLeafLimit = Math.pow(2, Math.ceil(twoLog));
-        const binaryNodeCount = twoLeafLimit - 1;
-
-        this.leafNodeCount = leafCount;
-
-        this.binaryNodeCount = binaryNodeCount;
-
-        this.boxCount = this.leafNodeCount + this.binaryNodeCount;
-
-        // possibly resize the storage
-        const storage_size = this.boxCount * 6;
-
-        if (this.data.length < storage_size) {
-            this.data = new Float32Array(storage_size);
-        } else {
-            this.data.fill(0);
-        }
-    }
-
-    unsortedBuiltIntermediate() {
-        const data = this.data;
-
-        const nodeCount = this.binaryNodeCount;
-
-        const leafNodesOffset = this.binaryNodeCount * 6;
-
-        let level = Math.floor(Math.log(nodeCount) / Math.log(2));
-
-        let i, offset, levelNodeCount;
-        //NOTE: building first level separately allows to avoid some switching logic needed to determine what is the type of lower level node
-        //build one level above leaf nodes
-        levelNodeCount = Math.pow(2, level);
-        offset = (levelNodeCount - 1) * 6;
-
-        let parentIndex, childIndex0, childIndex1;
-
-        for (i = 0; i < levelNodeCount; i++) {
-            const leafIndex0 = i * 2;
-            const leafIndex1 = leafIndex0 + 1;
-
-            const leafOffset0 = leafNodesOffset + leafIndex0 * 6;
-            const leafOffset1 = leafNodesOffset + leafIndex1 * 6;
-
-            if (leafIndex1 < this.leafNodeCount) {
-                binaryNodeRefit(data, offset, leafOffset0, leafOffset1);
-            } else if (leafIndex0 < this.leafNodeCount) {
-                copyBox(leafOffset0, offset, data);
-            } else {
-                //initialize to 0-size box same position as previous node
-                copyBoxZeroSize(offset - 6, offset, data);
-            }
-
-            offset += 6;
-        }
-
-        level--;
-
-        //build intermediate nodes
-        for (; level >= 0; level--) {
-            levelNodeCount = Math.pow(2, level);
-            parentIndex = (levelNodeCount - 1);
-
-            for (i = 0; i < levelNodeCount; i++) {
-
-                childIndex0 = (parentIndex << 1) + 1;
-                childIndex1 = childIndex0 + 1;
-
-                binaryNodeRefit(data, parentIndex * 6, childIndex0 * 6, childIndex1 * 6);
-
-                parentIndex++;
-            }
-        }
-
-        //set bounds of the bvh
-        array_copy(data, 0, scratch_aabb_0, 0, 6);
-
-        this.x0 = scratch_aabb_0[0];
-        this.y0 = scratch_aabb_0[1];
-        this.z0 = scratch_aabb_0[2];
-        this.x1 = scratch_aabb_0[3];
-        this.y1 = scratch_aabb_0[4];
-        this.z1 = scratch_aabb_0[5];
-    }
-
-    /**
-     * Sets bounds of a given leaf
-     * NOTE: to build tree, must call {@link #unsortedBuiltIntermediate} after all leaves are set
-     * @param {number} leaf_index
-     * @param {number} x0
-     * @param {number} y0
-     * @param {number} z0
-     * @param {number} x1
-     * @param {number} y1
-     * @param {number} z1
-     */
-    writeLeaf(leaf_index, x0, y0, z0, x1, y1, z1) {
-        const offset = this.binaryNodeCount * 6 + leaf_index * 6;
-        writeBox(this.data, offset, x0, y0, z0, x1, y1, z1);
-    }
-
-    /**
-     * @template T
-     * @deprecated use {@link #writeLeaf} instead followed by {@link #unsortedBuiltIntermediate}
-     * @param {function(index:number,offset:number,data:T, writeBox:function):void} visitor
-     */
-    setLeafs(visitor) {
-        let offset = this.binaryNodeCount * 6;
-
-        const data = this.data;
+function bvh32_set_leaf_from_triangle(bvh, triangle_index, vertices, a_index, b_index, c_index) {
+    const a = a_index * 3;
+    const b = b_index * 3;
+    const c = c_index * 3;
 
-        let i = 0;
-        const l = this.leafNodeCount;
-        for (; i < l; i++) {
-            visitor(i, offset, data, writeBox);
+    // read actual positions of each vertex
+    const aX = vertices[a];
+    const aY = vertices[a + 1];
+    const aZ = vertices[a + 2];
 
-            offset += 6;
-        }
-        this.unsortedBuiltIntermediate();
-    }
+    const bX = vertices[b];
+    const bY = vertices[b + 1];
+    const bZ = vertices[b + 2];
 
-    /**
-     *
-     * @param {IndexedBinaryBVHVisitor} visitor
-     * @param {Number} startIndex
-     */
-    traversePreOrderStack(visitor, startIndex) {
+    const cX = vertices[c];
+    const cY = vertices[c + 1];
+    const cZ = vertices[c + 2];
 
-        const stackOffset = stackPointer;
+    // compute bounds of the triangle
+    const x0 = min3(aX, bX, cX);
+    const y0 = min3(aY, bY, cY);
+    const z0 = min3(aZ, bZ, cZ);
 
-        stack$6[stackPointer++] = startIndex;
+    const x1 = max3(aX, bX, cX);
+    const y1 = max3(aY, bY, cY);
+    const z1 = max3(aZ, bZ, cZ);
 
-        const nodeThreshold = this.binaryNodeCount * 6;
-        const endAddress = this.boxCount * 6;
-
-        while (stackPointer-- > stackOffset) {
-
-            const index = stack$6[stackPointer];
-
-            const address = index * 6;
+    bvh.setLeafData(triangle_index, triangle_index, x0, y0, z0, x1, y1, z1);
+}
+
+/**
+ *
+ * @param {BinaryUint32BVH} bvh
+ * @param {Float32Array} vertices
+ * @param {Uint32Array} indices
+ */
+function bvh32_from_indexed_geometry(bvh, vertices, indices) {
 
-            const split = visitor.visit(address, NodeType.BINARY);
-            if (split) {
+    const triangle_count = indices.length / 3;
 
-                const leftIndex = (index << 1) + 1;
-                const rightIndex = leftIndex + 1;
+    bvh.setLeafCount(triangle_count);
+    bvh.initialize_structure();
 
-                const leftAddress = leftIndex * 6;
-                const rightAddress = rightIndex * 6;
+    for (let i = 0; i < triangle_count; i++) {
 
-                //right
-                if (rightAddress < endAddress) {
-                    if (rightAddress < nodeThreshold) {
-                        stack$6[stackPointer++] = rightIndex;
-                    } else {
-                        visitor.visit(rightAddress, NodeType.LEAF);
-                    }
-                }
+        const index3 = i * 3;
 
-                //left
-                if (leftAddress < endAddress) {
-                    if (leftAddress < nodeThreshold) {
-                        stack$6[stackPointer++] = leftIndex;
-                    } else {
-                        visitor.visit(leftAddress, NodeType.LEAF);
-                    }
-                }
-            }
-        }
+        // read triangle vertex indices
+        const iA = indices[index3];
+        const iB = indices[index3 + 1];
+        const iC = indices[index3 + 2];
 
-        //drop stack
-        stackPointer = stackOffset;
+        bvh32_set_leaf_from_triangle(bvh, i, vertices, iA, iB, iC);
     }
 
-    /**
-     *
-     * @param {function} visitor
-     * @param {number} index
-     * @param {number} type
-     */
-    traversePreOrder(visitor, index, type) {
-        const address = index * 6;
-        const carryOn = visitor(address, type);
-        const nodeThreshold = this.binaryNodeCount * 6;
-        const endAddress = this.boxCount * 6;
-
-        if (carryOn !== false) {
+    // finalize build
+    // bvh.sort_morton(MATRIX_4_IDENTITY);
+    bvh.build();
+}
+
+/**
+ *
+ * @param {BinaryUint32BVH} bvh
+ * @param {Float32Array} vertices
+ */
+function bvh32_from_unindexed_geometry(bvh, vertices) {
 
-            const leftIndex = (index << 1) + 1;
-            const rightIndex = leftIndex + 1;
+    const triangle_count = indices.length / 3;
 
-            const leftAddress = leftIndex * 6;
-            const rightAddress = rightIndex * 6;
-            //left
-            if (leftAddress < endAddress) {
-                if (leftAddress < nodeThreshold) {
-                    this.traversePreOrder(visitor, leftIndex, NodeType.BINARY);
-                } else {
-                    visitor(leftAddress, NodeType.LEAF);
-                }
-            }
-            //right
-            if (rightAddress < endAddress) {
-                if (rightAddress < nodeThreshold) {
-                    this.traversePreOrder(visitor, rightIndex, NodeType.BINARY);
-                } else {
-                    visitor(rightAddress, NodeType.LEAF);
-                }
-            }
-        }
-    }
+    bvh.setLeafCount(triangle_count);
+    bvh.initialize_structure();
 
-    /**
-     * @deprecated use a visitor object instead
-     * @param {number} startX
-     * @param {number} startY
-     * @param {number} startZ
-     * @param {number} directionX
-     * @param {number} directionY
-     * @param {number} directionZ
-     * @param {function} visitor
-     * @param {*} [thisArg]
-     */
-    traverseRayLeafIntersections(startX, startY, startZ, directionX, directionY, directionZ, visitor, thisArg) {
-        rayLeafIntersectionVisitor.originX = startX;
-        rayLeafIntersectionVisitor.originY = startY;
-        rayLeafIntersectionVisitor.originZ = startZ;
+    for (let i = 0; i < triangle_count; i++) {
 
-        rayLeafIntersectionVisitor.directionX = directionX;
-        rayLeafIntersectionVisitor.directionY = directionY;
-        rayLeafIntersectionVisitor.directionZ = directionZ;
+        const index3 = i * 3;
 
-        rayLeafIntersectionVisitor.root = this;
-        rayLeafIntersectionVisitor.callback = visitor;
-        rayLeafIntersectionVisitor.callbackThisArg = thisArg;
+        // generate triangle vertex indices
+        const iA = index3;
+        const iB = index3 + 1;
+        const iC = index3 + 2;
 
-        this.traversePreOrderStack(rayLeafIntersectionVisitor, 0);
+        bvh32_set_leaf_from_triangle(bvh, i, vertices, iA, iB, iC);
     }
-}
 
+    // finalize build
+    // bvh.sort_morton(MATRIX_4_IDENTITY);
+    bvh.build();
+}
+
 /**
  *
- * @param {number[]|Float32Array} source
- * @param {number} source_address_0
- * @param {number} source_address_1
- * @param {number[]|Float32Array} destination
- * @param {number} destination_offset
+ * @param {THREE.InterleavedBufferAttribute|THREE.BufferAttribute} source_attribute
+ * @returns {THREE.BufferAttribute}
  */
-function contain_box_array(source, source_address_0, source_address_1, destination, destination_offset) {
-
-    const ax0 = source[source_address_0];
-    const ay0 = source[source_address_0 + 1];
-    const az0 = source[source_address_0 + 2];
-    const ax1 = source[source_address_0 + 3];
-    const ay1 = source[source_address_0 + 4];
-    const az1 = source[source_address_0 + 5];
-
-    const bx0 = source[source_address_1];
-    const by0 = source[source_address_1 + 1];
-    const bz0 = source[source_address_1 + 2];
-    const bx1 = source[source_address_1 + 3];
-    const by1 = source[source_address_1 + 4];
-    const bz1 = source[source_address_1 + 5];
-
-    const x0 = min2(ax0, bx0);
-    const y0 = min2(ay0, by0);
-    const z0 = min2(az0, bz0);
+function deinterleaveBufferAttribute(source_attribute) {
+    if (source_attribute.isInterleavedBufferAttribute !== true && source_attribute.isBufferAttribute) {
+        return source_attribute;
+    }
 
-    const x1 = max2(ax1, bx1);
-    const y1 = max2(ay1, by1);
-    const z1 = max2(az1, bz1);
+    const source_data = source_attribute.data;
+    const source_data_array = source_data.array;
+    const stride = source_data.stride;
 
-    destination[destination_offset] = x0;
-    destination[destination_offset + 1] = y0;
-    destination[destination_offset + 2] = z0;
-    destination[destination_offset + 3] = x1;
-    destination[destination_offset + 4] = y1;
-    destination[destination_offset + 5] = z1;
-}
+    const item_count = source_attribute.count;
+    const itemSize = source_attribute.itemSize;
+    const array_size = item_count * itemSize;
 
-/**
- *
- * @param {Float32Array} array
- * @param {number} address
- * @param {number} x0
- * @param {number} y0
- * @param {number} z0
- * @param {number} x1
- * @param {number} y1
- * @param {number} z1
- */
-function writeBox(array, address, x0, y0, z0, x1, y1, z1) {
-    array[address] = x0;
-    array[address + 1] = y0;
-    array[address + 2] = z0;
-    array[address + 3] = x1;
-    array[address + 4] = y1;
-    array[address + 5] = z1;
-}
+    const offset = source_attribute.offset;
 
-/**
- *
- * @param {number} from
- * @param {number} to
- * @param {Float32Array} array
- */
-function copyBox(from, to, array) {
-    array_copy(array, from, array, to, 6);
-}
+    const destination_array = new source_data_array.constructor(array_size);
 
-/**
- *
- * @param {number} from
- * @param {number} to
- * @param {Float32Array|number[]} array
- */
-function copyBoxZeroSize(from, to, array) {
-    array_copy(array, from, scratch_aabb_0, 0, 3);
+    const attribute = new BufferAttribute(destination_array, itemSize);
 
-    scratch_aabb_0[3] = scratch_aabb_0[0];
-    scratch_aabb_0[4] = scratch_aabb_0[1];
-    scratch_aabb_0[5] = scratch_aabb_0[2];
+    attribute.normalized = source_attribute.normalized;
+    attribute.name = source_attribute.name;
 
-    array_copy(scratch_aabb_0, 0, array, to, 6);
-}
+    let i = 0, j = 0;
+    // copy data
+    for (; i < item_count; i++) {
+        for (j = 0; j < itemSize; j++) {
+            destination_array[i * itemSize + j] = source_data_array[i * stride + offset + j];
+        }
+    }
 
+    return attribute;
+}
+
 /**
  *
- * @param {Float32Array} array
- * @param {number} binaryNode
- * @param {number} childNode0
- * @param {number} childNode1
+ * @param {Float32Array|number[]} aabb
+ * @param {number} aabb_offset
+ * @param {Float32Array|number[]} planes
+ * @param {number} planes_offset
+ * @param {number} plane_count
+ * @return {boolean}
  */
-function binaryNodeRefit(array, binaryNode, childNode0, childNode1) {
-    contain_box_array(array, childNode0, childNode1, array, binaryNode);
-}
-
+function aabb3_array_intersects_clipping_volume_array(
+    aabb, aabb_offset,
+    planes, planes_offset, plane_count
+) {
 
-const stack$6 = [];
-let stackPointer = 0;
+    const x0 = aabb[aabb_offset + 0];
+    const y0 = aabb[aabb_offset + 1];
+    const z0 = aabb[aabb_offset + 2];
+    const x1 = aabb[aabb_offset + 3];
+    const y1 = aabb[aabb_offset + 4];
+    const z1 = aabb[aabb_offset + 5];
 
-const rayLeafIntersectionVisitor = new RayLeafIntersectionVisitor();
+    return aabb3_intersects_clipping_volume_array(
+        x0, y0, z0,
+        x1, y1, z1,
+        planes, planes_offset, plane_count
+    );
+}
 
-/**
- * Created by Alex on 29/05/2016.
- */
+const stack$6 = SCRATCH_UINT32_TRAVERSAL_STACK;
 
 /**
  *
- * @param {Float32Array|Float64Array|Array.<Number>} vertices
- * @param {Uint8Array|Uint16Array|Uint32Array|Array.<Number>} indices
- * @returns {IndexedBinaryBVH}
+ * @param {number[]} result
+ * @param {number} result_offset
+ * @param {BinaryUint32BVH} bvh
+ * @param {Float32Array|number[]} planes
+ * @param {number} planes_offset
+ * @param {number} plane_count
+ * @returns {number}
  */
-function buildUnsorted(vertices, indices) {
-    //
-    const numNodes = indices.length / 3;
-
-    const tree = new IndexedBinaryBVH();
-    tree.initialize(numNodes);
-
-    for (let i = 0; i < numNodes; i++) {
-
-        const index3 = i * 3;
-
-        // read triangle vertex indices
-        const iA = indices[index3];
-        const iB = indices[index3 + 1];
-        const iC = indices[index3 + 2];
-
-        const a = iA * 3;
-        const b = iB * 3;
-        const c = iC * 3;
-
-        // read actual positions of each vertex
-        const aX = vertices[a];
-        const aY = vertices[a + 1];
-        const aZ = vertices[a + 2];
-
-        const bX = vertices[b];
-        const bY = vertices[b + 1];
-        const bZ = vertices[b + 2];
+function bvh32_query_user_data_overlaps_clipping_volume(
+    result, result_offset,
+    bvh,
+    planes, planes_offset, plane_count
+) {
+    let hit_count = 0;
 
-        const cX = vertices[c];
-        const cY = vertices[c + 1];
-        const cZ = vertices[c + 2];
+    const binary_node_count = bvh.binary_node_count;
 
-        // compute bounds of the triangle
-        const x0 = min3(aX, bX, cX);
-        const y0 = min3(aY, bY, cY);
-        const z0 = min3(aZ, bZ, cZ);
+    if (binary_node_count <= 0) {
+        // this should not happen
+        return 0;
+    }
 
-        const x1 = max3(aX, bX, cX);
-        const y1 = max3(aY, bY, cY);
-        const z1 = max3(aZ, bZ, cZ);
+    /**
+     *
+     * @type {number}
+     */
+    const stack_top = stack$6.pointer++;
 
-        tree.writeLeaf(i, x0, y0, z0, x1, y1, z1);
-    }
+    /**
+     * After performing empirical tests, stack-based depth-first traversal turns out faster than using a queue
+     * @type {number}
+     */
+    stack$6[stack_top] = 0;
 
-    // finalize build
-    tree.unsortedBuiltIntermediate();
+    const last_valid_index = binary_node_count + bvh.leaf_node_count;
 
-    return tree;
-}
+    const float32 = bvh.float32;
+    const uint32 = bvh.uint32;
 
-/**
- *
- * @param {Float32Array|Float64Array|Array.<Number>} vertices
- * @returns {IndexedBinaryBVH}
- */
-function buildUnsortedUnindexed(vertices) {
-    //
-    const numNodes = vertices.length / 9;
+    do {
+        stack$6.pointer--;
 
-    const tree = new IndexedBinaryBVH();
-    tree.initialize(numNodes);
+        // query_bvh_frustum_from_objects.iteration_count++;
+        const node_index = stack$6[stack$6.pointer];
 
-    for (let i = 0; i < numNodes; i++) {
+        const node_address = bvh.getNodeAddress(node_index);
 
-        const index3 = i * 3;
+        if (!aabb3_array_intersects_clipping_volume_array(
+            float32, node_address,
+            planes, planes_offset, plane_count
+        )) {
+            continue;
+        }
 
-        // read triangle vertex indices
-        const iA = index3;
-        const iB = index3 + 1;
-        const iC = index3 + 2;
+        const is_intermediate_node = node_index < binary_node_count;
 
-        const a = iA * 3;
-        const b = iB * 3;
-        const c = iC * 3;
+        if (is_intermediate_node) {
+            // is intermediate node
 
-        // read actual positions of each vertex
-        const aX = vertices[a];
-        const aY = vertices[a + 1];
-        const aZ = vertices[a + 2];
+            const left_index = (node_index << 1) + 1;
+            const right_index = left_index + 1;
 
-        const bX = vertices[b];
-        const bY = vertices[b + 1];
-        const bZ = vertices[b + 2];
+            // left node ends up on top of the stack, which aligns with the desired access sequence
+            if (right_index < last_valid_index) {
+                stack$6[stack$6.pointer++] = right_index;
+                // micro-optimization, since we know that right node is valid and left appears before that, left is valid too
+                stack$6[stack$6.pointer++] = left_index;
+            } else if (left_index < last_valid_index) {
+                stack$6[stack$6.pointer++] = left_index;
+            }
 
-        const cX = vertices[c];
-        const cY = vertices[c + 1];
-        const cZ = vertices[c + 2];
 
-        // compute bounds of the triangle
-        const x0 = min3(aX, bX, cX);
-        const y0 = min3(aY, bY, cY);
-        const z0 = min3(aZ, bZ, cZ);
+        } else {
+            // leaf node
 
-        const x1 = max3(aX, bX, cX);
-        const y1 = max3(aY, bY, cY);
-        const z1 = max3(aZ, bZ, cZ);
+            // write to output
+            result[result_offset + hit_count] = uint32[node_address + 6];
 
-        tree.writeLeaf(i, x0, y0, z0, x1, y1, z1);
-    }
+            hit_count++;
+        }
 
-    // finalize build
-    tree.unsortedBuiltIntermediate();
+    } while (stack$6.pointer > stack_top)
 
-    return tree;
+    return hit_count;
 }
 
 /**
@@ -67811,526 +67674,145 @@ function computeTrianglePlaneSide(
     return result;
 }
 
-class GeometrySpatialAcceleratorVisitor extends IndexedBinaryBVHVisitor {
-    constructor() {
-        super();
-
-
-        /**
-         * @protected
-         * @type {THREE.BufferGeometry}
-         */
-        this.__geometry = null;
-
-        /**
-         *
-         * @type {number[]}
-         * @protected
-         */
-        this.__buffer_indices = null;
-
-        /**
-         *
-         * @type {number[]}
-         * @protected
-         */
-        this.__buffer_vertices = null;
-
-        /**
-         *
-         * @type {number}
-         * @protected
-         */
-        this.__buffer_vertex_stride = 3;
-
-        /**
-         *
-         * @type {number}
-         * @protected
-         */
-        this.__buffer_position_offset = 0;
-
-        /**
-         * @protected
-         * @type {IndexedBinaryBVH}
-         */
-        this.__root = null;
-    }
-
-    /**
-     * @param {IndexedBinaryBVH} root
-     */
-    setRoot(root) {
-        this.__root = root;
-    }
-
-
-    /**
-     * @param {THREE.BufferGeometry} geometry
-     */
-    setGeometry(geometry) {
-        this.geometry = geometry;
-
-        const index_attribute = geometry.getIndex();
-
-        if (index_attribute) {
-            this.__buffer_indices = index_attribute.array;
-        } else {
-            // no index attribute
-            this.__buffer_indices = null;
-        }
-
-        const position_attribute = geometry.getAttribute('position');
-
-        if (position_attribute.isInterleavedBufferAttribute) {
-            const data = position_attribute.data;
-
-            this.__buffer_vertices = data.array;
-            this.__buffer_vertex_stride = data.stride;
-            this.__buffer_position_offset = position_attribute.offset;
-        } else {
-            this.__buffer_vertices = position_attribute.array;
-            this.__buffer_vertex_stride = 3;
-            this.__buffer_position_offset = 0;
-        }
-    }
-
-}
-
-class ClippingPlaneContainmentComputingVisitor extends GeometrySpatialAcceleratorVisitor {
-    constructor() {
-        super();
-
-        /**
-         * @private
-         * @type {Plane[]}
-         */
-        this.planes = [];
-
-        /**
-         *
-         * @private
-         * @type {number}
-         */
-        this.plane_count = 0;
-
-        this.__hit_count_in = 0;
-        this.__hit_count_out = 0;
-        this.__hit_count_intersect = 0;
-    }
-
-    reset() {
-        this.__hit_count_in = 0;
-        this.__hit_count_intersect = 0;
-        this.__hit_count_out = 0;
-    }
-
-    /**
-     *
-     * @returns {number}
-     */
-    getContainment() {
-        if (this.__hit_count_out === 0) {
-            if (this.__hit_count_intersect > 0) {
-                return 0;
-            } else {
-                // fully in
-                return 1;
-            }
-        } else {
-            if (this.__hit_count_intersect > 0 || this.__hit_count_in > 0) {
-                return 0;
-            } else {
-                // fully out
-                return -1;
-            }
-        }
-    }
-
-    /**
-     * @param {Plane[]} planes
-     */
-    setPlanes(planes) {
-        this.planes = planes;
-        this.plane_count = planes.length;
-    }
-
-
-    visit(address, type) {
-        const root = this.__root;
-
-        const data = root.data;
-        const binaryNodeCount = root.binaryNodeCount;
-
-        const planes = this.planes;
-        const plane_count = this.plane_count;
-
-        let intersect_flag = false;
-        if (type === NodeType.LEAF) {
-            // check triangle intersection
-
-            const index = address / 6 - binaryNodeCount;
-
-            const index3 = index * 3;
-
-            const indices = this.__buffer_indices;
-
-            const a = indices[index3];
-            const b = indices[index3 + 1];
-            const c = indices[index3 + 2];
-
-            const vertices = this.__buffer_vertices;
-
-            const stride = this.__buffer_vertex_stride;
-            const offset = this.__buffer_position_offset;
-
-            const a_address = a * stride + offset;
-            const b_address = b * stride + offset;
-            const c_address = c * stride + offset;
-
-            const ax = vertices[a_address];
-            const ay = vertices[a_address + 1];
-            const az = vertices[a_address + 2];
-
-            const bx = vertices[b_address];
-            const by = vertices[b_address + 1];
-            const bz = vertices[b_address + 2];
-
-            const cx = vertices[c_address];
-            const cy = vertices[c_address + 1];
-            const cz = vertices[c_address + 2];
-
-            for (let i = 0; i < plane_count; i++) {
-                const plane = planes[i];
-
-                const plane_normal_x = plane.normal.x;
-                const plane_normal_y = plane.normal.y;
-                const plane_normal_z = plane.normal.z;
-                const plane_constant = plane.constant;
-
-                const side = computeTrianglePlaneSide(
-                    plane_normal_x,
-                    plane_normal_y,
-                    plane_normal_z,
-                    plane_constant,
-                    ax, ay, az,
-                    bx, by, bz,
-                    cx, cy, cz
-                );
-
-                if (side === -3) {
-                    // fully outside
-                    this.__hit_count_out++;
-                    return false;
-                } else if (side < 3) {
-                    intersect_flag = true;
-                }
-            }
-
-            if (intersect_flag) {
-                this.__hit_count_intersect++;
-            } else {
-                this.__hit_count_in++;
-            }
-
-            return false;
-        } else {
-            // this is an intermediate node (binary node)
-
-            // check AABB intersection
-
-
-            const x0 = data[address];
-            const y0 = data[address + 1];
-            const z0 = data[address + 2];
-            const x1 = data[address + 3];
-            const y1 = data[address + 4];
-            const z1 = data[address + 5];
-
-
-            for (let i = 0; i < plane_count; i++) {
-                const plane = planes[i];
-
-                const plane_normal_x = plane.normal.x;
-                const plane_normal_y = plane.normal.y;
-                const plane_normal_z = plane.normal.z;
-                const plane_constant = plane.constant;
-
-                const side = aabb3_compute_plane_side(
-                    plane_normal_x,
-                    plane_normal_y,
-                    plane_normal_z,
-                    plane_constant,
-
-                    x0, y0, z0,
-                    x1, y1, z1
-                );
-
-                if (side === -2) {
-                    this.__hit_count_out++;
-
-                    return false;
-                } else if (side === 0) {
-                    intersect_flag = true;
-                }
-            }
-
-            if (intersect_flag) {
-                return true;
-            } else {
-                // no need to traverse further down, the whole node is in
-                this.__hit_count_in++;
-                return false;
-            }
-        }
-
-
-    }
-}
-
-class RaycastNearestHitComputingVisitor extends GeometrySpatialAcceleratorVisitor {
-    constructor() {
-        super();
-
-
-        /**
-         *
-         * @type {number}
-         * @private
-         */
-        this.__nearest_distance = Number.POSITIVE_INFINITY;
-
-        /**
-         * @readonly
-         * @type {SurfacePoint3}
-         * @private
-         */
-        this.__nearest_hit = new SurfacePoint3();
-
-        /**
-         * @readonly
-         * @type {SurfacePoint3}
-         * @private
-         */
-        this.__temp_hit = new SurfacePoint3();
-
-        /**
-         *
-         * @type {boolean}
-         * @private
-         */
-        this.__hit_found = false;
+/**
+ * @param {number[]|Float32Array} planes
+ * @param {number} planes_offset
+ * @param {number} plane_count
+ * @param {number} ax
+ * @param {number} ay
+ * @param {number} az
+ * @param {number} bx
+ * @param {number} by
+ * @param {number} bz
+ * @param {number} cx
+ * @param {number} cy
+ * @param {number} cz
+ * @returns {boolean}
+ */
+function triangle_intersects_clipping_volume(
+    planes, planes_offset, plane_count,
+    ax, ay, az,
+    bx, by, bz,
+    cx, cy, cz
+) {
 
-        /**
-         * @readonly
-         * @type {Vector3}
-         * @private
-         */
-        this.__ray_origin = new Vector3$1();
+    for (let j = 0; j < plane_count; j++) {
 
-        /**
-         * @readonly
-         * @type {Vector3}
-         * @private
-         */
-        this.__ray_direction = new Vector3$1();
-    }
+        const plane_address = planes_offset + j * 4;
 
-    /**
-     *
-     * @param {number} origin_x
-     * @param {number} origin_y
-     * @param {number} origin_z
-     * @param {number} direction_x
-     * @param {number} direction_y
-     * @param {number} direction_z
-     */
-    setRay(origin_x, origin_y, origin_z, direction_x, direction_y, direction_z) {
-        this.__ray_origin.set(
-            origin_x,
-            origin_y,
-            origin_z
-        );
+        const plane_normal_x = planes[plane_address];
+        const plane_normal_y = planes[plane_address + 1];
+        const plane_normal_z = planes[plane_address + 2];
+        const plane_constant = planes[plane_address + 3];
 
-        this.__ray_direction.set(
-            direction_x,
-            direction_y,
-            direction_z
+        const side = computeTrianglePlaneSide(
+            plane_normal_x,
+            plane_normal_y,
+            plane_normal_z,
+            plane_constant,
+            ax, ay, az,
+            bx, by, bz,
+            cx, cy, cz
         );
-    }
-
-    reset() {
-        this.__nearest_distance = Number.POSITIVE_INFINITY;
-        this.__hit_found = false;
-    }
-
-    getNearestHit() {
-        return this.__nearest_hit;
-    }
-
-    isHitFound() {
-        return this.__hit_found;
-    }
-
-
-    visit(address, type) {
-        const root = this.__root;
-
-        const data = root.data;
-        const binaryNodeCount = root.binaryNodeCount;
-
-        const rayOrigin = this.__ray_origin;
-        const rayDirection = this.__ray_direction;
-
-        if (type === NodeType.LEAF) {
-            // do triangle test
-
-            const index = address / 6 - binaryNodeCount;
-
-            const index3 = index * 3;
-
-            const indices = this.__buffer_indices;
-
-            let a, b, c;
-
-            if (indices !== null) {
-                assert.lessThan(index3 + 2, indices.length, 'triangle index overflow, possibly geometry changed but tree was not rebuilt?');
-
-                a = indices[index3];
-                b = indices[index3 + 1];
-                c = indices[index3 + 2];
-            } else {
-                // implicit indices
-                a = index3;
-                b = index3 + 1;
-                c = index3 + 2;
-            }
-
-            const vertices = this.__buffer_vertices;
-
-            const stride = this.__buffer_vertex_stride;
-            const offset = this.__buffer_position_offset;
-
-            const a_address = a * stride + offset;
-            const b_address = b * stride + offset;
-            const c_address = c * stride + offset;
-
-            assert.lessThan(a_address + 2, vertices.length, 'a-vertex overflow');
-            assert.lessThan(b_address + 2, vertices.length, 'b-vertex overflow');
-            assert.lessThan(c_address + 2, vertices.length, 'c-vertex overflow');
-
-            const ax = vertices[a_address];
-            const ay = vertices[a_address + 1];
-            const az = vertices[a_address + 2];
-
-            const bx = vertices[b_address];
-            const by = vertices[b_address + 1];
-            const bz = vertices[b_address + 2];
-
-            const cx = vertices[c_address];
-            const cy = vertices[c_address + 1];
-            const cz = vertices[c_address + 2];
-
-            const temp_hit = this.__temp_hit;
-
-            if (computeTriangleRayIntersection(
-                temp_hit,
-                rayOrigin.x,
-                rayOrigin.y,
-                rayOrigin.z,
-                rayDirection.x,
-                rayDirection.y,
-                rayDirection.z,
-                ax, ay, az,
-                bx, by, bz,
-                cx, cy, cz
-            )) {
-                const d = temp_hit.position.distanceSqrTo(rayOrigin);
-
-                if (d < this.__nearest_distance) {
-                    this.__nearest_hit.copy(temp_hit);
-                    this.__nearest_hit.index = index;
-
-                    this.__nearest_distance = d;
-
-                    this.__hit_found = true;
-                }
-
-            }
 
+        if (side === -3) {
+            // fully outside
             return false;
-
-        } else {
-            // do AABB test
-
-            const x0 = data[address];
-            const y0 = data[address + 1];
-            const z0 = data[address + 2];
-            const x1 = data[address + 3];
-            const y1 = data[address + 4];
-            const z1 = data[address + 5];
-
-            return aabb3_intersects_ray(
-                x0, y0, z0,
-                x1, y1, z1,
-
-                rayOrigin.x,
-                rayOrigin.y,
-                rayOrigin.z,
-
-                rayDirection.x,
-                rayDirection.y,
-                rayDirection.z
-            );
-
         }
     }
+
+    return true;
 }
 
+const scratch_array$2 = [];
+
 /**
  *
- * @param {THREE.InterleavedBufferAttribute|THREE.BufferAttribute} source_attribute
- * @returns {THREE.BufferAttribute}
+ * @param {BinaryUint32BVH} bvh
+ * @param {number[]|ArrayLike<number>} vertices
+ * @param {number} vertex_offset Unless you're using an interleaved buffer of some kind, this will be 0
+ * @param {number} vertex_stride Unless you're using an interleaved buffer, this should be 3
+ * @param {number[]|ArrayLike<number>|undefined} indices if this is set to undefined - implicit indexing will be used
+ * @param {number[]|Float32Array} planes
+ * @param {number} planes_offset
+ * @param {number} plane_count
+ * @returns {boolean}
  */
-function deinterleaveBufferAttribute(source_attribute) {
-    if (source_attribute.isInterleavedBufferAttribute !== true && source_attribute.isBufferAttribute) {
-        return source_attribute;
-    }
-
-    const source_data = source_attribute.data;
-    const source_data_array = source_data.array;
-    const stride = source_data.stride;
+function bvh32_geometry_overlap_clipping_volume(
+    bvh,
+    vertices, vertex_offset, vertex_stride,
+    indices,
+    planes, planes_offset, plane_count
+) {
 
-    const item_count = source_attribute.count;
-    const itemSize = source_attribute.itemSize;
-    const array_size = item_count * itemSize;
+    const hit_count = bvh32_query_user_data_overlaps_clipping_volume(
+        scratch_array$2, 0,
+        bvh,
+        planes, planes_offset, plane_count
+    );
 
-    const offset = source_attribute.offset;
+    let a, b, c;
 
-    const destination_array = new source_data_array.constructor(array_size);
+    for (let i = 0; i < hit_count; i++) {
+        const triangle_index = scratch_array$2[i];
 
-    const attribute = new BufferAttribute(destination_array, itemSize);
+        const index3 = triangle_index * 3;
 
-    attribute.normalized = source_attribute.normalized;
-    attribute.name = source_attribute.name;
+        if (indices !== undefined) {
+            assert.lessThan(index3 + 2, indices.length, 'triangle index overflow, possibly geometry changed but tree was not rebuilt?');
 
-    let i = 0, j = 0;
-    // copy data
-    for (; i < item_count; i++) {
-        for (j = 0; j < itemSize; j++) {
-            destination_array[i * itemSize + j] = source_data_array[i * stride + offset + j];
+            a = indices[index3];
+            b = indices[index3 + 1];
+            c = indices[index3 + 2];
+        } else {
+            // implicit indices
+            a = index3;
+            b = index3 + 1;
+            c = index3 + 2;
+        }
+
+        const a_address = a * vertex_stride + vertex_offset;
+        const b_address = b * vertex_stride + vertex_offset;
+        const c_address = c * vertex_stride + vertex_offset;
+
+        assert.lessThan(a_address + 2, vertices.length, 'a-vertex overflow');
+        assert.lessThan(b_address + 2, vertices.length, 'b-vertex overflow');
+        assert.lessThan(c_address + 2, vertices.length, 'c-vertex overflow');
+
+        const ax = vertices[a_address];
+        const ay = vertices[a_address + 1];
+        const az = vertices[a_address + 2];
+
+        const bx = vertices[b_address];
+        const by = vertices[b_address + 1];
+        const bz = vertices[b_address + 2];
+
+        const cx = vertices[c_address];
+        const cy = vertices[c_address + 1];
+        const cz = vertices[c_address + 2];
+
+        if (triangle_intersects_clipping_volume(
+            planes, planes_offset, plane_count,
+            ax, ay, az,
+            bx, by, bz,
+            cx, cy, cz
+        )) {
+            return true;
         }
+
     }
 
-    return attribute;
+    return false;
 }
 
+const scratch_planes = [];
+
 class GeometrySpatialQueryAccelerator {
     constructor(cache_size = 100 * 1024 * 1024) {
 
         /**
          *
-         * @type {Cache<THREE.BufferGeometry, IndexedBinaryBVH>}
+         * @type {Cache<THREE.BufferGeometry, BinaryUint32BVH>}
          */
         this.cache = new Cache({
             maxWeight: cache_size,
@@ -68342,15 +67824,13 @@ class GeometrySpatialQueryAccelerator {
             },
             /**
              *
-             * @param {IndexedBinaryBVH} tree
+             * @param {BinaryUint32BVH} tree
              */
             valueWeigher(tree) {
                 return tree.estimateByteSize();
             }
         });
 
-        this.__visitor_clip = new ClippingPlaneContainmentComputingVisitor();
-        this.__visitor_raycast = new RaycastNearestHitComputingVisitor();
     }
 
     /**
@@ -68373,23 +67853,46 @@ class GeometrySpatialQueryAccelerator {
      *
      * @param {THREE.BufferGeometry} geometry
      * @param {Plane[]} planes
-     * @returns {number} -1,0,1. -1 means fully outside, 0 means partially inside, 1 means fully inside
+     * @returns {boolean} true means some overlap exists, false otherwise
      */
     queryContainmentViaClippingPlanes(geometry, planes) {
         assert.notNull(geometry, 'geometry');
         assert.defined(geometry, 'geometry');
 
+
         const bvh = this.__acquireBVH(geometry);
 
-        this.__visitor_clip.reset();
+        read_three_planes_to_array(planes, scratch_planes);
 
-        this.__visitor_clip.setGeometry(geometry);
-        this.__visitor_clip.setPlanes(planes);
-        this.__visitor_clip.setRoot(bvh);
+        const geometryIndices = geometry.getIndex()?.array;
+        const position_attribute = geometry.getAttribute('position');
+
+        let position_data;
+        let stride = 3;
+        let position_data_offset = 0;
+
+        if (position_attribute.isInterleavedBufferAttribute) {
+
+            position_data = position_attribute.data.array;
+
+            stride = position_attribute.data.stride;
+            position_data_offset = position_attribute.offset;
 
-        bvh.traversePreOrderStack(this.__visitor_clip, 0);
+        } else {
+
+            position_data = position_attribute.array;
+
+            stride = 3;
+            position_data_offset = 0;
 
-        return this.__visitor_clip.getContainment();
+        }
+
+        return bvh32_geometry_overlap_clipping_volume(
+            bvh,
+            position_data, position_data_offset, stride,
+            geometryIndices,
+            scratch_planes, 0, planes.length
+        );
     }
 
     /**
@@ -68439,11 +67942,33 @@ class GeometrySpatialQueryAccelerator {
             return false;
         }
 
-        this.__visitor_raycast.reset();
+        const geometryIndices = geometry.getIndex()?.array;
+        const position_attribute = geometry.getAttribute('position');
+
+        let position_data;
+        let stride = 3;
+        let position_data_offset = 0;
+
+        if (position_attribute.isInterleavedBufferAttribute) {
+
+            position_data = position_attribute.data.array;
+
+            stride = position_attribute.data.stride;
+            position_data_offset = position_attribute.offset;
 
-        this.__visitor_raycast.setGeometry(geometry);
-        this.__visitor_raycast.setRoot(bvh);
-        this.__visitor_raycast.setRay(
+        } else {
+
+            position_data = position_attribute.array;
+
+            stride = 3;
+            position_data_offset = 0;
+
+        }
+
+        return bvh32_geometry_raycast(
+            destination, bvh,
+            position_data, position_data_offset, stride,
+            geometryIndices,
             ray_origin_x,
             ray_origin_y,
             ray_origin_z,
@@ -68452,16 +67977,6 @@ class GeometrySpatialQueryAccelerator {
             ray_direction_z
         );
 
-        bvh.traversePreOrderStack(this.__visitor_raycast, 0);
-
-        if (this.__visitor_raycast.isHitFound()) {
-
-            destination.copy(this.__visitor_raycast.getNearestHit());
-
-            return true;
-        } else {
-            return false;
-        }
     }
 
     /**
@@ -68489,7 +68004,7 @@ class GeometrySpatialQueryAccelerator {
     /**
      * @private
      * @param {THREE.BufferGeometry} geometry
-     * @returns {IndexedBinaryBVH}
+     * @returns {BinaryUint32BVH}
      */
     __acquireBVH(geometry) {
         assert.notNull(geometry, 'geometry');
@@ -68511,7 +68026,7 @@ class GeometrySpatialQueryAccelerator {
     /**
      * @private
      * @param {THREE.BufferGeometry} geometry
-     * @returns {IndexedBinaryBVH}
+     * @returns {BinaryUint32BVH}
      */
     __buildBVH(geometry) {
         const position_attribute = geometry.getAttribute('position');
@@ -68520,14 +68035,19 @@ class GeometrySpatialQueryAccelerator {
         const de_interleaved_position_attribute = deinterleaveBufferAttribute(position_attribute);
         const vertices = de_interleaved_position_attribute.array;
 
+        const bvh = new BinaryUint32BVH();
+
         if (index_attribute === undefined || index_attribute === null) {
-            return buildUnsortedUnindexed(vertices);
-        }
+            bvh32_from_unindexed_geometry(bvh, vertices);
+        } else {
 
-        const de_interleaved_index_attribute = deinterleaveBufferAttribute(index_attribute);
-        const indices = de_interleaved_index_attribute.array;
+            const de_interleaved_index_attribute = deinterleaveBufferAttribute(index_attribute);
+            const indices = de_interleaved_index_attribute.array;
 
-        return buildUnsorted(vertices, indices);
+            bvh32_from_indexed_geometry(bvh, vertices, indices);
+        }
+
+        return bvh;
     }
 
 }
@@ -69346,29 +68866,6 @@ function bvh_query_user_data_overlaps_frustum(
     return result_cursor - result_offset;
 }
 
-/**
- *
- * @param {Plane[]} planes
- * @param {ArrayLike<number>|number[]|Float32Array|Float64Array} array
- */
-function read_frustum_planes_to_array(planes, array) {
-    assert.greaterThanOrEqual(array.length, 24, 'target array is too small');
-
-    for (let i = 0; i < 6; i++) {
-        const plane = planes[i];
-
-        const offset = i * 4;
-
-        const normal = plane.normal;
-
-        array[offset] = normal.x;
-        array[offset + 1] = normal.y;
-        array[offset + 2] = normal.z;
-
-        array[offset + 3] = plane.constant;
-    }
-}
-
 /**
  * @template CTX
  * @template Asset
@@ -71959,7 +71456,7 @@ class TerrainSystem extends System {
 
                 for (let i = 0; i < frustums.length; i++) {
 
-                    read_frustum_planes_to_array(frustums[i].planes, frustum);
+                    read_three_planes_to_array(frustums[i].planes, frustum);
 
                     found_tiles += bvh_query_user_data_overlaps_frustum(tiles, tile_count, tileManager.bvh, frustum);
                 }
@@ -91556,7 +91053,7 @@ class CameraView {
         frustum_from_camera(camera, scratch_frustum, false);
 
         // update view definition
-        read_frustum_planes_to_array(scratch_frustum.planes, this.frustum);
+        read_three_planes_to_array(scratch_frustum.planes, this.frustum);
 
         // read projection matrix
         // TODO
@@ -111242,7 +110739,7 @@ function query_bvh_frustum_from_texture(
 ) {
     let result = 0;
 
-    const binary_node_count = bvh.getBinaryNodeCount();
+    const binary_node_count = bvh.binary_node_count;
 
     if (binary_node_count <= 0) {
         // this should not happen
@@ -111261,7 +110758,7 @@ function query_bvh_frustum_from_texture(
      */
     stack[stack_top] = 0;
 
-    const last_valid_index = binary_node_count + bvh.getLeafNodeCount();
+    const last_valid_index = binary_node_count + bvh.leaf_node_count;
 
     const float32 = bvh.float32;
     const uint32 = bvh.uint32;
@@ -112817,7 +112314,7 @@ class LightManager {
 
         const nodes = [];
 
-        read_frustum_planes_to_array(this.__view_frustum.planes, scratch_frustum_planes);
+        read_three_planes_to_array(this.__view_frustum.planes, scratch_frustum_planes);
 
         /*
         Search is done in 2 phases:
@@ -119214,4 +118711,16 @@ class Blackboard extends AbstractBlackboard {
 
 Blackboard.typeName = 'Blackboard';
 
+/**
+ * just in case you need that function also
+ * @param {Vector3} axis
+ * @param {number} angle
+ * @param {Quaternion} result
+ */
+function quat3_createFromAxisAngle(axis, angle, result) {
+    const halfAngle = angle * .5;
+    const s = Math.sin(halfAngle);
+    result.set(axis.x * s, axis.y * s, axis.z * s, Math.cos(halfAngle));
+}
+
 export { AmbientOcclusionPostProcessEffect, Behavior, BehaviorStatus, Blackboard, Cache, EngineConfiguration, EngineHarness, ForwardPlusRenderingPlugin, HashMap, Light, ParallelBehavior, ParallelBehaviorPolicy, SGMesh, SGMeshSystem, SelectorBehavior, SequenceBehavior, ShadedGeometry, ShadedGeometrySystem, Signal, SignalBinding, Transform, dispatchViaProxy, findSignalHandlerIndexByHandle, findSignalHandlerIndexByHandleAndContext, quat3_createFromAxisAngle, v2_angleBetween, v2_bearing_angle_towards, v2_distance, v2_dot, v2_length_sqr, v2_magnitude, v4_applyMatrix4, v4_distance_sqr, v4_dot, v4_length_sqr };