@woosh/meep-engine 2.109.23 → 2.109.25

package/build/meep.module.js

@@ -84588,10 +84588,23 @@ class ViewStack extends View {
 }
 
 /**
- * Min-Heap implementation with a score function. The data structure is a binary heap where elements are removed in order defined by scoring function
+ * Min-Heap implementation with a score function.
+ * The data structure is a binary heap where elements are removed in order defined by scoring function
  * @template T
  */
-class BinaryHeap {
+class FastBinaryHeap {
+    /**
+     * @private
+     * @type {T[]}
+     */
+    data = [];
+
+    /**
+     * @private
+     * @type {number}
+     */
+    length = 0;
+
     /**
      * @template T
      * @param {function(el:T):number} scoreFunction
@@ -84605,17 +84618,6 @@ class BinaryHeap {
          */
         this.scoreFunction = scoreFunction;
 
-        /**
-         *
-         * @type {T[]}
-         */
-        this.data = [];
-
-        /**
-         * @private
-         * @type {number}
-         */
-        this.length = 0;
     }
 
     /**
@@ -84685,19 +84687,19 @@ class BinaryHeap {
             if (right >= length) {
                 //right node doesn't exist
 
-
                 if (scoreLeft >= scoreMin) {
                     break;
                 } else {
                     minIndex = left;
                     dataMin = dataLeft;
                 }
+
             } else {
+
                 //both left and right nodes exist
                 const dataRight = data[right];
                 const scoreRight = this.scoreFunction(dataRight);
 
-                //
                 if (scoreLeft <= scoreRight) {
                     if (scoreLeft >= scoreMin) {
                         break;
@@ -84713,6 +84715,7 @@ class BinaryHeap {
                         dataMin = dataRight;
                     }
                 }
+
             }
 
             //swap positions
@@ -84730,7 +84733,6 @@ class BinaryHeap {
      */
     pop() {
 
-
         this.length--;
 
         const new_length = this.length;
@@ -84739,19 +84741,20 @@ class BinaryHeap {
 
         if (new_length === 0) {
 
+            // this was the last element in the heap
+
             return last;
 
-        } else {
+        }
 
-            const ret = this.data[0];
+        const ret = this.data[0];
 
-            this.data[0] = last;
+        this.data[0] = last;
 
-            this.bubbleDown(0);
+        this.bubbleDown(0);
 
-            return ret;
+        return ret;
 
-        }
     }
 
     /**
@@ -84853,7 +84856,14 @@ class BinaryHeap {
 
         this.bubbleUp(position);
     }
-}
+}
+
+/**
+ * Useful for type checks
+ * @readonly
+ * @type {boolean}
+ */
+FastBinaryHeap.prototype.isFastBinaryHeap = true;
 
 /**
  * Decorator that wraps another map and lets you observe mutations
@@ -86043,7 +86053,7 @@ let Response$1 = class Response {
 };
 
 /**
- * Used by the priority queue, so the priority is inverted as the BinaryHeap returns elements in ascending score order (from lowest)
+ * Used by the priority queue, so the priority is inverted as the FastBinaryHeap returns elements in ascending score order (from lowest)
  * @param {PendingAsset} pending_asset
  * @returns {number}
  */
@@ -86078,7 +86088,7 @@ class AssetManager {
      * @type {BinaryHeap<PendingAsset>}
      * @private
      */
-    #pending_asset_wait_queue = new BinaryHeap(get_pending_asset_priority_score);
+    #pending_asset_wait_queue = new FastBinaryHeap(get_pending_asset_priority_score);
     /**
      * Assets currently being processed by #loaders
      * @type {Set<PendingAsset>}
@@ -91137,6 +91147,59 @@ class InputDeviceSwitch {
      * @type {boolean}
      */
     is_down = false
+
+    press() {
+        if (this.is_down) {
+            return;
+        }
+
+        this.is_down = true;
+        this.down.send0();
+    }
+
+    release() {
+        if (!this.is_down) {
+            return;
+        }
+
+        this.is_down = false;
+        this.up.send0();
+    }
+}
+
+/**
+ *
+ * @param thing
+ * @param klass
+ * @returns {boolean}
+ */
+function isInstanceOf$1(thing, klass) {
+    if (klass === undefined) {
+        return false;
+    }
+    if (klass === null) {
+        return false;
+    }
+
+    if (typeof klass !== "object") {
+        return false;
+    }
+
+
+    return thing instanceof klass;
+}
+
+/**
+ * Based on the article about focusable events: https://stackoverflow.com/questions/1599660/which-html-elements-can-receive-focus
+ * @param {Element} el
+ */
+function isHTMLElementFocusable(el) {
+    return isInstanceOf$1(el, HTMLInputElement)
+        || isInstanceOf$1(el, HTMLSelectElement)
+        || isInstanceOf$1(el, HTMLTextAreaElement)
+        || isInstanceOf$1(el, HTMLAnchorElement)
+        || isInstanceOf$1(el, HTMLButtonElement)
+        || isInstanceOf$1(el, HTMLAreaElement)
 }
 
 /**
@@ -91246,41 +91309,6 @@ const KeyCodes = {
     'back_quote': 223
 };
 
-/**
- *
- * @param thing
- * @param klass
- * @returns {boolean}
- */
-function isInstanceOf$1(thing, klass) {
-    if (klass === undefined) {
-        return false;
-    }
-    if (klass === null) {
-        return false;
-    }
-
-    if (typeof klass !== "object") {
-        return false;
-    }
-
-
-    return thing instanceof klass;
-}
-
-/**
- * Based on the article about focusable events: https://stackoverflow.com/questions/1599660/which-html-elements-can-receive-focus
- * @param {Element} el
- */
-function isFocusable(el) {
-    return isInstanceOf$1(el, HTMLInputElement)
-        || isInstanceOf$1(el, HTMLSelectElement)
-        || isInstanceOf$1(el, HTMLTextAreaElement)
-        || isInstanceOf$1(el, HTMLAnchorElement)
-        || isInstanceOf$1(el, HTMLButtonElement)
-        || isInstanceOf$1(el, HTMLAreaElement)
-}
-
 /**
  * @readonly
  * @type {string[]}
@@ -91313,7 +91341,7 @@ class KeyboardDevice {
         Only element in focus receives keyboard events, so the element supplied here must be focusable in order to be able to receive events
          */
         if (
-            !isFocusable(domElement)
+            !isHTMLElementFocusable(domElement)
             && domElement.getAttribute('tabindex') === null
         ) ;
 
@@ -91357,9 +91385,7 @@ class KeyboardDevice {
         if (keyName !== undefined) {
             const button = this.keys[keyName];
 
-            button.is_down = true;
-            button.down.send1(event);
-
+            button.press();
         }
     }
 
@@ -91379,8 +91405,7 @@ class KeyboardDevice {
         if (keyName !== undefined) {
             const button = this.keys[keyName];
 
-            button.is_down = false;
-            button.up.send1(event);
+            button.release();
         }
     }
 
@@ -91427,6 +91452,60 @@ const TouchEvents = {
     Cancel: "touchcancel",
 };
 
+/**
+ *
+ * @param {TouchEvent|MouseEvent} event
+ * @returns {number}
+ */
+function eventToSourceIdentifier(event) {
+    let device_id = 0;
+    let source_id = 0;
+
+    if (event instanceof MouseEvent) {
+
+        // mouse
+
+        device_id = 1;
+        source_id = event.button;
+
+    } else if (event instanceof TouchEvent) {
+
+        // touch
+
+        device_id = 2;
+        const touches = event.changedTouches;
+        const num_changes = touches.length;
+
+        if (num_changes > 0) {
+            const touch = touches.item(0);
+
+            source_id = touch.identifier;
+        }
+
+    }
+
+    return ((device_id & 0b11) << 29)
+        | (source_id & 0b11111111111111111111111111111)
+        ;
+}
+
+class LocationalInteractionMetadata {
+    timestamp = performance.now()
+    position = new Vector2()
+
+    /**
+     *
+     * @param {Vector2} p
+     */
+    static from(p) {
+        const r = new LocationalInteractionMetadata();
+
+        r.position.copy(p);
+
+        return r;
+    }
+}
+
 /**
  * @see https://developer.mozilla.org/en-US/docs/Web/API/MouseEvent/buttons
  * @see https://w3c.github.io/uievents/#widl-MouseEvent-buttons
@@ -91504,6 +91583,7 @@ function getTouchCenter(touchList, result) {
 
 }
 
+
 /**
  *
  * @param {Signal} up
@@ -91512,13 +91592,49 @@ function getTouchCenter(touchList, result) {
  * @param {number} maxDistance
  * @param {Signal} signal
  */
-function observeTap(up, down, move, maxDistance, signal) {
+function observeTap(
+    up,
+    down,
+    move,
+    maxDistance,
+    signal
+) {
 
-    const origin = new Vector2();
+    /**
+     *
+     * @type {Map<number, LocationalInteractionMetadata>}
+     */
+    const active = new Map();
+
+    /**
+     *
+     * @param {number} id
+     */
+    function reset(id) {
+
+        if (active.delete(id)) {
+            up.remove(handleUp);
+            move.remove(handleMove);
+        }
+    }
 
+    /**
+     *
+     * @param {Vector2} position
+     * @param {MouseEvent|TouchEvent} event
+     */
     function handleUp(position, event) {
-        up.remove(handleUp);
-        move.remove(handleMove);
+        const id = eventToSourceIdentifier(event);
+
+        const meta = active.get(id);
+
+        if (meta === undefined) {
+            // this should not happen
+            return;
+        }
+
+        reset(id);
+
         signal.send2(position, event);
     }
 
@@ -91528,20 +91644,42 @@ function observeTap(up, down, move, maxDistance, signal) {
      * @param {MouseEvent|TouchEvent} event
      */
     function handleMove(position, event) {
-        if (origin.distanceTo(position) > maxDistance) {
-            //we moved too far, abort tap
-            move.remove(handleMove);
+        const id = eventToSourceIdentifier(event);
 
-            up.remove(handleUp);
+        const meta = active.get(id);
+
+        if (meta === undefined) {
+            // this should not happen
+
+            reset(id);
+
+            return;
+        }
+
+        if (meta.position.distanceTo(position) > maxDistance) {
+            //we moved too far, abort tap
+            reset(id);
         }
+
     }
 
-    function handleDown(position) {
+    /**
+     *
+     * @param {Vector2} position
+     * @param {TouchEvent|MouseEvent} event
+     */
+    function handleDown(position, event) {
+        const id = eventToSourceIdentifier(event);
+
+        // make sure to cancel previous pending resolution
+        reset(id);
+
+        active.set(id, LocationalInteractionMetadata.from(position));
+
         up.addOne(handleUp);
+
         //track move
         move.add(handleMove);
-
-        origin.copy(position);
     }
 
     down.add(handleDown);
@@ -91852,17 +91990,11 @@ class PointerDevice {
         this.#domElement = domElement;
 
 
-        this.#touchStart.add((param0, param1, param2) => {
-            this.on.down.send3(param0, param1, param2);
-        });
+        this.#touchStart.add(this.on.down.send3, this.on.down);
 
-        this.#touchEnd.add((param0, param1, param2) => {
-            this.on.up.send3(param0, param1, param2);
-        });
-        this.#touchMove.add((param0, param1, param2) => {
-            this.on.move.send3(param0, param1, param2);
-        });
+        this.#touchEnd.add(this.on.up.send3, this.on.up);
 
+        this.#touchMove.add(this.on.move.send3, this.on.move);
 
         //constructed events
         observeTap(this.on.up, this.on.down, this.on.move, 10, this.on.tap);
@@ -91878,6 +92010,16 @@ class PointerDevice {
         });
     }
 
