@woosh/meep-engine 2.94.2 → 2.94.4

package/build/meep.cjs

@@ -504,6 +504,19 @@ assert.isFunction = function (value, name = 'value') {
     }
 };
 
+/**
+ *
+ * @param {Object|*} value
+ * @param {string} [name]
+ */
+assert.isObject = function (value, name = 'value') {
+    const typeofValue = typeof value;
+
+    if (typeofValue !== 'object') {
+        throw new Error(`expected ${name} to be an object, instead was '${typeofValue}'(=${value})`);
+    }
+};
+
 /**
  *
  * @param {number|*} value
@@ -1725,6 +1738,23 @@ function clamp$1(value, min, max) {
     }
 }
 
+/**
+ * Clamps a value to 0..1 range
+ * Same as `clamp(value, 0, 1)`
+ * Works the same as `saturate` function in GLSL
+ * @param {number} value
+ * @returns {number}
+ */
+function clamp01(value) {
+    if (value < 0) {
+        return 0;
+    } else if (value > 1) {
+        return 1;
+    } else {
+        return value;
+    }
+}
+
 /**
  * Very small value, used for comparison when compensation for rounding error is required
  * @type {number}
@@ -1754,16 +1784,6 @@ 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
@@ -4254,23 +4274,23 @@ let Quaternion$1 = class Quaternion {
         this.set(x, y, z, w);
     }
 
-
     /**
-     * @see https://github.com/toji/gl-matrix/blob/master/src/gl-matrix/quat.js
-     * @param {Quaternion} other
+     *
+     * @param {Quaternion} from
+     * @param {Quaternion} to
      * @param {number} t
      */
-    slerp(other, t) {
+    slerpQuaternions(from, to, t) {
 
-        const ax = this.x,
-            ay = this.y,
-            az = this.z,
-            aw = this.w;
+        const ax = from.x,
+            ay = from.y,
+            az = from.z,
+            aw = from.w;
 
-        let bx = other.x,
-            by = other.y,
-            bz = other.z,
-            bw = other.w;
+        let bx = to.x,
+            by = to.y,
+            bz = to.z,
+            bw = to.w;
 
         let omega, cosom, sinom, scale0, scale1;
 
@@ -4308,6 +4328,16 @@ let Quaternion$1 = class Quaternion {
         this.set(_x, _y, _z, _w);
     }
 
+
+    /**
+     * @see https://github.com/toji/gl-matrix/blob/master/src/gl-matrix/quat.js
+     * @param {Quaternion} other
+     * @param {number} t
+     */
+    slerp(other, t) {
+        this.slerpQuaternions(this, other, t);
+    }
+
     /**
      * @see https://github.com/gareth-cross/quat/blob/master/include/quaternion.hpp
      * TODO implement
@@ -4589,9 +4619,9 @@ let Quaternion$1 = class Quaternion {
 
     /**
      *
-     * @param {number} x
-     * @param {number} y
-     * @param {number} z
+     * @param {number} x in radians
+     * @param {number} y in radians
+     * @param {number} z in radians
      * @returns {Quaternion}
      */
     static fromEulerAngles(x, y, z) {
@@ -4618,9 +4648,9 @@ let Quaternion$1 = class Quaternion {
             result.copy(to);
         } else {
             // clamp to 1, to make sure we don't overshoot
-            const t = min2(1, max_delta / angle);
+            const t = clamp01(max_delta / angle);
 
-            from.slerp(to, t);
+            result.slerpQuaternions(from, to, t);
         }
 
     }
@@ -5003,6 +5033,24 @@ class Transform {
     toString() {
         return `{ position: ${this.position}, rotation: ${this.rotation}, scale: ${this.scale} }`;
     }
+
+    /**
+     * @deprecated use {@link Quaternion.rotateTowards} instead
+     * @param {Quaternion} sourceQuaternion
+     * @param {Vector3} targetVector
+     * @param {Number} limit
+     */
+    static adjustRotation(
+        sourceQuaternion,
+        targetVector,
+        limit = Infinity
+    ) {
+        const q = new Quaternion$1();
+
+        q.lookRotation(targetVector);
+
+        sourceQuaternion.rotateTowards(q, limit);
+    }
 }
 
 /**
@@ -5015,22 +5063,7 @@ Transform.typeName = "Transform";
  * @readonly
  * @type {boolean}
  */
-Transform.prototype.isTransform = true;
-
-
-/**
- * @deprecated use {@link Quaternion.rotateTowards} instead
- * @param {Quaternion} sourceQuaternion
- * @param {Vector3} targetVector
- * @param {Number} limit
- */
-Transform.adjustRotation = function (sourceQuaternion, targetVector, limit = Infinity) {
-    const q = new Quaternion$1();
-
-    q.lookRotation(targetVector);
-
-    sourceQuaternion.rotateTowards(q, limit);
-};
+Transform.prototype.isTransform = true;
 
 /**
  * Common utilities
@@ -47277,6 +47310,16 @@ function max2(a, b) {
     return a < b ? b : 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} x
@@ -53302,23 +53345,6 @@ function bvh_query_leaves_ray(
     return result_cursor - result_offset;
 }
 
-/**
- * Clamps a value to 0..1 range
- * Same as `clamp(value, 0, 1)`
- * Works the same as `saturate` function in GLSL
- * @param {number} value
- * @returns {number}
- */
-function clamp01(value) {
-    if (value < 0) {
-        return 0;
-    } else if (value > 1) {
-        return 1;
-    } else {
-        return value;
-    }
-}
-
 /**
  * Returns lowest value out of 3 supplied
  * @param {number} a
@@ -70088,7 +70114,7 @@ BitSet.prototype.nextSetBit = function (fromIndex) {
 
 
     //scan the rest of the words
-    const word_count = bit_length / 32;
+    const word_count = (bit_length + 31) >> 5; // Math.ceil(x /32)
     for (; word_index < word_count; word_index++) {
         word = data[word_index];
 
@@ -70124,8 +70150,6 @@ BitSet.prototype.nextClearBit = function (fromIndex) {
     // treat first word specially, as we may need to mask out portion of a word to skip certain number of bits
     let bit_index = fromIndex & 31;
 
-    const set_length = this.__length;
-    const word_count = set_length / 32;
     const data = this.__data_uint32;
 
     if (bit_index !== 0) {
@@ -70145,6 +70169,8 @@ BitSet.prototype.nextClearBit = function (fromIndex) {
 
         word_index++;
     }
+    const set_length = this.__length;
+    const word_count = (set_length + 31) >> 5; // Math.ceil(x /32)
 
     //scan the rest
     for (; word_index < word_count; word_index++) {
@@ -113613,12 +113639,13 @@ function resolvePathByArray(object, parts, missingPropertyHandler) {
 /**
  *
  * @param {object} object
- * @param {string} path
+ * @param {string} path separated with forward slash "/"
  * @param {function} [missingPropertyHandler] Allows custom handling of missing properties
  * @returns {*}
  * @throws {Error} if a path can not be resolved
  */
 function resolvePath(object, path, missingPropertyHandler) {
+
     const parts = path.split("/");
 
     return resolvePathByArray(object, parts, missingPropertyHandler);