@woosh/meep-engine 2.109.4 → 2.109.6

package/build/meep.cjs

@@ -67735,6 +67735,60 @@ function sampler2d_ensure_uint8_RGBA(input) {
 const DEFAULT_TEXTURE_WIDTH = 512;
 const DEFAULT_TEXTURE_HEIGHT = 512;
 
+/**
+ *
+ * @param {THREE.DataTexture} texture
+ * @param {number} channel_count
+ * @param {number} _width
+ * @param {number} _height
+ * @returns {Sampler2D}
+ */
+function data_texture_to_sampler(texture, channel_count, _width, _height) {
+    const source = new Sampler2D(texture.image.data, channel_count, texture.image.width, texture.image.height);
+
+    let converted = sampler2d_ensure_uint8_RGBA(source);
+
+    if (converted.width !== _width || converted.height !== _height) {
+        const target = Sampler2D.uint8(4, _width, _height);
+
+        sampler2d_scale(converted, target);
+
+        converted = target;
+    }
+    return converted;
+}
+
+/**
+ *
+ * @param {THREE.Texture} texture
+ * @param {number} channel_count
+ * @param {number} _width
+ * @param {number} _height
+ * @returns {Sampler2D}
+ */
+function html_image_texture_to_sampler(texture, channel_count, _width, _height) {
+    /**
+     *
+     * @type {Image}
+     */
+    const img = texture.image;
+
+    const canvas = document.createElement('canvas');
+
+    canvas.width = _width;
+    canvas.height = _height;
+
+    const ctx = canvas.getContext('2d');
+
+    ctx.drawImage(img, 0, 0, img.width, img.height, 0, 0, _width, _height);
+
+    const result = Sampler2D.uint8(4, _width, _height);
+
+    canvasDataToSampler(result, ctx);
+
+    return result;
+}
+
 /**
  *
  * @param {Texture} texture
@@ -67754,8 +67808,6 @@ function convertTexture2Sampler2D(
 
     const channel_count = formatToChannelCount(texture.format);
 
-    // TODO take channel count into account
-
     if (_width === undefined || _height === undefined) {
 
         //figure out texture size
@@ -67794,21 +67846,14 @@ function convertTexture2Sampler2D(
     if (texture.isDataTexture === true) {
 
         // special case
+        const converted = data_texture_to_sampler(texture, channel_count, _width, _height);
 
-        const source = new Sampler2D(texture.image.data, channel_count, texture.image.width, texture.image.height);
-
-        let converted = sampler2d_ensure_uint8_RGBA(source);
-
-        if (converted.width !== _width || converted.height !== _height) {
-            const target = Sampler2D.uint8(4, _width, _height);
+        data = converted.data;
 
-            sampler2d_scale(converted, target);
-
-            converted = target;
-        }
+    } else if (texture.image instanceof Image) {
+        const converted = html_image_texture_to_sampler(texture, channel_count, _width, _height);
 
         data = converted.data;
-
     } else {
         const built = WebGLRendererPool.global.use(renderer => {
 
@@ -84852,7 +84897,7 @@ class Deque {
      * @type {T[]}
      * @private
      */
-    #data=EMPTY_ARRAY;
+    #data = EMPTY_ARRAY;
     /**
      *
      * @type {number}
@@ -84942,8 +84987,8 @@ class Deque {
 
         let new_length = length * 2;
 
-        // bigger than Integer.MAX_VALUE
         if (new_length > UINT32_MAX) {
+            // clamp to max uint32 value
             new_length = UINT32_MAX;
         }
 
@@ -84973,7 +85018,7 @@ class Deque {
      * @return {boolean}
      */
     isEmpty() {
-        return this.size() === 0;
+        return this.#status === STATUS_EMPTY;
     }
 
     clear() {
@@ -85082,9 +85127,10 @@ class Deque {
 
         const data = this.#data;
         const capacity = data.length;
+        const head = this.#head;
 
         for (let i = 0; i < size; i++) {
-            const index = (this.#head + i) % capacity;
+            const index = (head + i) % capacity;
 
             const el = data[index];
 
@@ -85169,6 +85215,58 @@ class Deque {
         const last = this.#circular_previous_position(this.#tail);
         return this.#data[last];
     }
+
+    /**
+     * Retrieved element by position from head. Where element at the head is position 0
+     * @param {number} index
+     * @returns {T|undefined} undefined if indexing element that is past the end, otherwise returns element at the position given
+     */
+    getElementByIndex(index) {
+
+        if (index >= this.size()) {
+            // overflow
+            return undefined;
+        }
+
+        const data = this.#data;
+
+        /**
+         *
+         * @type {number}
+         */
+        const position = (this.#head + index) % data.length;
+
+        return data[position];
+    }
+
+    /**
+     * Returns a copy of this queue represented as an array without gaps, with the head of the queue (first element) being at position 0
+     * @param {T[]} [result]
+     * @param {number} [result_offset]
+     * @returns {T[]}
+     */
+    toArray(result = [], result_offset = 0) {
+        const size = this.size();
+
+        for (let i = 0; i < size; i++) {
+            result[i] = this.getElementByIndex(i);
+        }
+
+        return result;
+    }
+
+    /**
+     *
+     * @returns {Generator<T,void>}
+     */
+    * [Symbol.iterator]() {
+
+        const size = this.size();
+
+        for (let i = 0; i < size; i++) {
+            yield this.getElementByIndex(i);
+        }
+    }
 }
 
 /*