+
+    /**
+     *
+     * @param {TouchEvent} event
+     */
+    #eventHandlerGlobalTouchEnd = (event) => {
+        getTouchCenter(event.touches, this.position);
+        this.#globalUp.send2(this.position, event);
+    }
+
     /**
      *
      * @param {MouseEvent} event
@@ -91891,19 +92033,7 @@ class PointerDevice {
 
         const button = this.buttons[button_index];
 
-        if (button !== undefined) {
-            button.is_down = true;
-            button.down.send0();
-        }
-    }
-
-    /**
-     *
-     * @param {TouchEvent} event
-     */
-    #eventHandlerGlobalTouchEnd = (event) => {
-        getTouchCenter(event.touches, this.position);
-        this.#globalUp.send2(this.position, event);
+        button?.press();
     }
 
     /**
@@ -91928,10 +92058,7 @@ class PointerDevice {
 
         const button = this.buttons[button_index];
 
-        if (button !== undefined) {
-            button.is_down = false;
-            button.up.send0();
-        }
+        button?.release();
     }
 
     /**
@@ -108035,7 +108162,7 @@ class MaxRectanglesPacker {
             return -Math.min(box.getWidth(), box.getHeight());
         }
 
-        const heap = new BinaryHeap(scoreBoxByMinSide);
+        const heap = new FastBinaryHeap(scoreBoxByMinSide);
 
         for (let i = 0; i < numBoxes; i++) {
             heap.push(i);

package/package.json

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

package/src/core/collection/heap/FastBinaryHeap.d.ts

@@ -1,9 +1,10 @@
-export default BinaryHeap;
+export default FastBinaryHeap;
 /**
- * Min-Heap implementation with a score function. The data structure is a binary heap where elements are removed in order defined by scoring function
+ * Min-Heap implementation with a score function.
+ * The data structure is a binary heap where elements are removed in order defined by scoring function
  * @template T
  */
