@woosh/meep-engine 2.109.24 → 2.109.26

package/build/meep.cjs

@@ -71549,6 +71549,23 @@ class EntityObserver {
     }
 }
 
+/**
+ * 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} name of the property, or undefined if property not found
+ */
+function objectKeyByValue(object, value) {
+    for (let i in object) {
+        if (object[i] === value) {
+            return i;
+        }
+    }
+
+    return undefined;
+}
+
 /**
  *
  * @enum {number}
@@ -71665,6 +71682,10 @@ class Edge {
         return [this.first, this.second];
     }
 
+    toString() {
+        return `Edge:{ first=${this.first}, second=${this.second}, direction=${objectKeyByValue(EdgeDirectionType, this.direction)} }`
+    }
+
 }
 
 /**
@@ -78582,23 +78603,6 @@ 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} name of the property, or undefined if property not found
- */
-function objectKeyByValue(object, value) {
-    for (let i in object) {
-        if (object[i] === value) {
-            return i;
-        }
-    }
-
-    return undefined;
-}
-
 /**
  *
  * @enum {string}
@@ -84590,10 +84594,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 {
+    /**
+     * @private
+     * @type {T[]}
+     */
+    data = [];
+
+    /**
+     * @private
+     * @type {number}
+     */
+    length = 0;
+
     /**
      * @template T
      * @param {function(el:T):number} scoreFunction
@@ -84607,17 +84624,6 @@ class BinaryHeap {
          */
         this.scoreFunction = scoreFunction;
 
-        /**
-         *
-         * @type {T[]}
-         */
-        this.data = [];
-
-        /**
-         * @private
-         * @type {number}
-         */
-        this.length = 0;
     }
 
     /**
@@ -84687,19 +84693,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;
@@ -84715,6 +84721,7 @@ class BinaryHeap {
                         dataMin = dataRight;
                     }
                 }
+
             }
 
             //swap positions
@@ -84732,7 +84739,6 @@ class BinaryHeap {
      */
     pop() {
 
-
         this.length--;
 
         const new_length = this.length;
@@ -84741,19 +84747,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;
 
-        }
     }
 
     /**
@@ -84855,7 +84862,14 @@ class BinaryHeap {
 
         this.bubbleUp(position);
     }
-}
+}
+
+/**
+ * Useful for type checks
+ * @readonly
+ * @type {boolean}
+ */
+BinaryHeap.prototype.isBinaryHeap = true;
 
 /**
  * Decorator that wraps another map and lets you observe mutations
@@ -91139,6 +91153,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)
 }
 
 /**
@@ -91248,41 +91315,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[]}
@@ -91315,7 +91347,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
         ) ;
 
@@ -91359,9 +91391,7 @@ class KeyboardDevice {
         if (keyName !== undefined) {
             const button = this.keys[keyName];
 
-            button.is_down = true;
-            button.down.send1(event);
-
+            button.press();
         }
     }
 
@@ -91381,8 +91411,7 @@ class KeyboardDevice {
         if (keyName !== undefined) {
             const button = this.keys[keyName];
 
-            button.is_down = false;
-            button.up.send1(event);
+            button.release();
         }
     }
 
@@ -91397,6 +91426,43 @@ class KeyboardDevice {
     }
 }
 
+/**
+ *
+ * @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)
+        ;
+}
+
 /**
  * Event names for DOM {@link EventTarget} related to mouse.
  * useful for .addEventListener and .removeEventListener
@@ -91429,6 +91495,23 @@ const TouchEvents = {
     Cancel: "touchcancel",
 };
 
+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
@@ -91506,6 +91589,7 @@ function getTouchCenter(touchList, result) {
 
 }
 
+
 /**
  *
  * @param {Signal} up
@@ -91514,13 +91598,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);
     }
 
@@ -91530,20 +91650,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);
@@ -91854,17 +91996,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);
@@ -91880,6 +92016,16 @@ class PointerDevice {
         });
     }
 
+
+    /**
+     *
+     * @param {TouchEvent} event
+     */
+    #eventHandlerGlobalTouchEnd = (event) => {
+        getTouchCenter(event.touches, this.position);
+        this.#globalUp.send2(this.position, event);
+    }
+
     /**
      *
      * @param {MouseEvent} event
@@ -91893,19 +92039,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();
     }
 
     /**
@@ -91930,10 +92064,7 @@ class PointerDevice {
 
         const button = this.buttons[button_index];
 
-        if (button !== undefined) {
-            button.is_down = false;
-            button.up.send0();
-        }
+        button?.release();
     }
 
     /**