@woosh/meep-engine 2.94.2 → 2.94.5

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
@@ -1709,7 +1722,7 @@ function dispatchViaProxy(handlers, args) {
 }
 
 /**
- * Clamps a given value to the specified min/max range
+ * Constrain a value to lie between specified min/max values
  * @param {number} value
  * @param {number} min
  * @param {number} max
@@ -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
@@ -68353,6 +68379,12 @@ class System {
 
 }
 
+/**
+ * @readonly
+ * @type {boolean}
+ */
+System.prototype.isSystem = true;
+
 /**
  * Fixed update function, every step happens with the same exact time increment
  * useful for systems that must have a fixed time step to be predictable and stable, such as physics
@@ -70088,7 +70120,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 +70156,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 +70175,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++) {
@@ -74283,7 +74315,10 @@ function returnTrue() {
  * @param {number} z1
  * @returns {number}
  */
-function v3_distance_sqr(x0, y0, z0, x1, y1, z1) {
+function v3_distance_sqr(
+    x0, y0, z0,
+    x1, y1, z1
+) {
     const x = x0 - x1;
     const y = y0 - y1;
     const z = z0 - z1;
@@ -79699,10 +79734,24 @@ class AABB2 {
      * @param {Vector2} result
      */
     getCenter(result) {
-        result.set(
-            (this.x0 + this.x1) / 2,
-            (this.y0 + this.y1) / 2
-        );
+        result.set(this.centerX, this.centerY);
+    }
+
+    /**
+     *
+     * @return {number}
+     */
+    get centerX() {
+        return (this.x0 + this.x1) * 0.5;
+    }
+
+    /**
+     *
+     * @return {number}
+     */
+    get centerY() {
+
+        return (this.y0 + this.y1) * 0.5
     }
 
     /**
@@ -79713,6 +79762,14 @@ class AABB2 {
         return this.x1 - this.x0;
     }
 
+    /**
+     *
+     * @return {number}
+     */
+    get width() {
+        return this.getWidth();
+    }
+
     /**
      *
      * @returns {number}
@@ -79721,6 +79778,14 @@ class AABB2 {
         return this.y1 - this.y0;
     }
 
+    /**
+     *
+     * @return {number}
+     */
+    get height() {
+        return this.getHeight();
+    }
+
     /**
      *
      * @param {Number} x0
@@ -103911,6 +103976,7 @@ class EngineConfiguration {
      * @returns {boolean}
      */
     addSystem(system) {
+
         this.systems.push(system);
 
         return true;
@@ -103920,6 +103986,7 @@ class EngineConfiguration {
      * @param {System} systems
      */
     addManySystems(...systems) {
+
         systems.forEach(s => this.addSystem(s));
     }
 
@@ -113613,12 +113680,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);
@@ -115278,9 +115346,6 @@ class EngineHarness {
         terrain.splat.resize(1, 1, 1);
         terrain.splat.fillLayerWeights(0, 255);
 
-        terrain.build(engine.assetManager);
-
-
         const eb = new Entity();
 
         eb.add(new Transform());