-declare class BinaryHeap<T> {
+declare class FastBinaryHeap<T> {
     /**
      * @template T
      * @param {function(el:T):number} scoreFunction
@@ -11,20 +12,20 @@ declare class BinaryHeap<T> {
      */
     constructor(scoreFunction: any);
     /**
-     *
-     * @type {function(T): number}
-     */
-    scoreFunction: (arg0: T_1) => number;
-    /**
-     *
+     * @private
      * @type {T[]}
      */
-    data: T_1[];
+    private data;
     /**
      * @private
      * @type {number}
      */
     private length;
+    /**
+     *
+     * @type {function(T): number}
+     */
+    scoreFunction: (arg0: T_1) => number;
     /**
      * @private
      * @param {number} pos
@@ -87,5 +88,11 @@ declare class BinaryHeap<T> {
      * @param {T} el
      */
     push(el: T): void;
+    /**
+     * Useful for type checks
+     * @readonly
+     * @type {boolean}
+     */
+    readonly isFastBinaryHeap: boolean;
 }
 //# sourceMappingURL=FastBinaryHeap.d.ts.map

package/src/core/collection/heap/FastBinaryHeap.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"FastBinaryHeap.d.ts","sourceRoot":"","sources":["../../../../../src/core/collection/heap/FastBinaryHeap.js"],"names":[],"mappings":";AAEA;;;GAGG;AACH;IACI;;;;OAIG;IACH,gCAmBC;IAjBG;;;OAGG;IACH,8BAFuB,MAAM,CAEK;IAElC;;;OAGG;IACH,YAAc;IAEd;;;OAGG;IACH,eAAe;IAGnB;;;OAGG;IACH,iBA8BC;IAED;;;OAGG;IACH,mBAkEC;IAED;;;OAGG;IACH,OAFY,CAAC,CA0BZ;IAED;;;OAGG;IACH,QAFa,CAAC,GAAC,SAAS,CAIvB;IAED;;;;OAIG;IACH,aAHW,CAAC,GACC,OAAO,CAYnB;IAED;;;OAGG;IACH,iBAFW,MAAM,QAOhB;IAED;;OAEG;IACH,cAGC;IAED;;;;OAIG;IACH,eAHW,CAAC,GACC,OAAO,CAKnB;IAED;;;OAGG;IACH,WAFa,OAAO,CAInB;IAED;;;OAGG;IACH,QAFa,MAAM,CAIlB;IAED;;;;OAIG;IACH,yBAHW,CAAC,GACC,OAAO,CAWnB;IAED;;;OAGG;IACH,SAFW,CAAC,QAUX;CACJ"}
+{"version":3,"file":"FastBinaryHeap.d.ts","sourceRoot":"","sources":["../../../../../src/core/collection/heap/FastBinaryHeap.js"],"names":[],"mappings":";AAEA;;;;GAIG;AACH;IAaI;;;;OAIG;IACH,gCAQC;IAzBD;;;OAGG;IACH,aAAU;IAEV;;;OAGG;IACH,eAAW;IASP;;;OAGG;IACH,8BAFuB,MAAM,CAEK;IAItC;;;OAGG;IACH,iBA8BC;IAED;;;OAGG;IACH,mBAmEC;IAED;;;OAGG;IACH,OAFY,CAAC,CA0BZ;IAED;;;OAGG;IACH,QAFa,CAAC,GAAC,SAAS,CAIvB;IAED;;;;OAIG;IACH,aAHW,CAAC,GACC,OAAO,CAYnB;IAED;;;OAGG;IACH,iBAFW,MAAM,QAOhB;IAED;;OAEG;IACH,cAGC;IAED;;;;OAIG;IACH,eAHW,CAAC,GACC,OAAO,CAKnB;IAED;;;OAGG;IACH,WAFa,OAAO,CAInB;IAED;;;OAGG;IACH,QAFa,MAAM,CAIlB;IAED;;;;OAIG;IACH,yBAHW,CAAC,GACC,OAAO,CAWnB;IAED;;;OAGG;IACH,SAFW,CAAC,QAUX;IAGL;;;;OAIG;IACH,2BAFU,OAAO,CAEwB;CAPxC"}

