@woosh/meep-engine 2.79.0 → 2.80.1

package/build/meep.cjs

@@ -2222,7 +2222,7 @@ let Vector3$1 = class Vector3 {
 
     /**
      *
-     * @param {number[]} array
+     * @param {number[]|Float32Array} array
      * @param {number} offset
      */
     readFromArray(array, offset = 0) {
@@ -2235,7 +2235,7 @@ let Vector3$1 = class Vector3 {
 
     /**
      *
-     * @param {number[]} array
+     * @param {number[]|Float32Array} array
      * @param {number} offset
      */
     writeToArray(array, offset = 0) {
@@ -77621,10 +77621,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) {
@@ -79232,46 +79233,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
@@ -79356,6 +79317,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
@@ -79484,7 +79485,7 @@ class AABB2 {
     /**
      *
      * @param {AABB2} other
-     * @returns {number}
+     * @returns {boolean}
      */
     overlapExists(other) {
         const ax0 = this.x0;
@@ -79511,6 +79512,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);
     }
@@ -79521,21 +79523,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);
     }
 
     /**
@@ -86069,7 +86058,7 @@ function computeStatisticalPartialMedian(values, start, end) {
 
     const range = end - start;
 
-    const position = (start + range) >> 1;
+    const position = start + (range >> 1);
 
     return copy[position];
 }
@@ -95345,23 +95334,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');
+    }
 
     /**
      *
@@ -95372,78 +95376,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);
@@ -95459,22 +95428,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;
     }
 }
 
@@ -106099,76 +106068,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
@@ -106404,6 +106303,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 {
     /**
      *
@@ -106418,6 +106392,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);
 
         /**
@@ -106492,7 +106468,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}
@@ -106576,9 +106553,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) {
 
@@ -106591,18 +106569,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() {