@woosh/meep-engine 2.109.26 → 2.110.1

package/build/meep.module.js

@@ -54461,6 +54461,10 @@ class NumericInterval {
          */
         this.max = max;
 
+        /**
+         * @readonly
+         * @type {Signal<number, number, number, number>}
+         */
         this.onChanged = new Signal();
     }
 
@@ -54475,24 +54479,21 @@ class NumericInterval {
         const oldMin = this.min;
         const oldMax = this.max;
 
-        if (min !== oldMin || max !== oldMax) {
-            this.min = min;
-            this.max = max;
+        if (min === oldMin && max === oldMax) {
+            return;
+        }
 
-            if (this.onChanged.hasHandlers()) {
-                this.onChanged.send4(min, max, oldMin, oldMax);
-            }
+        this.min = min;
+        this.max = max;
+
+        if (!this.onChanged.hasHandlers()) {
+            return;
         }
-    }
 
-    /**
-     *
-     * @param {NumericInterval} other
-     */
-    copy(other) {
-        this.set(other.min, other.max);
+        this.onChanged.send4(min, max, oldMin, oldMax);
     }
 
+
     /**
      *
      * @param {number} value
@@ -54565,6 +54566,10 @@ class NumericInterval {
         };
     }
 
+    toString() {
+        return `NumericInterval{ min=${this.min}, max=${this.max} }`;
+    }
+
     /**
      *
      * @param {BinaryBuffer} buffer
@@ -54583,6 +54588,14 @@ class NumericInterval {
         this.max = buffer.readFloat64();
     }
 
+    /**
+     *
+     * @param {NumericInterval} other
+     */
+    copy(other) {
+        this.set(other.min, other.max);
+    }
+
     /**
      *
      * @param {NumericInterval} other
@@ -54623,12 +54636,19 @@ NumericInterval.prototype.isNumericInterval = true;
  * @readonly
  * @type {NumericInterval}
  */
-NumericInterval.one_one = Object.freeze(new NumericInterval(1, 1));
+NumericInterval.zero_zero = Object.freeze(new NumericInterval(0, 0));
+
+/**
+ * @readonly
+ * @type {NumericInterval}
+ */
+NumericInterval.zero_one = Object.freeze(new NumericInterval(0, 1));
+
 /**
  * @readonly
  * @type {NumericInterval}
  */
-NumericInterval.zero_zero = Object.freeze(new NumericInterval(0, 0));
+NumericInterval.one_one = Object.freeze(new NumericInterval(1, 1));
 
 /**
  *
@@ -71681,7 +71701,7 @@ class Edge {
     }
 
     toString() {
-        return `Edge:{ first=${this.first}, second=${this.second}, direction=${objectKeyByValue(EdgeDirectionType, this.direction)} }`
+        return `Edge{ first=${this.first}, second=${this.second}, direction=${objectKeyByValue(EdgeDirectionType, this.direction)} }`
     }
 
 }
@@ -84101,6 +84121,8 @@ class ConcurrentExecutor {
         task.state.set(TaskState.FAILED);
         task.on.failed.send1(reason);
 
+        if (!task.on.failed.hasHandlers()) ;
+
         this.resolveTasks();
 
         this.on.task_completed.send1(task);
@@ -84188,7 +84210,12 @@ class ConcurrentExecutor {
             try {
                 executionTime = this.#runTaskForTimeMonitored(task, sliceTimeLeft);
             } catch (e) {
-                this.#fail_task(task, e);
+                const error = new Error("Task threw an exception");
+
+                error.cause = e;
+
+                // console.error(`Task threw an exception`, task, e);
+                this.#fail_task(task, error);
             }
 
             this.#cycle_count++;
@@ -91424,41 +91451,16 @@ class KeyboardDevice {
     }
 }
 
+//Use highest available resolution time source
+const source = typeof performance === "undefined" ? Date : performance;
+
 /**
- *
- * @param {TouchEvent|MouseEvent} event
+ * Current time in seconds
  * @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)
-        ;
+function current_time_in_seconds() {
+    // time source produces value in milliseconds, we need to scale to seconds
+    return source.now() * 1e-3;
 }
 
 /**
@@ -91481,20 +91483,28 @@ const MouseEvents = {
 };
 
 /**
- * Event names for DOM {@link EventTarget} related to touch.
- * useful for .addEventListener and .removeEventListener
- * @readonly
+ *
  * @enum {string}
  */
-const TouchEvents = {
-    Start: "touchstart",
-    End: "touchend",
-    Move: "touchmove",
-    Cancel: "touchcancel",
+const PointerEvents = {
+    Up: "pointerup",
+    Down: "pointerdown",
+    Move: "pointermove",
+    Over: "pointerover",
+    Out: "pointerout",
+    Enter: "pointerenter",
+    Leave: "pointerleave",
+    Cancel: "pointercancel",
+    GotCapture: "gotpointercapture",
+    LostCapture: "lostpointercapture"
 };
 
 class LocationalInteractionMetadata {
-    timestamp = performance.now()
+    /**
+     * In seconds
+     * @type {number}
+     */
+    timestamp = current_time_in_seconds()
     position = new Vector2()
 
     /**
@@ -91510,99 +91520,35 @@ class LocationalInteractionMetadata {
     }
 }
 
-/**
- * @see https://developer.mozilla.org/en-US/docs/Web/API/MouseEvent/buttons
- * @see https://w3c.github.io/uievents/#widl-MouseEvent-buttons
- *
- * @param {Number} value
- * @return {boolean[]} array of booleans, boolean is true if mouse button is pressed, false otherwise
- */
-function decodeMouseEventButtons(value) {
-    const result = [];
-
-    for (let i = 0; i < 32; i++) {
-
-        const shiftedValue = value >> i;
-
-        result[i] = (shiftedValue & 1) !== 0;
-    }
-
-    return result;
-}
-
 /**
  * Prevent default context menu from showing up
  * @param {Event} event
+ * @returns {boolean}
  */
-function supressContextMenu(event) {
+function suppressContextMenu(event) {
     event.preventDefault();
     event.stopPropagation();
 
     return false;
-}
-
-/**
- *
- * @param {TouchList} touchList
- * @param {function(Touch,number)} callback
- */
-function forEachTouch(touchList, callback) {
-    const length = touchList.length;
-    for (let i = 0; i < length; i++) {
-        const touch = touchList.item(i);
-        callback(touch, i);
-    }
-}
-
-/**
- *
- * @param {TouchList} touchList
- * @param {Vector2} result
- */
-function getTouchCenter(touchList, result) {
-    const length = touchList.length;
-
-    let x = 0, y = 0;
-
-    if (length > 0) {
-
-        for (let i = 0; i < length; i++) {
-            const touch = touchList.item(i);
-
-            if (touch === null) {
-                continue;
-            }
-
-            x += touch.clientX;
-            y += touch.clientY;
-        }
-
-        // average to get center
-        x /= length;
-        y /= length;
-
-    }
-
-    result.set(x, y);
-
-}
-
-
+}
+
 /**
  *
  * @param {Signal} up
  * @param {Signal} down
  * @param {Signal} move
- * @param {number} maxDistance
+ * @param {number} [maxDistance] in pixels
+ * @param {number} [maxDelay] Maximum delay between down and up events in seconds
  * @param {Signal} signal
  */
-function observeTap(
-    up,
-    down,
-    move,
-    maxDistance,
-    signal
-) {
+function observeTap({
+                        up,
+                        down,
+                        move = new Signal(),
+                        maxDistance = 10,
+                        maxDelay = 1,
+                        signal
+                    }) {
 
     /**
      *
@@ -91616,7 +91562,8 @@ function observeTap(
      */
     function reset(id) {
 
-        if (active.delete(id)) {
+        const deleted = active.delete(id);
+        if (deleted) {
             up.remove(handleUp);
             move.remove(handleMove);
         }
@@ -91625,10 +91572,10 @@ function observeTap(
     /**
      *
      * @param {Vector2} position
-     * @param {MouseEvent|TouchEvent} event
+     * @param {PointerEvent} event
      */
     function handleUp(position, event) {
-        const id = eventToSourceIdentifier(event);
+        const id = event.pointerId;
 
         const meta = active.get(id);
 
@@ -91639,16 +91586,25 @@ function observeTap(
 
         reset(id);
 
+        const time_now = current_time_in_seconds();
+
+        const delay = time_now - meta.timestamp;
+
+        if (delay > maxDelay) {
+            // too much time has passed, swallow event
+            return;
+        }
+
         signal.send2(position, event);
     }
 
     /**
      *
      * @param {Vector2} position
-     * @param {MouseEvent|TouchEvent} event
+     * @param {PointerEvent} event
      */
     function handleMove(position, event) {
-        const id = eventToSourceIdentifier(event);
+        const id = event.pointerId;
 
         const meta = active.get(id);
 
@@ -91670,10 +91626,10 @@ function observeTap(
     /**
      *
      * @param {Vector2} position
-     * @param {TouchEvent|MouseEvent} event
+     * @param {PointerEvent} event
      */
     function handleDown(position, event) {
-        const id = eventToSourceIdentifier(event);
+        const id = event.pointerId;
 
         // make sure to cancel previous pending resolution
         reset(id);
@@ -91689,119 +91645,6 @@ function observeTap(
     down.add(handleDown);
 }
 
-/**
- *
- * @param {Signal} touchStart
- * @param {Signal} touchEnd
- * @param {Signal} touchMove
- * @param {Signal} pinch
- * @param {Signal} pinchStart
- * @param {Signal} pinchEnd
- * @param {PointerDevice} device
- */
-function observePinch({
-                          touchStart,
-                          touchEnd,
-                          touchMove,
-                          pinch,
-                          pinchStart,
-                          pinchEnd,
-                          device
-                      }) {
-    const center = new Vector2();
-
-    const v2 = new Vector2();
-
-    const pinchBox0 = new Vector2();
-    const pinchBox1 = new Vector2();
-
-    let pinchActive = false;
-    let touchCount = 0;
-
-
-    /**
-     *
-     * @param {TouchList} touchList
-     * @param {Vector2} pinchDimensions
-     */
-    function computeTouchRadius(touchList, pinchDimensions) {
-        getTouchCenter(touchList, center);
-
-        const length = touchList.length;
-
-        pinchDimensions.set(0, 0);
-
-        for (let i = 0; i < length; i++) {
-            const touch = touchList.item(i);
-
-            device.readPointerPositionFromEvent(v2, touch);
-
-            v2.sub(center);
-            v2.abs();
-
-            pinchDimensions.add(v2);
-        }
-
-        return pinchDimensions.multiplyScalar(1 / length);
-    }
-
-    function touchRemoved(touch, event) {
-        touchCount--;
-        if (touchCount < 2 && pinchActive) {
-            handlePinchEnd();
-        }
-    }
-
-    function touchAdded(touch, event) {
-        touchCount++;
-        if (touchCount > 1 && !pinchActive) {
-            handlePinchStart(event);
-        }
-    }
-
-    function handlePinchStart(event) {
-        pinchActive = true;
-
-        computeTouchRadius(event.touches, pinchBox0);
-
-        touchMove.add(handleMove);
-
-        pinchStart.send1(pinchBox0);
-    }
-
-    /**
-     *
-     * @param {TouchEvent} event
-     */
-    function handlePinchEnd(event) {
-        pinchActive = false;
-
-        touchMove.remove(handleMove);
-
-        pinchEnd.send0();
-    }
-
-    function handleDown(position, event) {
-        forEachTouch(event.changedTouches, function (touch) {
-            touchAdded(touch, event);
-        });
-    }
-
-    function handleUp(position, event) {
-        forEachTouch(event.changedTouches, function (touch) {
-            touchRemoved();
-        });
-    }
-
-    function handleMove(position, event) {
-        computeTouchRadius(event.touches, pinchBox1);
-        pinch.send2(pinchBox1, pinchBox0);
-    }
-
-    touchEnd.add(handleUp);
-    touchStart.add(handleDown);
-}
-
 /**
  *
  * @param {Signal} up
@@ -91893,18 +91736,8 @@ class PointerDevice {
      */
     position = new Vector2();
 
-    /**
-     * @readonly
-     * @type {Vector2}
-     */
-    #anchor_touch_last = new Vector2();
-
     #globalUp = new Signal();
 
-    #touchStart = new Signal();
-    #touchEnd = new Signal();
-    #touchMove = new Signal();
-
     /**
      * @readonly
      */
@@ -91994,41 +91827,18 @@ class PointerDevice {
         this.#domElement = domElement;
 
 
-        this.#touchStart.add(this.on.down.send3, this.on.down);
-
-        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);
+        observeTap({ up: this.on.up, down: this.on.down, move: this.on.move, maxDistance: 10, signal: this.on.tap });
         observeDrag(this.#globalUp, this.on.down, this.on.move, this.on.dragStart, this.on.dragEnd, this.on.drag);
-        observePinch({
-            touchStart: this.#touchStart,
-            touchEnd: this.#touchEnd,
-            touchMove: this.#touchMove,
-            pinch: this.on.pinch,
-            pinchStart: this.on.pinchStart,
-            pinchEnd: this.on.pinchEnd,
-            device: this
-        });
-    }
-
 
-    /**
-     *
-     * @param {TouchEvent} event
-     */
-    #eventHandlerGlobalTouchEnd = (event) => {
-        getTouchCenter(event.touches, this.position);
-        this.#globalUp.send2(this.position, event);
     }
 
+
     /**
      *
-     * @param {MouseEvent} event
+     * @param {PointerEvent} event
      */
-    #eventHandlerMouseDown = (event) => {
+    #eventHandlerPointerDown = (event) => {
         this.readPointerPositionFromEvent(this.position, event);
         this.on.down.send2(this.position, event);
 
@@ -92042,9 +91852,9 @@ class PointerDevice {
 
     /**
      *
-     * @param {MouseEvent} event
+     * @param {PointerEvent} event
      */
-    #eventHandlerMouseUp = (event) => {
+    #eventHandlerPointerUp = (event) => {
         this.readPointerPositionFromEvent(this.position, event);
         this.on.up.send2(this.position, event);
     }
@@ -92053,7 +91863,7 @@ class PointerDevice {
      *
      * @param {MouseEvent} event
      */
-    #eventHandlerGlobalMouseUp = (event) => {
+    #eventHandlerGlobalPointerUp = (event) => {
         this.readPointerPositionFromEvent(this.position, event);
         this.#globalUp.send2(this.position, event);
 
@@ -92065,32 +91875,6 @@ class PointerDevice {
         button?.release();
     }
 
-    /**
-     *
-     * @param {TouchEvent} event
-     */
-    #eventHandlerTouchEnd = (event) => {
-        getTouchCenter(event.touches, this.position);
-        this.#touchEnd.send2(this.position, event);
-    }
-
-    /**
-     *
-     * @param {TouchEvent} event
-     */
-    #eventHandlerTouchMove = (event) => {
-        event.preventDefault();
-
-        getTouchCenter(event.touches, this.position);
-
-        const delta = new Vector2();
-
-        delta.subVectors(this.position, this.#anchor_touch_last);
-
-        this.#touchMove.send3(this.position, event, delta);
-
-        this.#anchor_touch_last.copy(this.position);
-    }
 
     /**
      *
@@ -92114,20 +91898,9 @@ class PointerDevice {
 
     /**
      *
-     * @param {TouchEvent} event
-     */
-    #eventHandlerTouchStart = (event) => {
-        getTouchCenter(event.touches, this.position);
-        this.#touchStart.send2(this.position, event);
-
-        this.#anchor_touch_last.copy(this.position);
-    }
-
-    /**
-     *
-     * @param {MouseEvent} event
+     * @param {PointerEvent} event
      */
-    #eventHandlerMouseMove = (event) => {
+    #eventHandlerPointerMove = (event) => {
         event.preventDefault();
 
         this.#target = event.target;
@@ -92196,16 +91969,11 @@ class PointerDevice {
 
         const domElement = this.#domElement;
 
-        domElement.addEventListener(MouseEvents.Move, this.#eventHandlerMouseMove);
-        domElement.addEventListener(MouseEvents.Up, this.#eventHandlerMouseUp);
-        domElement.addEventListener(MouseEvents.Down, this.#eventHandlerMouseDown);
+        domElement.addEventListener(PointerEvents.Move, this.#eventHandlerPointerMove);
+        domElement.addEventListener(PointerEvents.Up, this.#eventHandlerPointerUp);
+        domElement.addEventListener(PointerEvents.Down, this.#eventHandlerPointerDown);
 
-        domElement.addEventListener(TouchEvents.Start, this.#eventHandlerTouchStart);
-        domElement.addEventListener(TouchEvents.End, this.#eventHandlerTouchEnd);
-        domElement.addEventListener(TouchEvents.Move, this.#eventHandlerTouchMove);
-
-        window.addEventListener(MouseEvents.Up, this.#eventHandlerGlobalMouseUp);
-        window.addEventListener(TouchEvents.End, this.#eventHandlerGlobalTouchEnd);
+        window.addEventListener(PointerEvents.Up, this.#eventHandlerGlobalPointerUp);
 
         /*
         In some cases wheel event gets registered as "passive" by default. This interferes with "preventDefault()"
@@ -92214,7 +91982,7 @@ class PointerDevice {
         domElement.addEventListener(MouseEvents.Wheel, this.#eventHandlerWheel, { passive: false });
 
 
-        domElement.addEventListener("contextmenu", supressContextMenu);
+        domElement.addEventListener("contextmenu", suppressContextMenu);
     }
 
     stop() {
@@ -92229,21 +91997,16 @@ class PointerDevice {
 
         const domElement = this.domElement;
 
-        domElement.removeEventListener(MouseEvents.Move, this.#eventHandlerMouseMove);
-        domElement.removeEventListener(MouseEvents.Up, this.#eventHandlerMouseUp);
-        domElement.removeEventListener(MouseEvents.Down, this.#eventHandlerMouseDown);
-
-        domElement.removeEventListener(TouchEvents.Start, this.#eventHandlerTouchStart);
-        domElement.removeEventListener(TouchEvents.End, this.#eventHandlerTouchEnd);
-        domElement.removeEventListener(TouchEvents.Move, this.#eventHandlerTouchMove);
+        domElement.removeEventListener(PointerEvents.Move, this.#eventHandlerPointerMove);
+        domElement.removeEventListener(PointerEvents.Up, this.#eventHandlerPointerUp);
+        domElement.removeEventListener(PointerEvents.Down, this.#eventHandlerPointerDown);
 
-        window.removeEventListener(MouseEvents.Up, this.#eventHandlerGlobalMouseUp);
-        window.removeEventListener(TouchEvents.End, this.#eventHandlerGlobalTouchEnd);
+        window.removeEventListener(PointerEvents.Up, this.#eventHandlerGlobalPointerUp);
 
         domElement.removeEventListener(MouseEvents.Wheel, this.#eventHandlerWheel);
 
 
-        domElement.removeEventListener("contextmenu", supressContextMenu);
+        domElement.removeEventListener("contextmenu", suppressContextMenu);
     }
 }
 
@@ -96702,18 +96465,6 @@ Stat.Process = {
  */
 Stat.prototype.isStat = true;
 
-//Use highest available resolution time source
-const source = typeof performance === "undefined" ? Date : performance;
-
-/**
- * Current time in seconds
- * @returns {number}
- */
-function current_time_in_seconds() {
-    // time source produces value in milliseconds, we need to scale to seconds
-    return source.now() * 1e-3;
-}
-
 /**
  *
  * @param {Clock} clock
@@ -105377,6 +105128,95 @@ class EngineConfiguration {
     }
 }
 
+/**
+ * @see https://developer.mozilla.org/en-US/docs/Web/API/MouseEvent/buttons
+ * @see https://w3c.github.io/uievents/#widl-MouseEvent-buttons
+ *
+ * @param {Number} value
+ * @param {boolean[]} [result]
+ * @return {boolean[]} array of booleans, boolean is true if mouse button is pressed, false otherwise
+ */
+function decodeMouseEventButtons(value, result = []) {
+
+    for (let i = 0; i < 32; i++) {
+
+        const shiftedValue = value >> i;
+
+        result[i] = (shiftedValue & 1) !== 0;
+    }
+
+    return result;
+}
+
+class InputBinding {
+    /**
+     *
+     * @param {string} path
+     * @param {function} listener
+     * @param {boolean} [exclusive=false]
+     */
+    constructor({ path, listener, exclusive = false }) {
+
+        /**
+         *
+         * @type {string}
+         */
+        this.path = path;
+        /**
+         *
+         * @type {Function}
+         */
+        this.listener = listener;
+        /**
+         * @deprecated don't use
+         * @type {boolean}
+         */
+        this.exclusive = exclusive;
+    }
+}
+
+class InputController {
+    /**
+     *
+     * @param {Array} bindings
+     * @constructor
+     */
+    constructor(bindings = []) {
+
+        this.mapping = new List();
+
+        const inputControllerBindings = bindings.map(b => new InputBinding(b));
+
+        this.mapping.addAll(inputControllerBindings);
+
+        this.on = {
+            unlinked: new Signal()
+        };
+    }
+
+    /**
+     *
+     * @param {Array} bindings
+     */
+    static from(bindings) {
+        const ic = new InputController();
+
+        const n = bindings.length;
+        for (let i = 0; i < n; i++) {
+            const binding = bindings[i];
+
+            const inputBinding = new InputBinding(binding);
+
+            ic.mapping.add(inputBinding);
+        }
+
+        return ic;
+    }
+}
+
+InputController.typeName = "InputController";
+InputController.serializable = false;
+
 /**
  *
  * @param {number[]} mat4
@@ -105767,75 +105607,6 @@ TopDownCameraController.typeName = "TopDownCameraController";
 TopDownCameraController.pan = pan;
 TopDownCameraController.rotate = rotate_from_view;
 
-class InputBinding {
-    /**
-     *
-     * @param {string} path
-     * @param {function} listener
-     * @param {boolean} [exclusive=false]
-     */
-    constructor({ path, listener, exclusive = false }) {
-
-        /**
-         *
-         * @type {string}
-         */
-        this.path = path;
-        /**
-         *
-         * @type {Function}
-         */
-        this.listener = listener;
-        /**
-         * @deprecated don't use
-         * @type {boolean}
-         */
-        this.exclusive = exclusive;
-    }
-}
-
-class InputController {
-    /**
-     *
-     * @param {Array} bindings
-     * @constructor
-     */
-    constructor(bindings = []) {
-
-        this.mapping = new List();
-
-        const inputControllerBindings = bindings.map(b => new InputBinding(b));
-
-        this.mapping.addAll(inputControllerBindings);
-
-        this.on = {
-            unlinked: new Signal()
-        };
-    }
-
-    /**
-     *
-     * @param {Array} bindings
-     */
-    static from(bindings) {
-        const ic = new InputController();
-
-        const n = bindings.length;
-        for (let i = 0; i < n; i++) {
-            const binding = bindings[i];
-
-            const inputBinding = new InputBinding(binding);
-
-            ic.mapping.add(inputBinding);
-        }
-
-        return ic;
-    }
-}
-
-InputController.typeName = "InputController";
-InputController.serializable = false;
-
 /**
  *
  * @param {number} camera_entity