@woosh/meep-engine 2.118.2 → 2.118.4

package/build/meep.cjs

@@ -1767,6 +1767,12 @@ function lerp$1(a, b, fraction) {
     return (b - a) * fraction + a;
 }
 
+/**
+ * equal to `Math.pow(2,32) - 1`
+ * @type {number}
+ */
+const UINT32_MAX = 4294967295;
+
 /**
  *
  * @param {number} v
@@ -1774,12 +1780,12 @@ function lerp$1(a, b, fraction) {
  */
 function computeHashFloat(v) {
     //we break the number up into fractional and whole parts
-    const whole = v | 0;
+    const whole = v >> 0;
 
     const fraction = v - whole;
 
     //fractional part is scaled up into int32 range, this inexact method, as it will produce 0 hash for values below a certain threshold
-    const fractionHash = fraction * 1367130550;
+    const fractionHash = fraction * UINT32_MAX;
 
     //take XOR of both parts
     return fractionHash ^ whole;
@@ -2124,10 +2130,8 @@ function v3_slerp(
 
 /**
  * @author Alex Goldring
- * @copyright Alex Goldring 2015
+ * @copyright Alex Goldring 2015-2024
  */
-
-
 let Vector3$1 = class Vector3 {
     /**
      *
@@ -3017,7 +3021,7 @@ let Vector3$1 = class Vector3 {
      * @deprecated use dedicated method directly instead
      */
     fromBinaryBufferFloat32_EqualityEncoded(buffer) {
-        throw  new Error('deprecated, use v3_binary_equality_decode')
+        throw new Error('deprecated, use v3_binary_equality_decode')
     }
 
     hash() {
@@ -3178,19 +3182,7 @@ Vector3$1.prototype.isVector3 = true;
  * @readonly
  * @type {string}
  */
-Vector3$1.typeName = "Vector3";
-
-/**
- * @deprecated use {@link v3_dot} directly instead
- * @param {number} x0
- * @param {number} y0
- * @param {number} z0
- * @param {number} x1
- * @param {number} y1
- * @param {number} z1
- * @returns {number}
- */
-Vector3$1._dot = v3_dot;
+Vector3$1.typeName = "Vector3";
 
 const scratch_v3_a = new Vector3$1();
 const scratch_v3_b = new Vector3$1();
@@ -50301,6 +50293,7 @@ function float_to_uint8(v) {
  * @returns {number}
  */
 function uint8_to_float(v) {
+
     return v / 255;
 }
 
@@ -51203,18 +51196,28 @@ const context_cache = new WeakMap();
 /**
  *
  * @param {HTMLCanvasElement} canvas
- * @returns {Sampler2D}
+ * @returns {CanvasRenderingContext2D}
  */
-function html_canvas_to_sampler2d(canvas) {
-    const width = canvas.width;
-    const height = canvas.height;
-
+function html_canvas_to_rendering_context2d_cached(canvas) {
     let context = context_cache.get(canvas);
 
     if (context === undefined) {
         context = canvas.getContext("2d");
         context_cache.set(canvas, context);
     }
+    return context;
+}
+
+/**
+ *
+ * @param {HTMLCanvasElement} canvas
+ * @returns {Sampler2D}
+ */
+function html_canvas_to_sampler2d(canvas) {
+    const width = canvas.width;
+    const height = canvas.height;
+
+    const context = html_canvas_to_rendering_context2d_cached(canvas);
 
     const imageData = context.getImageData(0, 0, width, height);
 
@@ -52059,12 +52062,6 @@ class TerrainPreview {
     }
 }
 
-/**
- * equal to `Math.pow(2,32) - 1`
- * @type {number}
- */
-const UINT32_MAX = 4294967295;
-
 /**
  * This is essentially a {@link memcopy} implementation for ArrayBuffers
  * NOTE: allocates light-weight typed arrays under the hood, so beware of potential GC implications. Generally not an issue, unless you're copying very large number of very small arrays, consider alternatives such as {@link array_copy} instead
@@ -53921,9 +53918,9 @@ class Color {
 
     /**
      *
-     * @param {number} r
-     * @param {number} g
-     * @param {number} b
+     * @param {number} r [0..255]
+     * @param {number} g [0..255]
+     * @param {number} b [0..255]
      */
     setRGBUint8(r, g, b) {
         this.setRGB(
@@ -55310,13 +55307,17 @@ function v3_morton_encode_bounded(x, y, z, bounds) {
 function max3(a, b, c) {
 
     let v = a;
+
     if (v < b) {
         v = b;
     }
+
     if (v < c) {
         v = c;
     }
+
     return v;
+
 }
 
 /**
@@ -76451,6 +76452,17 @@ function murmur3_32(key, seed) {
     return h1 >>> 0;
 }
 
+/**
+ *
+ * @param {HTMLCanvasElement} canvas
+ * @returns {number}
+ */
+function computeHtmlCanvasElementHash(canvas) {
+    const sampler = html_canvas_to_sampler2d(canvas);
+
+    return sampler.hash();
+}
+
 /**
  * Guards against cases where ImageBitmap doesn't exist
  * @param {*} image
@@ -76695,6 +76707,10 @@ function computeImageDataHash(image) {
 
         result = computeStringHash(image.src);
 
+    }else if(image instanceof HTMLCanvasElement) {
+
+        result = computeHtmlCanvasElementHash(image);
+
     }
 
     let width = 0;
@@ -85293,6 +85309,13 @@ const STATUS_FULL = 0;
 const STATUS_EMPTY = 1;
 const STATUS_NORMAL = 2;
 
+/**
+ * When growing underlying array, how much to grow by. This is a multiplier.
+ * Must be greater than 1
+ * @type {number}
+ */
+const GROWTH_FACTOR = 2;
+
 const EMPTY_ARRAY = new Array(0);
 
 /**
@@ -85309,14 +85332,16 @@ class Deque {
      * @private
      */
     #data = EMPTY_ARRAY;
+
     /**
-     *
+     * Index of the front of the queue inside the internal data array
      * @type {number}
      * @private
      */
     #head = 0;
+
     /**
-     *
+     * Index of the back of the queue inside the internal data array
      * @type {number}
      * @private
      */
@@ -85398,7 +85423,7 @@ class Deque {
         }
 
         // double existing length
-        let new_length = length * 2;
+        let new_length = length * GROWTH_FACTOR;
 
         if (new_length > UINT32_MAX) {
             // clamp to max uint32 value
@@ -85471,41 +85496,23 @@ class Deque {
     /**
      *
      * @param {number} current
-     * @param {boolean} shift_front should we shift elements before the removed element or after?
      * @private
      */
-    #remove_internal(current, shift_front) {
+    #remove_internal_shift_backward(current) {
         let cursor = current;
 
-        if (shift_front) {
-
-            // shift towards tail
-
-            const head = this.#head;
+        // shift towards head, this has a better data access pattern than shifting the other way as we're going through the data in forward sequence
 
-            while (cursor !== head) {
-                const next = this.#circular_previous_position(cursor);
-                this.#data[cursor] = this.#data[next];
-                cursor = next;
-            }
-
-            this.#head = this.#circular_next_position(head);
-
-        } else {
-
-            // shift towards head
-
-            const tail = this.#tail;
+        const tail = this.#tail;
 
-            while (cursor !== tail) {
-                const next = this.#circular_next_position(cursor);
-                this.#data[cursor] = this.#data[next];
-                cursor = next;
-            }
+        while (cursor !== tail) {
+            const next = this.#circular_next_position(cursor);
+            this.#data[cursor] = this.#data[next];
+            cursor = next;
+        }
 
-            this.#tail = this.#circular_previous_position(tail);
+        this.#tail = this.#circular_previous_position(tail);
 
-        }
 
         // fill in slot of last moved element
         this.#data[cursor] = undefined;
@@ -85525,7 +85532,7 @@ class Deque {
             return false;
         }
 
-        this.#remove_internal(i, true);
+        this.#remove_internal_shift_backward(i);
 
         return true;
     }
@@ -85687,12 +85694,21 @@ class Deque {
 Stack methods
  */
 
+/**
+ * Stack operation. Alias of {@link Deque.prototype.getFirst}
+ */
 Deque.prototype.peek = Deque.prototype.getFirst;
+/**
+ * Stack operation. Alias of {@link Deque.prototype.addFirst}
+ */
 Deque.prototype.push = Deque.prototype.addFirst;
+/**
+ * Stack operation. Alias of {@link Deque.prototype.removeFirst}
+ */
 Deque.prototype.pop = Deque.prototype.removeFirst;
 
 /**
- * Standard queue method
+ * Alias of {@link Deque.prototype.addLast}
  */
 Deque.prototype.add = Deque.prototype.addLast;
 
@@ -103212,59 +103228,49 @@ GUIElement.serializable = true;
 
 class ViewportPosition {
     /**
-     *
-     * @constructor
+     * Clip-scale position, on-screen values are in range of 0 to 1
+     * @type {Vector2}
      */
-    constructor(options) {
-        /**
-         * Clip-scale position, on-screen values are in range of 0 to 1
-         * @type {Vector2}
-         */
-        this.position = new Vector2();
-
-        /**
-         * Fixed offset in pixels
-         * @type {Vector2}
-         */
-        this.offset = new Vector2();
-        /**
-         * ranges from 0..1 in both X and Y, controls anchor point of element positioning
-         * @type {Vector2}
-         */
-        this.anchor = new Vector2(0, 0);
+    position = new Vector2();
 
+    /**
+     * Fixed offset in pixels
+     * @type {Vector2}
+     */
+    offset = new Vector2();
+    /**
+     * ranges from 0..1 in both X and Y, controls anchor point of element positioning
+     * @type {Vector2}
+     */
+    anchor = new Vector2(0, 0);
 
-        /**
-         * Makes display element avoid overlap with GUI elements
-         * @see GUIElement
-         * @type {boolean}
-         */
-        this.resolveGuiCollisions = false;
 
-        /**
-         * How far should the HUD stay away from the edge if it's sticky
-         * @see stickToScreenEdge
-         * @type {number}
-         */
-        this.screenEdgeWidth = 10;
+    /**
+     * Makes display element avoid overlap with GUI elements
+     * @see GUIElement
+     * @type {boolean}
+     */
+    resolveGuiCollisions = false;
 
+    /**
+     * How far should the HUD stay away from the edge if it's sticky
+     * @see stickToScreenEdge
+     * @type {number}
+     */
+    screenEdgeWidth = 10;
 
-        /**
-         * Controls whenever or not HUD should remain on the screen when it gets to the edge
-         * @type {boolean}
-         */
-        this.stickToScreenEdge = false;
 
-        /**
-         * Can be used to enable and disable positioning
-         * @type {ObservedBoolean}
-         */
-        this.enabled = new ObservedBoolean(true);
+    /**
+     * Controls whenever or not HUD should remain on the screen when it gets to the edge
+     * @type {boolean}
+     */
+    stickToScreenEdge = false;
 
-        if (options !== undefined) {
-            this.fromJSON(options);
-        }
-    }
+    /**
+     * Can be used to enable and disable positioning
+     * @type {ObservedBoolean}
+     */
+    enabled = new ObservedBoolean(true);
 
     /**
      *