package/src/core/collection/heap/FastBinaryHeap.js

@@ -1,10 +1,23 @@
 import { assert } from "../../assert.js";
 
 /**
- * Min-Heap implementation with a score function. The data structure is a binary heap where elements are removed in order defined by scoring function
+ * Min-Heap implementation with a score function.
+ * The data structure is a binary heap where elements are removed in order defined by scoring function
  * @template T
  */
-class BinaryHeap {
+class FastBinaryHeap {
+    /**
+     * @private
+     * @type {T[]}
+     */
+    data = [];
+
+    /**
+     * @private
+     * @type {number}
+     */
+    length = 0;
+
     /**
      * @template T
      * @param {function(el:T):number} scoreFunction
@@ -18,17 +31,6 @@ class BinaryHeap {
          */
         this.scoreFunction = scoreFunction;
 
-        /**
-         *
-         * @type {T[]}
-         */
-        this.data = [];
-
-        /**
-         * @private
-         * @type {number}
-         */
-        this.length = 0;
     }
 
     /**
@@ -100,19 +102,19 @@ class BinaryHeap {
             if (right >= length) {
                 //right node doesn't exist
 
-
                 if (scoreLeft >= scoreMin) {
                     break;
                 } else {
                     minIndex = left;
                     dataMin = dataLeft;
                 }
+
             } else {
+
                 //both left and right nodes exist
                 const dataRight = data[right];
                 const scoreRight = this.scoreFunction(dataRight);
 
-                //
                 if (scoreLeft <= scoreRight) {
                     if (scoreLeft >= scoreMin) {
                         break;
@@ -128,6 +130,7 @@ class BinaryHeap {
                         dataMin = dataRight;
                     }
                 }
+
             }
 
             //swap positions
@@ -145,7 +148,6 @@ class BinaryHeap {
      */
     pop() {
 
-
         this.length--;
 
         const new_length = this.length;
@@ -154,19 +156,20 @@ class BinaryHeap {
 
         if (new_length === 0) {
 
+            // this was the last element in the heap
+
             return last;
 
-        } else {
+        }
 
-            const ret = this.data[0];
+        const ret = this.data[0];
 
-            this.data[0] = last;
+        this.data[0] = last;
 
-            this.bubbleDown(0);
+        this.bubbleDown(0);
 
-            return ret;
+        return ret;
 
-        }
     }
 
     /**
@@ -270,4 +273,11 @@ class BinaryHeap {
     }
 }
 
-export default BinaryHeap;
+/**
+ * Useful for type checks
+ * @readonly
+ * @type {boolean}
+ */
+FastBinaryHeap.prototype.isFastBinaryHeap = true;
+
+export default FastBinaryHeap;