@woosh/meep-engine 2.69.0 → 2.71.0

package/build/meep.cjs

@@ -1764,6 +1764,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
@@ -1775,13 +1796,190 @@ 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 v0, v1, v2, dropped, max;
+
+    //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;
+    }
+
+
+    //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.hypot(v0, v1, v2, dropped);
+    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);
 }
 
 /**
@@ -1800,13 +1998,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);
 }
 
 /**
@@ -1862,6 +2058,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
@@ -1933,45 +2233,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
@@ -2816,100 +3077,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);
     }
 
 
@@ -3067,16 +3259,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.
  */
@@ -3086,18 +3268,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 {
     /**
      *
@@ -4520,31 +4690,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);
     }
 
     /**
@@ -4552,107 +4698,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);
     }
 
     /**
@@ -4839,13 +4885,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
@@ -5112,8 +5152,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);
     }
@@ -48947,11 +48986,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;
     }
 
     /**
@@ -48962,8 +48997,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);
     }
@@ -56786,6 +56824,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
@@ -56848,10 +56919,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];
@@ -56860,17 +56931,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 {
     /**
@@ -57101,17 +57170,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);
     }
@@ -57163,9 +57230,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;
 
@@ -57195,15 +57262,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--;
                 }
 
@@ -65351,6 +65418,23 @@ const TaskSignal = {
     Yield: 3
 };
 
+/**
+ * @template T
+ * @param {T[]} array
+ * @param {T} element
+ * @return {boolean}
+ */
+function array_push_if_unique(array, element) {
+    const i = array.indexOf(element);
+
+    if (i === -1) {
+        array.push(element);
+        return true;
+    }
+
+    return false;
+}
+
 /**
  * Created by Alex on 22/05/2016.
  */
@@ -65373,8 +65457,44 @@ const TaskState = {
  * Created by Alex on 22/05/2016.
  */
 
+/**
+ *
+ * @type {number}
+ */
+let id_counter$3 = 0;
 
 class Task {
+    /**
+     * @readonly
+     * @type {number}
+     */
+    id = id_counter$3++;
+
+    on = {
+        started: new Signal(),
+        completed: new Signal(),
+        failed: new Signal()
+    };
+
+    /**
+     *
+     * @type {ObservedInteger}
+     */
+    state = new ObservedInteger(TaskState.INITIAL);
+
+    /**
+     * amount of time spent running this task in milliseconds
+     * @type {number}
+     * @public
+     */
+    __executedCpuTime = 0;
+    /**
+     * number of time task's cycle function was executed
+     * @type {number}
+     * @public
+     */
+    __executedCycleCount = 0;
+
     /**
      *
      * @param {string} [name] useful for identifying the task later on, for various UI and debug purposes
@@ -65399,9 +65519,16 @@ class Task {
         assert.isFunction(cycleFunction, 'cycleFunction');
         assert.isNumber(estimatedDuration, 'estimatedDuration');
 
-
+        /**
+         *
+         * @type {Task[]}
+         */
         this.dependencies = dependencies;
 
+        /**
+         *
+         * @type {number}
+         */
         this.estimatedDuration = estimatedDuration;
 
         /**
@@ -65429,30 +65556,6 @@ class Task {
 
         }
 
-        this.on = {
-            started: new Signal(),
-            completed: new Signal(),
-            failed: new Signal()
-        };
-
-        /**
-         *
-         * @type {ObservedInteger}
-         */
-        this.state = new ObservedInteger(TaskState.INITIAL);
-
-        /**
-         * amount of time spent running this task in milliseconds
-         * @type {number}
-         * @public
-         */
-        this.__executedCpuTime = 0;
-        /**
-         * number of time task's cycle function was executed
-         * @type {number}
-         * @public
-         */
-        this.__executedCycleCount = 0;
     }
 
     computeProgress() {
@@ -65497,11 +65600,7 @@ class Task {
         } else if (task.isTask) {
 
             //check that the dependency is not registered yet
-            if (this.dependencies.indexOf(task) === -1) {
-
-                this.dependencies.push(task);
-
-            }
+            array_push_if_unique(this.dependencies, task);
 
         } else {
             throw new Error('Expected a Task or a TaskGroup, got something else');
@@ -65515,11 +65614,14 @@ class Task {
      * @param {Array<(Task|TaskGroup)>} tasks
      */
     addDependencies(tasks) {
-        if (!Array.isArray(tasks)) {
-            throw new Error(`argument 'tasks' is not an Array`);
-        }
+        assert.isArray(tasks, 'tasks');
+
+        const task_count = tasks.length;
 
-        tasks.forEach(t => this.addDependency(t));
+        for (let i = 0; i < task_count; i++) {
+            const task = tasks[i];
+            this.addDependency(task);
+        }
     }
 
     toString() {
@@ -69859,23 +69961,6 @@ function array_copy_unique(source, source_position, destination, destination_pos
     return j - destination_position;
 }
 
-/**
- * @template T
- * @param {T[]} array
- * @param {T} element
- * @return {boolean}
- */
-function array_push_if_unique(array, element) {
-    const i = array.indexOf(element);
-
-    if (i === -1) {
-        array.push(element);
-        return true;
-    }
-
-    return false;
-}
-
 /**
  * Created by Alex on 01/04/2014.
  */
@@ -87802,7 +87887,7 @@ function computeStatisticalPartialMedian(values, start, end) {
 
     const range = end - start;
 
-    const position = (start + range / 2) | 0;
+    const position = (start + range) >> 1;
 
     return copy[position];
 }
@@ -98709,13 +98794,6 @@ function playTrackRealTime(track, ecd) {
     return entity;
 }
 
-/**
- * Magic field that can be added to an individual component to control serialization on level of individual components
- * @readonly
- * @type {string}
- */
-const COMPONENT_SERIALIZATION_TRANSIENT_FIELD = '@serialization_transient';
-
 /**
  * @template A,B
  * @param {A} a
@@ -98787,64 +98865,48 @@ const GUIElementFlag = {
 class GUIElement {
     /**
      *
-     * @param {View} [view] parameter is deprecated
-     * @constructor
+     * @type {View}
      */
-    constructor(view) {
-        /**
-         *
-         * @type {View}
-         */
-        this.view = null;
+    view = null;
 
-        /**
-         *
-         * @type {String}
-         */
-        this.klass = null;
-
-        /**
-         *
-         * @type {Object}
-         */
-        this.parameters = {};
-
-        /**
-         * ranges from 0..1 in both X and Y, controls anchor point of element positioning
-         * @type {Vector2}
-         */
-        this.anchor = new Vector2(0, 0);
-
-        /**
-         * Used for visual grouping of elements, system will create and manage named containers to group elements together
-         * @readonly
-         * @type {String|null}
-         */
-        this.group = null;
+    /**
+     *
+     * @type {String}
+     */
+    klass = null;
 
-        /**
-         * @private
-         * @type {number}
-         */
-        this.flags = GUIElementFlag.Managed;
+    /**
+     *
+     * @type {Object}
+     */
+    parameters = {};
 
+    /**
+     * ranges from 0..1 in both X and Y, controls anchor point of element positioning
+     * @type {Vector2}
+     */
+    anchor = new Vector2(0, 0);
 
-        /**
-         *
-         * @type {ObservedBoolean}
-         */
-        this.visible = new ObservedBoolean(true);
+    /**
+     * Used for visual grouping of elements, system will create and manage named containers to group elements together
+     * @readonly
+     * @type {String|null}
+     */
+    group = null;
 
+    /**
+     * @private
+     * @type {number}
+     */
+    flags = GUIElementFlag.Managed;
 
-        if (view !== undefined) {
-            console.warn('constructor parameters are deprecated');
-            this.view = view;
 
-            //set non-serializable flag
-            this[COMPONENT_SERIALIZATION_TRANSIENT_FIELD] = true;
-        }
+    /**
+     *
+     * @type {ObservedBoolean}
+     */
+    visible = new ObservedBoolean(true);
 
-    }
 
     /**
      *
@@ -99001,11 +99063,9 @@ GUIElement.serializable = true;
 class ViewportPosition {
     /**
      *
-     * @param {Vector2} [position]
-     * @param {Vector2} [offset]
      * @constructor
      */
-    constructor({ position, offset } = {}) {
+    constructor(options) {
         /**
          * Clip-scale position, on-screen values are in range of 0 to 1
          * @type {Vector2}
@@ -99051,12 +99111,9 @@ class ViewportPosition {
          */
         this.enabled = new ObservedBoolean(true);
 
-        if (position !== void 0) {
-            this.position.copy(position);
-        }
-
-        if (offset !== void 0) {
-            this.offset.copy(offset);
+        if (options !== undefined) {
+            console.warn("ViewportPosition constructor options is deprecated, please use static fromJSON method instead if you need similar functionality");
+            this.fromJSON(options);
         }
     }
 
@@ -118645,6 +118702,18 @@ 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));
+}
+
 exports.AmbientOcclusionPostProcessEffect = AmbientOcclusionPostProcessEffect;
 exports.Behavior = Behavior;
 exports.BehaviorStatus = BehaviorStatus;