@woosh/meep-engine 2.79.0 → 2.80.0

package/build/meep.module.js

@@ -2220,7 +2220,7 @@ let Vector3$1 = class Vector3 {
 
     /**
      *
-     * @param {number[]} array
+     * @param {number[]|Float32Array} array
      * @param {number} offset
      */
     readFromArray(array, offset = 0) {
@@ -2233,7 +2233,7 @@ let Vector3$1 = class Vector3 {
 
     /**
      *
-     * @param {number[]} array
+     * @param {number[]|Float32Array} array
      * @param {number} offset
      */
     writeToArray(array, offset = 0) {
@@ -77619,10 +77619,11 @@ class ShadedGeometrySystem extends System {
 }
 
 /**
- *
+ * Given an object and a value, find the first property with matching value and returns name of that property
+ * Useful for working with ENUM-like objects
  * @param {Object<T>} object
  * @param {T} value
- * @returns {string|undefined}
+ * @returns {string|undefined} name of the property, or undefined if property not found
  */
 function objectKeyByValue(object, value) {
     for (let i in object) {
@@ -79230,46 +79231,6 @@ Stats.Panel = function ( name, fg, bg ) {
 
 };
 
-/**
- *
- * @param {number} ax0
- * @param {number} ay0
- * @param {number} ax1
- * @param {number} ay1
- * @param {number} bx0
- * @param {number} by0
- * @param {number} bx1
- * @param {number} by1
- * @param {AABB2} result
- * @returns {boolean} true if overlap exists, false if no overlap
- */
-function aabb2_compute_overlap(
-    ax0, ay0, ax1, ay1,
-    bx0, by0, bx1, by1,
-    result
-) {
-
-    const x0 = max2(ax0, bx0);
-    const x1 = min2(ax1, bx1);
-
-    if (x0 >= x1) {
-        //no overlap
-        return false;
-    }
-
-    const y0 = max2(ay0, by0);
-    const y1 = min2(ay1, by1);
-
-    if (y0 >= y1) {
-        //no overlap
-        return false;
-    }
-
-    result.set(x0, y0, x1, y1);
-
-    return true;
-}
-
 /**
  *
  * Find intersection point between two line segments if they intersect at all
@@ -79354,6 +79315,46 @@ function line_segment_compute_line_segment_intersection_2d(
     return collision;
 }
 
+/**
+ *
+ * @param {number} ax0
+ * @param {number} ay0
+ * @param {number} ax1
+ * @param {number} ay1
+ * @param {number} bx0
+ * @param {number} by0
+ * @param {number} bx1
+ * @param {number} by1
+ * @param {AABB2} result
+ * @returns {boolean} true if overlap exists, false if no overlap
+ */
+function aabb2_compute_overlap(
+    ax0, ay0, ax1, ay1,
+    bx0, by0, bx1, by1,
+    result
+) {
+
+    const x0 = max2(ax0, bx0);
+    const x1 = min2(ax1, bx1);
+
+    if (x0 >= x1) {
+        //no overlap
+        return false;
+    }
+
+    const y0 = max2(ay0, by0);
+    const y1 = min2(ay1, by1);
+
+    if (y0 >= y1) {
+        //no overlap
+        return false;
+    }
+
+    result.set(x0, y0, x1, y1);
+
+    return true;
+}
+
 /**
  * Created by Alex on 08/08/2016.
  * @copyright Alex Goldring 2016
@@ -79482,7 +79483,7 @@ class AABB2 {
     /**
      *
      * @param {AABB2} other
-     * @returns {number}
+     * @returns {boolean}
      */
     overlapExists(other) {
         const ax0 = this.x0;
@@ -79509,6 +79510,7 @@ class AABB2 {
     _expandToFit(x0, y0, x1, y1) {
         this.x0 = min2(this.x0, x0);
         this.y0 = min2(this.y0, y0);
+
         this.x1 = max2(this.x1, x1);
         this.y1 = max2(this.y1, y1);
     }
@@ -79519,21 +79521,8 @@ class AABB2 {
      * @param {number} y
      */
     _expandToFitPoint(x, y) {
-        if (x < this.x0) {
-            this.x0 = x;
-        }
-
-        if (x > this.x1) {
-            this.x1 = x;
-        }
-
-        if (y < this.y0) {
-            this.y0 = y;
-        }
-
-        if (y > this.y1) {
-            this.y1 = y;
-        }
+        // shortcut, use a 0-size box
+        this._expandToFit(x, y, x, y);
     }
 
     /**
@@ -95343,23 +95332,38 @@ class Clock {
  * Created by Alex on 06/05/2015.
  */
 
+/**
+ * Simulation tick generator
+ * Dispatches "tick" every animation frame or "maxDelay" time, whichever happens to be soonest
+ * This is essentially the timing bus that all the simulation systems subscribe to for their step advancement
+ */
 class Ticker {
     /**
      * @readonly
      * @type {Clock}
      */
     clock = new Clock();
+
     /**
      * @private
      * @type {boolean}
      */
-    isRunning = false;
+    #isRunning = false;
+
 
     /**
-     *
-     * @type {SignalHandler[]}
+     * Dispatches time delta in seconds since last tick
+     * @readonly
+     * @type {Signal<number>}
      */
-    callbacks = [];
+    onTick = new Signal();
+
+    /**
+     * @deprecated
+     */
+    get callbacks() {
+        throw new Error('deprecated, use onTick signal instead');
+    }
 
     /**
      *
@@ -95370,78 +95374,43 @@ class Ticker {
     }
 
     /**
-     *
+     * @deprecated use onTick signal directly instead
      * @param {function} callback
      * @param {*} [thisArg]
      */
     subscribe(callback, thisArg) {
-        const handler = new SignalHandler(callback, thisArg);
-
-        this.callbacks.push(handler);
+        this.onTick.add(callback, thisArg);
     }
 
     /**
-     *
+     * @deprecated use onTick signal directly instead
      * @param {function} callback
      * @param {*} [thisArg]
      */
     unsubscribe(callback, thisArg) {
-
-        const callbacks = this.callbacks;
-        const n = callbacks.length;
-        for (let i = 0; i < n; i++) {
-            const cb = callbacks[i];
-
-            if (cb.handle === callback) {
-                if (thisArg !== undefined) {
-                    if (thisArg === cb.context) {
-                        callbacks.splice(i, 1);
-                        return;
-                    }
-                } else {
-                    callbacks.splice(i, 1);
-                    return;
-                }
-            }
-        }
-
+        this.onTick.remove(callback, thisArg);
     }
 
     /**
      *
-     * @param {number} maxTimeout
+     * @param {number} [maxTimeout]
      */
     start({ maxTimeout = 100 } = {}) {
 
-
-        const self = this;
         let timeout = null;
         let animationFrame = null;
 
-        this.isRunning = true;
-
-        function update() {
-            if (self.isRunning) {
-
-                const delta = self.clock.getDelta();
-
-                const callbacks = self.callbacks;
+        this.#isRunning = true;
 
-                for (let i = 0; i < callbacks.length; i++) {
-                    const callback = callbacks[i];
-
-                    try {
-                        callback.handle.call(callback.context, delta);
-                    } catch (e) {
-                    }
-
-                }
+        const update = () => {
+            if (!this.#isRunning) {
+                return;
             }
-        }
 
-        function cycle() {
-            update();
-        }
+            const delta = this.clock.getDelta();
+
+            this.onTick.send1(delta);
+        };
 
         function timeoutCallback() {
             cancelAnimationFrame(animationFrame);
@@ -95457,22 +95426,22 @@ class Ticker {
 
         function animate() {
             animationFrame = requestAnimationFrame(animationFrameCallback);
-            cycle();
+            update();
             timeout = setTimeout(timeoutCallback, maxTimeout);
         }
 
-        self.clock.getDelta(); //purge delta
-        self.clock.start();
+        this.clock.getDelta(); //purge delta
+        this.clock.start();
 
         requestAnimationFrame(animationFrameCallback);
     }
 
     pause() {
-        this.isRunning = false;
+        this.#isRunning = false;
     }
 
     resume() {
-        this.isRunning = true;
+        this.#isRunning = true;
     }
 }
 
@@ -106097,76 +106066,6 @@ class QuadTreeNode extends AABB2 {
 
 }
 
-/**
- * Remove all rectangles that are fully contained within others
- * @param {QuadTreeNode} boxes
- */
-function removeRedundantBoxes(boxes) {
-    const removals = [];
-
-
-    let datum;
-
-    /**
-     *
-     * @param {QuadTreeDatum} intersection
-     */
-    function visitDatumIntersection(intersection) {
-        if (datum === intersection) {
-            //skip self
-            return;
-        }
-
-        const ax0 = intersection.x0;
-        const ay0 = intersection.y0;
-        const ax1 = intersection.x1;
-        const ay1 = intersection.y1;
-
-        const bx0 = datum.x0;
-        const by0 = datum.y0;
-        const bx1 = datum.x1;
-        const by1 = datum.y1;
-
-        //question is now whether it is containment
-        if (ax0 >= bx0 && ax1 <= bx1 && ay0 >= by0 && ay1 <= by1) {
-            //b contains a
-            removals.push(intersection);
-        } else if (bx0 >= ax0 && bx1 <= ax1 && by0 >= ay0 && by1 <= ay1) {
-            //a contains b
-            removals.push(datum);
-
-            //scheduled removal of the datum, prevent further traversal
-            return false;
-        }
-    }
-
-    /**
-     *
-     * @param {QuadTreeNode} node
-     */
-    function visitTreeNode(node) {
-        const data = node.data;
-        const dataCount = data.length;
-
-        for (let i = 0; i < dataCount; i++) {
-            /**
-             *
-             * @type {QuadTreeDatum}
-             */
-            datum = data[i];
-
-            node.traverseRectangleIntersections(datum.x0, datum.y0, datum.x1, datum.y1, visitDatumIntersection);
-        }
-    }
-
-    boxes.traversePreOrder(visitTreeNode);
-
-    for (let i = 0; i < removals.length; i++) {
-        const removal = removals[i];
-        removal.disconnect();
-    }
-}
-
 /**
  *
  * @param {number} containerWidth
@@ -106402,6 +106301,81 @@ function packOneBox(box, free) {
     return true;
 }
 
+/**
+ * Remove all rectangles that are fully contained within others
+ * @param {QuadTreeNode} boxes
+ */
+function removeRedundantBoxes(boxes) {
+    const removals = [];
+
+
+    let datum;
+
+    /**
+     *
+     * @param {QuadTreeDatum} intersection
+     */
+    function visitDatumIntersection(intersection) {
+        if (datum === intersection) {
+            //skip self
+            return;
+        }
+
+        const ax0 = intersection.x0;
+        const ay0 = intersection.y0;
+        const ax1 = intersection.x1;
+        const ay1 = intersection.y1;
+
+        const bx0 = datum.x0;
+        const by0 = datum.y0;
+        const bx1 = datum.x1;
+        const by1 = datum.y1;
+
+        //question is now whether it is containment
+        if (ax0 >= bx0 && ax1 <= bx1 && ay0 >= by0 && ay1 <= by1) {
+            //b contains a
+            removals.push(intersection);
+        } else if (bx0 >= ax0 && bx1 <= ax1 && by0 >= ay0 && by1 <= ay1) {
+            //a contains b
+            removals.push(datum);
+
+            //scheduled removal of the datum, prevent further traversal
+            return false;
+        }
+    }
+
+    /**
+     *
+     * @param {QuadTreeNode} node
+     */
+    function visitTreeNode(node) {
+        const data = node.data;
+        const dataCount = data.length;
+
+        for (let i = 0; i < dataCount; i++) {
+            /**
+             *
+             * @type {QuadTreeDatum}
+             */
+            datum = data[i];
+
+            node.traverseRectangleIntersections(datum.x0, datum.y0, datum.x1, datum.y1, visitDatumIntersection);
+        }
+    }
+
+    boxes.traversePreOrder(visitTreeNode);
+
+    for (let i = 0; i < removals.length; i++) {
+        const removal = removals[i];
+        removal.disconnect();
+    }
+}
+
+/**
+ * Packs rectangles into a finite area, packer is incremental and supports both insertions and removals of rectangles
+ * Implementation of "max rectangles" packing algorithm.
+ * Useful for packing texture atlases
+ */
 class MaxRectanglesPacker {
     /**
      *
@@ -106416,6 +106390,8 @@ class MaxRectanglesPacker {
          * @type {QuadTreeNode}
          */
         this.free = new QuadTreeNode(0, 0, width, height);
+
+        // initialize a with a free space occupying the entire area
         this.free.add(null, 0, 0, width, height);
 
         /**
@@ -106490,7 +106466,8 @@ class MaxRectanglesPacker {
     }
 
     /**
-     *
+     * Tests whether a rectangle of given dimensions can be packed into remaining space
+     * Essentially, if this method succeeds - insertion will succeed as well, and if it fails - insertion will fail too
      * @param {number} w
      * @param {number} h
      * @return {boolean}
@@ -106574,9 +106551,10 @@ class MaxRectanglesPacker {
     }
 
     /**
-     * Resize the packer canvas
+     * Resize the packer canvas, may trigger repacking if new dimensions are smaller than the existing ones
      * @param {number} width
      * @param {number} height
+     * @returns {boolean} false if packing fails after resize, true otherwise
      */
     resize(width, height) {
 
@@ -106589,18 +106567,20 @@ class MaxRectanglesPacker {
 
         if (oldWidth > width || oldHeight > height) {
             //canvas was made smaller in at least one dimension, re-pack is required
-            this.repack();
-        } else {
-            //canvas was enlarged, we can simply add new free areas
-            if (width > oldWidth) {
-                this.free.insertDatum(new QuadTreeDatum(oldWidth, 0, width, height));
-            }
-            if (height > oldHeight) {
-                this.free.insertDatum(new QuadTreeDatum(0, oldHeight, width, height));
-            }
+            return this.repack();
+        }
+
+        //canvas was enlarged, we can simply add new free areas
+        if (width > oldWidth) {
+            this.free.insertDatum(new QuadTreeDatum(oldWidth, 0, width, height));
+        }
+        if (height > oldHeight) {
+            this.free.insertDatum(new QuadTreeDatum(0, oldHeight, width, height));
         }
 
         // assert.ok(this.validate());
+
+        return true;
     }
 
     validate() {

package/package.json

@@ -5,7 +5,7 @@
   "description": "Fully featured ECS game engine written in JavaScript",
   "type": "module",
   "author": "Alexander Goldring",
-  "version": "2.79.0",
+  "version": "2.80.0",
   "main": "build/meep.module.js",
   "module": "build/meep.module.js",
   "exports": {

package/src/core/geom/2d/aabb/AABB2.js

@@ -9,11 +9,11 @@ import { clamp } from "../../../math/clamp.js";
 import { max2 } from "../../../math/max2.js";
 import { min2 } from "../../../math/min2.js";
 import Vector2 from "../../Vector2.js";
-import { aabb2_compute_overlap } from "./aabb2_compute_overlap.js";
-import { aabb2_overlap_exists } from "./aabb2_overlap_exists.js";
 import {
     line_segment_compute_line_segment_intersection_2d
 } from "../line/line_segment_compute_line_segment_intersection_2d.js";
+import { aabb2_compute_overlap } from "./aabb2_compute_overlap.js";
+import { aabb2_overlap_exists } from "./aabb2_overlap_exists.js";
 
 /**
  *
@@ -146,7 +146,7 @@ class AABB2 {
     /**
      *
      * @param {AABB2} other
-     * @returns {number}
+     * @returns {boolean}
      */
     overlapExists(other) {
         const ax0 = this.x0;
@@ -173,6 +173,7 @@ class AABB2 {
     _expandToFit(x0, y0, x1, y1) {
         this.x0 = min2(this.x0, x0);
         this.y0 = min2(this.y0, y0);
+
         this.x1 = max2(this.x1, x1);
         this.y1 = max2(this.y1, y1);
     }
@@ -183,21 +184,8 @@ class AABB2 {
      * @param {number} y
      */
     _expandToFitPoint(x, y) {
-        if (x < this.x0) {
-            this.x0 = x;
-        }
-
-        if (x > this.x1) {
-            this.x1 = x;
-        }
-
-        if (y < this.y0) {
-            this.y0 = y;
-        }
-
-        if (y > this.y1) {
-            this.y1 = y;
-        }
+        // shortcut, use a 0-size box
+        this._expandToFit(x, y, x, y);
     }
 
     /**

package/src/core/geom/3d/SurfacePoint3.spec.js

@@ -1,5 +1,5 @@
+import { MATRIX_4_IDENTITY } from "./mat4/MATRIX_4_IDENTITY.js";
 import { SurfacePoint3 } from "./SurfacePoint3.js";
-import { MATRIX_4_IDENTITY } from "./matrix/MATRIX_4_IDENTITY.js";
 
 
 test("equals", () => {

package/src/core/geom/3d/{matrix → mat4}/m4_multiply.spec.js

@@ -1,7 +1,6 @@
-import {MATRIX_4_IDENTITY} from "./MATRIX_4_IDENTITY.js";
-import {m4_multiply} from "./m4_multiply.js";
-import {m4_multiply_alphatensor} from "./m4_multiply_alphatensor.js";
-import {number_pretty_print} from "../../../primitives/numbers/number_pretty_print.js";
+import { number_pretty_print } from "../../../primitives/numbers/number_pretty_print.js";
+import { m4_multiply } from "./m4_multiply.js";
+import { MATRIX_4_IDENTITY } from "./MATRIX_4_IDENTITY.js";
 
 test("identity multiplication", () => {
 

package/src/core/geom/3d/{matrix → mat4}/m4_multiply_alphatensor.spec.js

@@ -1,6 +1,6 @@
-import {m4_multiply_alphatensor} from "./m4_multiply_alphatensor.js";
-import {MATRIX_4_IDENTITY} from "./MATRIX_4_IDENTITY.js";
-import {number_pretty_print} from "../../../primitives/numbers/number_pretty_print.js";
+import { number_pretty_print } from "../../../primitives/numbers/number_pretty_print.js";
+import { m4_multiply_alphatensor } from "./m4_multiply_alphatensor.js";
+import { MATRIX_4_IDENTITY } from "./MATRIX_4_IDENTITY.js";
 
 test("identity multiplication", () => {
 

package/src/core/geom/3d/morton/v3_morton_encode_transformed.spec.js

@@ -1,5 +1,5 @@
+import { MATRIX_4_IDENTITY } from "../mat4/MATRIX_4_IDENTITY.js";
 import { v3_morton_encode_transformed } from "./v3_morton_encode_transformed.js";
-import { MATRIX_4_IDENTITY } from "../matrix/MATRIX_4_IDENTITY.js";
 
 test("valid number with identity transform", () => {
     const v = v3_morton_encode_transformed(0, 0, 0, MATRIX_4_IDENTITY);

package/src/core/geom/3d/sphere/sphere_radius_sqr_from_v3_array_transformed.spec.js

@@ -1,5 +1,5 @@
+import { MATRIX_4_IDENTITY } from "../mat4/MATRIX_4_IDENTITY.js";
 import { sphere_radius_sqr_from_v3_array_transformed } from "./sphere_radius_sqr_from_v3_array_transformed.js";
-import { MATRIX_4_IDENTITY } from "../matrix/MATRIX_4_IDENTITY.js";
 
 test("base case", () => {
     expect(sphere_radius_sqr_from_v3_array_transformed([0, 0, 0], 3, MATRIX_4_IDENTITY)).toBe(0);

package/src/core/geom/Vector3.js

@@ -37,7 +37,7 @@ class Vector3 {
 
     /**
      *
-     * @param {number[]} array
+     * @param {number[]|Float32Array} array
      * @param {number} offset
      */
     readFromArray(array, offset = 0) {
@@ -50,7 +50,7 @@ class Vector3 {
 
     /**
      *
-     * @param {number[]} array
+     * @param {number[]|Float32Array} array
      * @param {number} offset
      */
     writeToArray(array, offset = 0) {

package/src/core/geom/Vector3.spec.js

@@ -1,5 +1,5 @@
-import {MATRIX_4_IDENTITY} from "./3d/matrix/MATRIX_4_IDENTITY.js";
-import {v3_slerp} from "./vec3/v3_slerp.js";
+import { MATRIX_4_IDENTITY } from "./3d/mat4/MATRIX_4_IDENTITY.js";
+import { v3_slerp } from "./vec3/v3_slerp.js";
 import Vector3 from "./Vector3.js";
 
 test('slerp', () => {