@woosh/meep-engine 2.109.0 → 2.109.2

package/build/meep.cjs

@@ -977,13 +977,6 @@ class SignalHandler {
  */
 SignalHandler.prototype.isSignalHandler = true;
 
-/**
- *
- * @author Alex Goldring
- * @copyright Alex Goldring 2014
- */
-
-
 /**
  * Common dispatch stack
  * @readonly
@@ -1600,11 +1593,12 @@ function findSignalHandlerIndexByHandleAndContext(handlers, f, ctx) {
     const l = handlers.length;
 
     for (let i = 0; i < l; i++) {
-        const signalHandler = handlers[i];
+        const handler = handlers[i];
 
-        if (signalHandler.handle === f && signalHandler.context === ctx) {
+        if (handler.handle === f && handler.context === ctx) {
             return i;
         }
+
     }
 
     return -1;
@@ -1637,7 +1631,7 @@ function removeHandlerByHandler(signal, h) {
  */
 function removeHandlerByHandlerAndContext(signal, h, ctx) {
     const handlers = signal.handlers;
-    let i = findSignalHandlerIndexByHandleAndContext(handlers, h, ctx);
+    const i = findSignalHandlerIndexByHandleAndContext(handlers, h, ctx);
 
     if (i >= 0) {
         handlers.splice(i, 1);
@@ -1647,6 +1641,12 @@ function removeHandlerByHandlerAndContext(signal, h, ctx) {
     return false;
 }
 
+/**
+ *
+ * @param {function} f
+ * @param {*} context
+ * @param {Array} args
+ */
 function dispatchCallback(f, context, args) {
 
     try {
@@ -1938,6 +1938,30 @@ function v3_dot(x0, y0, z0, x1, y1, z1) {
     return (x0 * x1 + y0 * y1 + z0 * z1);
 }
 
+/**
+ *
+ * @param {number} x
+ * @param {number} y
+ * @param {number} z
+ * @param {number} w
+ * @returns {number}
+ */
+function v4_length_sqr(x, y, z, w) {
+    return x * x + y * y + z * z + w * w;
+}
+
+/**
+ *
+ * @param {number} x
+ * @param {number} y
+ * @param {number} z
+ * @param {number} w
+ * @returns {number}
+ */
+function v4_length(x, y, z, w) {
+    return Math.sqrt(v4_length_sqr(x, y, z, w));
+}
+
 /**
  *
  * @param {number} v
@@ -3602,7 +3626,7 @@ let Quaternion$1 = class Quaternion {
         const z = this.z;
         const w = this.w;
 
-        return Math.sqrt(x * x + y * y + z * z + w * w);
+        return v4_length(x, y, z, w);
     }
 
     /**
@@ -3614,48 +3638,20 @@ let Quaternion$1 = class Quaternion {
         Quaternion.rotateTowards(this, this, other, max_delta);
     }
 
-    /**
-     *
-     * @param {Vector3} direction
-     * @param {Vector3} [up]
-     * @param {Vector3} [forward]
-     */
-    alignToDirection(direction, up = Vector3$1.up, forward = Vector3$1.forward) {
-
-        const dot = up.dot(direction);
-
-
-        if (Math.abs(dot + 1) < 0.000001) {
-            // vector a and b point exactly in the opposite direction,
-            // so it is a 180 degrees turn around the up-axis
-            this.set(forward.x, forward.y, forward.z, Math.PI);
-        } else if (Math.abs(dot - 1) < 0.000001) {
-            // vector a and b point exactly in the same direction
-            // so we return the identity quaternion
-            this.set(0, 0, 0, 1);
-        }
-
-        const angle = Math.acos(dot);
-
-        axis.crossVectors(up, direction);
-        axis.normalize();
-
-        this.fromAxisAngle(axis, angle);
-    }
-
     /**
      *
      * @param {Vector3} source
      * @param {Vector3} target
+     * @param {Vector3} [up]
      */
-    lookAt(source, target) {
+    lookAt(source, target, up = Vector3$1.up) {
         const forward = new Vector3$1();
 
         forward.subVectors(target, source);
 
         forward.normalize();
 
-        this.alignToDirection(forward);
+        this.lookRotation(forward, up);
     }
 
     /**
@@ -4038,22 +4034,23 @@ let Quaternion$1 = class Quaternion {
         const qW_1 = qW + l0;
 
         //normalize result
-        const l1 = Math.sqrt(p0 + qW_1 * qW_1);
+        const l1 = 1 / Math.sqrt(p0 + qW_1 * qW_1);
 
-        const x = qX / l1;
-        const y = qY / l1;
-        const z = qZ / l1;
-        const w = qW / l1;
+        const x = qX * l1;
+        const y = qY * l1;
+        const z = qZ * l1;
+        const w = qW * l1;
 
         this.set(x, y, z, w);
     }
 
     /**
+     * NOTE: Vectors need to be normalized
      * Based on blog post: http://lolengine.net/blog/2013/09/18/beautiful-maths-quaternion-from-vectors
      * @param {Vector3} from
      * @param {Vector3} to
      */
-    fromUnitVectors2(from, to) {
+    fromUnitVectors(from, to) {
 
         //quat quat::fromtwovectors(vec3 u, vec3 v)
         // {
@@ -4072,7 +4069,7 @@ let Quaternion$1 = class Quaternion {
 
         const uv_dot = v3_dot(ax, ay, az, bx, by, bz);
 
-        if (uv_dot === -1) {
+        if (uv_dot < -0.9999999) {
             //to vector is opposite, produce a reversal quaternion
 
             tempvec3.crossVectors(Vector3$1.left, from);
@@ -4116,49 +4113,6 @@ let Quaternion$1 = class Quaternion {
         );
     }
 
-    /**
-     * Input vectors must be normalized
-     * @param {Vector3} from
-     * @param {Vector3} to
-     */
-    fromUnitVectors(from, to) {
-
-        const dot = from.dot(to);
-
-        let x, y, z, w;
-
-        if (dot < -0.9999999) {
-            const tempvec3 = new Vector3$1();
-
-            tempvec3.crossVectors(Vector3$1.left, from);
-
-            if (tempvec3.lengthSqr() < 0.00001) {
-                tempvec3.crossVectors(Vector3$1.up, from);
-            }
-
-            tempvec3.normalize();
-
-            this.fromAxisAngle(tempvec3, Math.PI);
-        } else if (dot > 0.9999999) {
-            x = 0;
-            y = 0;
-            z = 0;
-            w = 1;
-
-            this.set(x, y, z, w);
-        } else {
-            //cross product from x to
-
-            x = from.y * to.z - from.z * to.y;
-            y = from.z * to.x - from.x * to.z;
-            z = from.x * to.y - from.y * to.x;
-            w = 1 + dot;
-
-            this.set(x, y, z, w);
-            this.normalize();
-        }
-    }
-
     /**
      * @deprecated
      * @param {Matrix4} m
@@ -4345,17 +4299,6 @@ let Quaternion$1 = class Quaternion {
         this.slerpQuaternions(this, other, t);
     }
 
-    /**
-     * @see https://github.com/gareth-cross/quat/blob/master/include/quaternion.hpp
-     * TODO implement
-     * @param {Quaternion} a
-     * @param {Quaternion} b
-     * @param {number} t
-     */
-    quaternionsInterpolateRungeKutta4(a, b, t) {
-        throw new Error('Not Implemented');
-    }
-
     /**
      *
      * @param {function} handler
@@ -4675,13 +4618,6 @@ Quaternion$1.prototype.toArray = Quaternion$1.prototype.writeToArray;
 Quaternion$1.identity = Object.freeze(new Quaternion$1(0, 0, 0, 1));
 
 
-/**
- *
- * @type {Vector3}
- */
-const axis = new Vector3$1();
-
-
 const tempvec3 = new Vector3$1();
 
 /**
@@ -50507,6 +50443,14 @@ class Vector1 extends Number {
         return this.set(clamp$1(this.x, low, high));
     }
 
+    /**
+     * Negate sign of the value, if value is 7, it will become -7 and vice versa
+     * Zero is unaffected
+     */
+    negate() {
+        this.set(-this.x);
+    }
+
     /**
      *
      * @param {Vector1|Vector2|Vector3|Vector4} other
@@ -50561,7 +50505,7 @@ class Vector1 extends Number {
      * @param {number[]} array
      * @param {number} offset
      */
-    readFromArray(array, offset=0) {
+    readFromArray(array, offset = 0) {
         this.set(array[offset]);
     }
 
@@ -50570,11 +50514,11 @@ class Vector1 extends Number {
      * @param {number[]} array
      * @param {number} offset
      */
-    writeToArray(array, offset=0) {
+    writeToArray(array, offset = 0) {
         array[offset] = this.x;
     }
 
-    asArray(){
+    asArray() {
         return [this.x];
     }
 
@@ -52484,7 +52428,7 @@ class BVH {
     /**
      *
      * @param {number} id
-     * @param {number[]|ArrayLike<number>} aabb
+     * @param {number[]|ArrayLike<number>|AABB3} aabb
      */
     node_set_aabb(id, aabb) {
 
@@ -52625,27 +52569,24 @@ class BVH {
         const float32 = this.__data_float32;
 
         const a_x0 = float32[address_a];
-        const b_x0 = float32[address_b];
-        const x0 = min2(a_x0, b_x0);
-
         const a_y0 = float32[address_a + 1];
-        const b_y0 = float32[address_b + 1];
-        const y0 = min2(a_y0, b_y0);
-
         const a_z0 = float32[address_a + 2];
-        const b_z0 = float32[address_b + 2];
-        const z0 = min2(a_z0, b_z0);
-
         const a_x1 = float32[address_a + 3];
-        const b_x1 = float32[address_b + 3];
-        const x1 = max2(a_x1, b_x1);
-
         const a_y1 = float32[address_a + 4];
-        const b_y1 = float32[address_b + 4];
-        const y1 = max2(a_y1, b_y1);
-
         const a_z1 = float32[address_a + 5];
+
+        const b_x0 = float32[address_b];
+        const b_y0 = float32[address_b + 1];
+        const b_z0 = float32[address_b + 2];
+        const b_x1 = float32[address_b + 3];
+        const b_y1 = float32[address_b + 4];
         const b_z1 = float32[address_b + 5];
+
+        const x0 = min2(a_x0, b_x0);
+        const y0 = min2(a_y0, b_y0);
+        const z0 = min2(a_z0, b_z0);
+        const x1 = max2(a_x1, b_x1);
+        const y1 = max2(a_y1, b_y1);
         const z1 = max2(a_z1, b_z1);
 
 
@@ -52778,8 +52719,6 @@ class BVH {
         const uint32 = this.__data_uint32;
 
         do {
-            index = this.balance(index);
-
             const address = index * ELEMENT_WORD_COUNT;
 
             const child1 = uint32[address + COLUMN_CHILD_1];
@@ -55143,7 +55082,7 @@ function mortonEncode_magicbits(x, y, z) {
  * @param {number} x
  * @param {number} y
  * @param {number} z
- * @param {number[]} bounds
+ * @param {number[]|AABB3} bounds
  * @returns {number}
  */
 function v3_morton_encode_bounded(x, y, z, bounds) {
@@ -59801,34 +59740,35 @@ function collectIteratorValueToArray(result, iterator) {
  * @return {number}
  */
 function ctz32(x) {
+    let _x = x;
     let n = 0;
 
-    if ((x & 0xffff) === 0) {
-        x >>= 16;
+    if ((_x & 0xffff) === 0) {
+        _x >>= 16;
         n += 16;
     }
 
-    if ((x & 0xff) === 0) {
-        x >>= 8;
+    if ((_x & 0xff) === 0) {
+        _x >>= 8;
         n += 8;
     }
 
-    if ((x & 0xf) === 0) {
-        x >>= 4;
+    if ((_x & 0xf) === 0) {
+        _x >>= 4;
         n += 4;
     }
 
-    if ((x & 0x3) === 0) {
-        x >>= 2;
+    if ((_x & 0x3) === 0) {
+        _x >>= 2;
         n += 2;
     }
 
-    if ((x & 0x1) === 0) {
-        x >>= 1;
+    if ((_x & 0x1) === 0) {
+        _x >>= 1;
         n += 1;
     }
 
-    if (x === 0) {
+    if (_x === 0) {
         n += 1;
     }
 
@@ -59862,6 +59802,7 @@ function invokeObjectHash(object) {
  * @param {number} index1
  */
 function array_swap_one(array, index0, index1) {
+
     const t = array[index0];
 
     array[index0] = array[index1];
@@ -59955,7 +59896,7 @@ const DEFAULT_INITIAL_CAPACITY_POWER = 4;
  * @readonly
  * @type {number}
  */
-const DEFAULT_INITIAL_CAPACITY = 2 ** DEFAULT_INITIAL_CAPACITY_POWER;
+const DEFAULT_INITIAL_CAPACITY$1 = 2 ** DEFAULT_INITIAL_CAPACITY_POWER;
 
 /**
  * @readonly
@@ -60084,7 +60025,7 @@ class HashMap {
     constructor({
                     keyHashFunction = invokeObjectHash,
                     keyEqualityFunction = invokeObjectEquals,
-                    capacity = DEFAULT_INITIAL_CAPACITY,
+                    capacity = DEFAULT_INITIAL_CAPACITY$1,
                     loadFactor = DEFAULT_LOAD_FACTOR
                 } = {}) {
 
@@ -67567,8 +67508,12 @@ function formatToChannelCount(format) {
         case RGFormat:
             return 2;
         case RGBFormat:
+        case RGB_S3TC_DXT1_Format:
             return 3;
         case RGBAFormat:
+        case RGBA_S3TC_DXT1_Format:
+        case RGBA_S3TC_DXT3_Format:
+        case RGBA_S3TC_DXT5_Format:
             return 4;
         default:
             throw new Error(`Unsupported format '${format}'`);
@@ -67966,13 +67911,15 @@ const CrossOriginKind = {
 };
 
 class CrossOriginConfig {
-    constructor() {
-        this.kind = CrossOriginKind.Anonymous;
-    }
-
+    kind = CrossOriginKind.Anonymous;
 }
 
 const default_coc = new CrossOriginConfig();
+
+/**
+ * @readonly
+ * @type {Readonly<CrossOriginConfig>}
+ */
 CrossOriginConfig.default = Object.freeze(default_coc);
 
 /**
@@ -70777,16 +70724,25 @@ const EntityFlags = {
     WatchDestruction: 4
 };
 
+/**
+ * Align to the nearest number divisible by 32, rounding up
+ * @param {number} n
+ * @returns {number}
+ */
+function align_32(n) {
+    return ((n + 31) >>> 5) << 5
+}
+
 /**
  * de Bruijn sequence
  * @see https://graphics.stanford.edu/~seander/bithacks.html
  * @type {Uint8Array}
  */
-const msb_lut = new Uint8Array([
+const msb_lut_de_bruijn = new Uint8Array([
     0, 1, 28, 2, 29, 14, 24, 3, 30, 22, 20, 15, 25, 17, 4, 8,
     31, 27, 13, 23, 21, 19, 16, 7, 26, 12, 18, 6, 11, 5, 10, 9
-]);
-
+]);
+
 /**
  * Get index of the least significant set bit
  * Also known as ctz32 or "count trailing zeroes"
@@ -70795,9 +70751,9 @@ const msb_lut = new Uint8Array([
  * @returns {number}
  */
 function lsb_32(v) {
-    return msb_lut[((v & -v) * 0x077CB531) >>> 27];
-}
-
+    return msb_lut_de_bruijn[((v & -v) * 0x077CB531) >>> 27];
+}
+
 /**
  * Used for overallocating space when bit set needs to grow
  * @constant
@@ -70818,12 +70774,20 @@ const SHRINK_FACTOR$1 = 0.5;
  */
 const RESIZE_COUNT_THRESHOLD = 128;
 
+/**
+ * @readonly
+ * @type {number}
+ */
+const DEFAULT_INITIAL_CAPACITY = 64;
+
 class BitSet {
     /**
      * Dynamically sized bit field
      * @constructor
+     * @param {number} [initial_capacity]
      */
-    constructor() {
+    constructor(initial_capacity = DEFAULT_INITIAL_CAPACITY) {
+
         /**
          * Number of bits currently in use
          * @private
@@ -70836,7 +70800,7 @@ class BitSet {
          * @private
          * @type {number}
          */
-        this.__capacity = 64;
+        this.__capacity = align_32(initial_capacity);
 
         /**
          * Uint32-backed storage
@@ -71362,9 +71326,7 @@ class BitSet {
      * @returns {BitSet}
      */
     static fixedSize(x) {
-        const r = new BitSet();
-
-        r.setCapacity(x);
+        const r = new BitSet(x);
 
         //prevent resizing
         r.__shrinkFactor = 0;
@@ -105088,13 +105050,6 @@ class EngineConfiguration {
     }
 }
 
-//
-
-
-function atan2(a, b) {
-    return Math.atan2(a, b);
-}
-
 /**
  *
  * @param {number[]} mat4
@@ -105106,15 +105061,9 @@ function coeff(mat4, row_index, column_index) {
     return mat4[row_index + column_index * 4];
 }
 
-function sin(a) {
-    return Math.sin(a);
-}
-
-function cos(a) {
-    return Math.cos(a);
-}
-
-const EIGEN_PI = Math.PI;
+const sin = Math.sin;
+const cos = Math.cos;
+const atan2 = Math.atan2;
 
 /**
  *
@@ -105139,10 +105088,14 @@ const EIGEN_PI = Math.PI;
  * @param {number[]} res
  * @param {number[]|Float32Array|mat4} m4
  * @param {number} a0 axis index
- * @param {number} a1
- * @param {number} a2
+ * @param {number} a1 axis index
+ * @param {number} a2 axis index
  */
-function eulerAnglesFromMatrix(res, m4, a0, a1, a2) {
+function eulerAnglesFromMatrix(
+    res, m4,
+    a0, a1, a2
+) {
+
     const odd = ((a0 + 1) % 3 === a1) ? 0 : 1;
 
     const i = a0;
@@ -105151,11 +105104,12 @@ function eulerAnglesFromMatrix(res, m4, a0, a1, a2) {
 
     if (a0 === a2) {
         res[0] = atan2(coeff(m4, j, i), coeff(m4, k, i));
-        if ((odd && res[0] < 0) || ((!odd) && res[0] > 0)) {
+
+        if ((odd && res[0] < 0) || ((~odd) && res[0] > 0)) {
             if (res[0] > 0) {
-                res[0] -= EIGEN_PI;
+                res[0] -= Math.PI;
             } else {
-                res[0] += EIGEN_PI;
+                res[0] += Math.PI;
             }
             const s2 = v2_magnitude(coeff(m4, j, i), coeff(m4, k, i));
             res[1] = -atan2(s2, coeff(m4, i, i));
@@ -105176,25 +105130,34 @@ function eulerAnglesFromMatrix(res, m4, a0, a1, a2) {
 
         const s1 = sin(res[0]);
         const c1 = cos(res[0]);
+
         res[2] = atan2(c1 * coeff(m4, j, k) - s1 * coeff(m4, k, k), c1 * coeff(m4, j, j) - s1 * coeff(m4, k, j));
+
     } else {
+
         res[0] = atan2(coeff(m4, j, k), coeff(m4, k, k));
+
         const c2 = v2_magnitude(coeff(m4, i, i), coeff(m4, i, j));
-        if ((odd && res[0] < 0) || ((!odd) && res[0] > 0)) {
+
+        if ((odd && res[0] < 0) || ((~odd) && res[0] > 0)) {
             if (res[0] > 0) {
-                res[0] -= EIGEN_PI;
+                res[0] -= Math.PI;
             } else {
-                res[0] += EIGEN_PI;
+                res[0] += Math.PI;
             }
             res[1] = atan2(-coeff(m4, i, k), -c2);
-        } else
+        } else {
             res[1] = atan2(-coeff(m4, i, k), c2);
+        }
+
         const s1 = sin(res[0]);
         const c1 = cos(res[0]);
+
         res[2] = atan2(s1 * coeff(m4, k, i) - c1 * coeff(m4, j, i), c1 * coeff(m4, j, j) - s1 * coeff(m4, k, j));
+
     }
 
-    if (!odd) {
+    if (odd === 0) {
         // invert result
         res[0] = -res[0];
         res[1] = -res[1];
@@ -118039,18 +118002,6 @@ function v4_dot(
     return (x0 * x1 + y0 * y1 + z0 * z1 + w0 * w1);
 }
 
-/**
- *
- * @param {number} x
- * @param {number} y
- * @param {number} z
- * @param {number} w
- * @returns {number}
- */
-function v4_length_sqr(x, y, z, w) {
-    return x * x + y * y + z * z + w * w;
-}
-
 /**
  *
  * @param {number} x0