@woosh/meep-engine 2.46.36 → 2.47.2

package/build/meep.cjs

@@ -48200,59 +48200,15 @@ class Sampler2D {
          * @type {number}
          */
         this.version = 0;
-        /**
-         * @readonly
-         * @type {boolean}
-         */
-        this.isSampler2D = true;
     }
 
     /**
+     * @deprecated
      * @param {number} [channel=0]
      * @returns {{x: number, index: number, y: number, value: number}}
      */
     computeMax(channel = 0) {
-        const itemSize = this.itemSize;
-
-        assert.isNumber(channel, "channel");
-        assert.isNonNegativeInteger(channel , 'channel');
-        assert.lessThan(channel, itemSize, `channel must be less than itemSize(=${itemSize}), was ${channel}`);
-
-        const data = this.data;
-
-        const l = data.length;
-
-        if (l === 0) {
-            //no data
-            return undefined;
-        }
-
-        let bestValue = data[channel];
-        let bestIndex = channel;
-
-        for (let i = channel + itemSize; i < l; i += itemSize) {
-            const value = data[i];
-
-            if (bestValue < value) {
-                bestValue = value;
-                bestIndex = i;
-            }
-
-        }
-
-        const width = this.width;
-
-        const itemIndex = (bestIndex / this.itemSize) | 0;
-
-        const x = itemIndex % width;
-        const y = (itemIndex / width) | 0;
-
-        return {
-            index: bestIndex,
-            value: bestValue,
-            x,
-            y
-        };
+       throw new Error("deprecated, use sampler2d_channel_compute_max");
     }
 
     /**
@@ -48274,7 +48230,7 @@ class Sampler2D {
 
         if (l === 0) {
             //no data
-            return undefined;
+            return;
         }
 
         let bestValue = data[channel];
@@ -48300,56 +48256,15 @@ class Sampler2D {
         if (resultCount < result.length) {
             result.splice(resultCount, result.length - resultCount);
         }
-
-        return;
     }
 
     /**
+     * @deprecated
      * @param {number} [channel=0]
      * @returns {{x: number, index: number, y: number, value: number}}
      */
     computeMin(channel = 0) {
-        const itemSize = this.itemSize;
-
-        assert.typeOf(channel, "number", "channel");
-        assert.ok(channel >= 0, `channel must be >= 0, was ${channel}`);
-        assert.ok(channel < itemSize, `channel must be less than itemSize(=${itemSize}), was ${channel}`);
-
-        const data = this.data;
-
-        const l = data.length;
-
-        if (l === 0) {
-            //no data
-            return undefined;
-        }
-
-        let bestValue = data[channel];
-        let bestIndex = channel;
-
-        for (let i = channel + itemSize; i < l; i += itemSize) {
-            const value = data[i];
-
-            if (bestValue > value) {
-                bestValue = value;
-                bestIndex = i;
-            }
-
-        }
-
-        const width = this.width;
-
-        const itemIndex = (bestIndex / this.itemSize) | 0;
-
-        const x = itemIndex % width;
-        const y = (itemIndex / width) | 0;
-
-        return {
-            index: bestIndex,
-            value: bestValue,
-            x,
-            y
-        };
+        throw new Error("deprecated, use sampler2d_channel_compute_min");
     }
 
     /**
@@ -48839,73 +48754,6 @@ class Sampler2D {
         result.set(x, y);
     }
 
-    /**
-     *
-     * @param {number} scale
-     * @param {number} offset
-     * @return {function(index:int, array:ArrayLike, x:int, y:int)}
-     */
-    makeArrayFiller(scale, offset) {
-        scale = scale || 255;
-        offset = offset || 0;
-
-        const sampler = this;
-        const v4 = [1 / scale, 1 / scale, 1 / scale, 1 / scale];
-
-        //
-        function fillDD1(index, array, x, y) {
-            const val = (sampler.sampleChannelBilinear(x, y, 0) + offset) * scale | 0;
-            array[index] = val;
-            array[index + 1] = val;
-            array[index + 2] = val;
-            array[index + 3] = 255;
-        }
-
-        function fillDD2(index, array, x, y) {
-            sampler.sampleBilinear(x, y, v4, 0);
-            const val = (v4[0] + offset) * scale | 0;
-            array.fill(val, index, index + 3);
-            array[index + 3] = (v4[1] + offset) * scale | 0;
-        }
-
-        function fillDD3(index, array, x, y) {
-
-            sampler.sampleBilinear(x, y, v4, 0);
-
-            array[index] = (v4[0] + offset) * scale | 0;
-            array[index + 1] = (v4[1] + offset) * scale | 0;
-            array[index + 2] = (v4[2] + offset) * scale | 0;
-            array[index + 3] = 255;
-        }
-
-        function fillDD4(index, array, x, y) {
-            sampler.sampleBilinear(x, y, v4, 0);
-            array[index] = (v4[0] + offset) * scale | 0;
-            array[index + 1] = (v4[1] + offset) * scale | 0;
-            array[index + 2] = (v4[2] + offset) * scale | 0;
-            array[index + 3] = (v4[3] + offset) * scale | 0;
-        }
-
-        let fillDD;
-        switch (sampler.itemSize) {
-            case 1:
-                fillDD = fillDD1;
-                break;
-            case 2:
-                fillDD = fillDD2;
-                break;
-            case 3:
-                fillDD = fillDD3;
-                break;
-            case 4:
-                fillDD = fillDD4;
-                break;
-            default :
-                throw new Error("unsupported item size");
-        }
-        return fillDD;
-    }
-
     /**
      * Copy a patch from another sampler with a margin.
      * This is useful for texture rendering where filtering can cause bleeding along the edges of the patch.
@@ -49482,28 +49330,7 @@ class Sampler2D {
      * @param {BinaryBuffer} buffer
      */
     toBinaryBuffer(buffer) {
-        const width = this.width;
-        const height = this.height;
-
-        const itemSize = this.itemSize;
-
-        buffer.writeUint16(width);
-        buffer.writeUint16(height);
-
-        buffer.writeUint8(itemSize);
-
-        if (this.data instanceof Uint8Array) {
-            //data type
-            buffer.writeUint8(0);
-
-
-            const byteSize = width * height * itemSize;
-
-            buffer.writeBytes(this.data, 0, byteSize);
-
-        } else {
-            throw new TypeError(`Unsupported data type`);
-        }
+        throw new Error('Deprecated, use Sampler2DSerializationAdapter instead');
     }
 
     /**
@@ -49511,24 +49338,7 @@ class Sampler2D {
      * @param {BinaryBuffer} buffer
      */
     fromBinaryBuffer(buffer) {
-        this.width = buffer.readUint16();
-        this.height = buffer.readUint16();
-
-        this.itemSize = buffer.readUint8();
-
-        const dataType = buffer.readUint8();
-
-        if (dataType === 0) {
-
-            const numBytes = this.height * this.width * this.itemSize;
-            this.data = new Uint8Array(numBytes);
-
-            buffer.readBytes(this.data, 0, numBytes);
-
-            this.version++;
-        } else {
-            throw new TypeError(`Unsupported data type (${dataType})`);
-        }
+        throw new Error('Deprecated, use Sampler2DSerializationAdapter instead');
     }
 
     /**
@@ -49773,6 +49583,11 @@ class Sampler2D {
 
 }
 
+/**
+ * @readonly
+ * @type {boolean}
+ */
+Sampler2D.prototype.isSampler2D = true;
 
 /**
  * Based on code from reddit https://www.reddit.com/r/javascript/comments/jxa8x/bicubic_interpolation/
@@ -54840,7 +54655,7 @@ class ObservedString extends String {
  * @param {Sampler2D} input
  * @param {Sampler2D} output
  */
-function sampler2D_scale_down_linear(input, output) {
+function sampler2d_scale_down_linear(input, output) {
     assert.notEqual(input, undefined, 'input is undefined');
     assert.notEqual(output, undefined, 'output is undefined');
 
@@ -55053,7 +54868,7 @@ function scaleSampler2D(input, output) {
         // downscaling
         if (Number.isInteger(sourceWidth / targetWidth) && Number.isInteger(sourceHeight / targetHeight)) {
             // dimensions are multiples of source/target
-            sampler2D_scale_down_linear(input, output);
+            sampler2d_scale_down_linear(input, output);
         } else {
             // generic downsample
             genericResampleSampler2D(input, output);
@@ -62731,6 +62546,10 @@ List.prototype.toBinaryBuffer = function (buffer) {
     for (let i = 0; i < n; i++) {
         const item = this.data[i];
 
+        if(typeof item.toBinaryBuffer !== "function"){
+            throw new Error('item.toBinaryBuffer is not a function');
+        }
+
         item.toBinaryBuffer(buffer);
     }
 };
@@ -62745,6 +62564,10 @@ List.prototype.fromBinaryBuffer = function (buffer, constructor) {
 
         const el = new constructor();
 
+        if(typeof el.fromBinaryBuffer !== "function"){
+            throw new Error('item.fromBinaryBuffer is not a function');
+        }
+
         el.fromBinaryBuffer(buffer);
 
         return el;
@@ -65569,6 +65392,106 @@ WorkerBuilder.prototype.build = function () {
     return proxy;
 };
 
+/**
+ *
+ * @param {Sampler2D} sampler
+ * @param {number} [channel=0]
+ * @returns {undefined|{x: number, index:number, y: number, value: number}}
+ */
+function sampler2d_channel_compute_max(sampler, channel=0){
+    const itemSize = sampler.itemSize;
+
+    assert.isNumber(channel, "channel");
+    assert.isNonNegativeInteger(channel , 'channel');
+    assert.lessThan(channel, itemSize, `channel must be less than itemSize(=${itemSize}), was ${channel}`);
+
+    const data = sampler.data;
+
+    const l = data.length;
+
+    if (l === 0) {
+        //no data
+        return undefined;
+    }
+
+    let bestValue = data[channel];
+    let bestIndex = channel;
+
+    for (let i = channel + itemSize; i < l; i += itemSize) {
+        const value = data[i];
+
+        if (bestValue < value) {
+            bestValue = value;
+            bestIndex = i;
+        }
+
+    }
+
+    const width = this.width;
+
+    const itemIndex = (bestIndex / itemSize) | 0;
+
+    const x = itemIndex % width;
+    const y = (itemIndex / width) | 0;
+
+    return {
+        index: bestIndex,
+        value: bestValue,
+        x,
+        y
+    };
+}
+
+/**
+ *
+ * @param {Sampler2D} sampler
+ * @param {number} [channel=0]
+ * @returns {undefined|{x: number, index:number, y: number, value: number}}
+ */
+function sampler2d_channel_compute_min(sampler, channel=0){
+    const itemSize = sampler.itemSize;
+
+    assert.isNumber(channel, "channel");
+    assert.isNonNegativeInteger(channel , 'channel');
+    assert.lessThan(channel, itemSize, `channel must be less than itemSize(=${itemSize}), was ${channel}`);
+
+    const data = sampler.data;
+
+    const l = data.length;
+
+    if (l === 0) {
+        //no data
+        return undefined;
+    }
+
+    let bestValue = data[channel];
+    let bestIndex = channel;
+
+    for (let i = channel + itemSize; i < l; i += itemSize) {
+        const value = data[i];
+
+        if (bestValue > value) {
+            bestValue = value;
+            bestIndex = i;
+        }
+
+    }
+
+    const width = this.width;
+
+    const itemIndex = (bestIndex / itemSize) | 0;
+
+    const x = itemIndex % width;
+    const y = (itemIndex / width) | 0;
+
+    return {
+        index: bestIndex,
+        value: bestValue,
+        x,
+        y
+    };
+}
+
 /**
  *
  * @return {WorkerProxy}
@@ -65596,8 +65519,8 @@ function makeTerrainWorkerProxy() {
 
             useSampler(function (sampler) {
 
-                const min = sampler.computeMin();
-                const max = sampler.computeMax();
+                const min = sampler2d_channel_compute_min(sampler);
+                const max = sampler2d_channel_compute_max(sampler);
 
                 resolve({
                     min: min.value,
@@ -105684,213 +105607,223 @@ class TooltipManager {
  */
 
 
-/**
- *
- * @param {number} x
- * @param {number} y
- * @param {number} width
- * @param {number} height
- * @constructor
- */
-function Rectangle(x = 0, y = 0, width = 0, height = 0) {
+class Rectangle {
+    /**
+     *
+     * @param {number} x
+     * @param {number} y
+     * @param {number} width
+     * @param {number} height
+     * @constructor
+     */
+    constructor(x = 0, y = 0, width = 0, height = 0) {
+
+        /**
+         * @readonly
+         * @type {Vector2}
+         */
+        this.position = new Vector2(x, y);
+
+        /**
+         * @readonly
+         * @type {Vector2}
+         */
+        this.size = new Vector2(width, height);
+    }
 
     /**
-     * @type {Vector2}
+     *
+     * @param {number} x
+     * @param {number} y
+     * @param {number} width
+     * @param {number} height
      */
-    this.position = new Vector2(x, y);
+    set(x, y, width, height) {
+        this.size.set(width, height);
+        this.position.set(x, y);
+    }
 
     /**
-     * @type {Vector2}
+     *
+     * @returns {Rectangle}
      */
-    this.size = new Vector2(width, height);
-}
+    clone() {
+        return new Rectangle(this.position.x, this.position.y, this.size.x, this.size.y);
+    }
 
-/**
- *
- * @param {number} x
- * @param {number} y
- * @param {number} width
- * @param {number} height
- */
-Rectangle.prototype.set = function set(x, y, width, height) {
-    this.size.set(width, height);
-    this.position.set(x, y);
-};
+    /**
+     *
+     * @param {Rectangle} other
+     */
+    copy(other) {
+        this.position.copy(other.position);
+        this.size.copy(other.size);
+    }
 
-/**
- *
- * @returns {Rectangle}
- */
-Rectangle.prototype.clone = function () {
-    return new Rectangle(this.position.x, this.position.y, this.size.x, this.size.y);
-};
+    /**
+     *
+     * @param {number} x0
+     * @param {number} y0
+     * @param {number} x1
+     * @param {number} y1
+     * @returns {boolean}
+     */
+    _intersects(x0, y0, x1, y1) {
+        const p = this.position;
+        const s = this.size;
 
-/**
- *
- * @param {Rectangle} other
- */
-Rectangle.prototype.copy = function (other) {
-    this.position.copy(other.position);
-    this.size.copy(other.size);
-};
+        const _x0 = p.x;
+        const _y0 = p.y;
 
-/**
- *
- * @param {number} x0
- * @param {number} y0
- * @param {number} x1
- * @param {number} y1
- * @returns {boolean}
- */
-Rectangle.prototype._intersects = function (x0, y0, x1, y1) {
-    const p = this.position;
-    const s = this.size;
+        return intersects1D(x0, x1, _x0, s.x + _x0) && intersects1D(y0, y1, _y0, _y0 + s.y);
+    }
 
-    const _x0 = p.x;
-    const _y0 = p.y;
+    /**
+     *
+     * @param {Rectangle} other
+     * @returns {boolean}
+     */
+    intersects(other) {
+        const x0 = other.position.x;
+        const y0 = other.position.y;
+        const y1 = other.size.y + y0;
+        const x1 = other.size.x + x0;
+        return this._intersects(x0, y0, x1, y1);
+    }
 
-    return intersects1D(x0, x1, _x0, s.x + _x0) && intersects1D(y0, y1, _y0, _y0 + s.y);
-};
+    /**
+     *
+     * @param {number}  x0
+     * @param {number} y0
+     * @param {number} x1
+     * @param {number} y1
+     * @returns {boolean}
+     */
+    _overlaps(x0, y0, x1, y1) {
+        const p = this.position;
+        const s = this.size;
 
-/**
- *
- * @param {Rectangle} other
- * @returns {boolean}
- */
-Rectangle.prototype.intersects = function (other) {
-    const x0 = other.position.x;
-    const y0 = other.position.y;
-    const y1 = other.size.y + y0;
-    const x1 = other.size.x + x0;
-    return this._intersects(x0, y0, x1, y1);
-};
+        const _x0 = p.x;
+        const _y0 = p.y;
 
-/**
- *
- * @param {number}  x0
- * @param {number} y0
- * @param {number} x1
- * @param {number} y1
- * @returns {boolean}
- */
-Rectangle.prototype._overlaps = function (x0, y0, x1, y1) {
-    const p = this.position;
-    const s = this.size;
+        return overlap1D(x0, x1, _x0, s.x + _x0) && overlap1D(y0, y1, _y0, _y0 + s.y);
+    }
 
-    const _x0 = p.x;
-    const _y0 = p.y;
+    overlaps(other) {
+        const x0 = other.position.x;
+        const y0 = other.position.y;
+        const y1 = other.size.y + y0;
+        const x1 = other.size.x + x0;
+        return this._overlaps(x0, y0, x1, y1);
+    }
 
-    return overlap1D(x0, x1, _x0, s.x + _x0) && overlap1D(y0, y1, _y0, _y0 + s.y);
-};
+    _resizeToFit(x0, y0, x1, y1) {
+        const size = this.size;
 
-Rectangle.prototype.overlaps = function (other) {
-    const x0 = other.position.x;
-    const y0 = other.position.y;
-    const y1 = other.size.y + y0;
-    const x1 = other.size.x + x0;
-    return this._overlaps(x0, y0, x1, y1);
-};
+        const _x0 = this.position.x;
+        const _y0 = this.position.y;
 
-Rectangle.prototype._resizeToFit = function (x0, y0, x1, y1) {
-    const size = this.size;
+        let _y1 = size.y + _y0;
+        let _x1 = size.x + _x0;
 
-    const _x0 = this.position.x;
-    const _y0 = this.position.y;
+        if (Number.isNaN(_x1)) {
+            _x1 = -Infinity;
+        }
+        if (Number.isNaN(_y1)) {
+            _y1 = -Infinity;
+        }
 
-    let _y1 = size.y + _y0;
-    let _x1 = size.x + _x0;
+        const nX0 = min2(x0, _x0);
+        const nY0 = min2(y0, _y0);
+        const nX1 = max2(x1, _x1);
+        const nY1 = max2(y1, _y1);
 
-    if (Number.isNaN(_x1)) {
-        _x1 = -Infinity;
-    }
-    if (Number.isNaN(_y1)) {
-        _y1 = -Infinity;
+        this.position.set(nX0, nY0);
+        size.set(nX1 - nX0, nY1 - nY0);
     }
 
-    const nX0 = min2(x0, _x0);
-    const nY0 = min2(y0, _y0);
-    const nX1 = max2(x1, _x1);
-    const nY1 = max2(y1, _y1);
+    resizeToFit(other) {
+        const x0 = other.position.x;
+        const y0 = other.position.y;
+        const y1 = other.size.y + y0;
+        const x1 = other.size.x + x0;
 
-    this.position.set(nX0, nY0);
-    size.set(nX1 - nX0, nY1 - nY0);
-};
+        return this._resizeToFit(x0, y0, x1, y1);
+    }
 
-Rectangle.prototype.resizeToFit = function (other) {
-    const x0 = other.position.x;
-    const y0 = other.position.y;
-    const y1 = other.size.y + y0;
-    const x1 = other.size.x + x0;
+    _contains(x0, y0, x1, y1) {
+        const size = this.size;
 
-    return this._resizeToFit(x0, y0, x1, y1);
-};
+        const _x0 = this.position.x;
+        const _y0 = this.position.y;
 
-Rectangle.prototype._contains = function (x0, y0, x1, y1) {
-    const size = this.size;
+        const _y1 = size.y + _y0;
+        const _x1 = size.x + _x0;
 
-    const _x0 = this.position.x;
-    const _y0 = this.position.y;
+        return x0 >= _x0 && x1 <= _x1 && y0 >= _y0 && y1 <= _y1;
+    }
 
-    const _y1 = size.y + _y0;
-    const _x1 = size.x + _x0;
+    contains(other) {
+        const x0 = other.position.x;
+        const y0 = other.position.y;
+        const y1 = other.size.y + y0;
+        const x1 = other.size.x + x0;
 
-    return x0 >= _x0 && x1 <= _x1 && y0 >= _y0 && y1 <= _y1;
-};
+        return this._contains(x0, y0, x1, y1);
+    }
 
-Rectangle.prototype.contains = function (other) {
-    const x0 = other.position.x;
-    const y0 = other.position.y;
-    const y1 = other.size.y + y0;
-    const x1 = other.size.x + x0;
+    /**
+     *
+     * @param {Vector2} result
+     */
+    computeCenter(result) {
+        const p = this.position;
+        const s = this.size;
 
-    return this._contains(x0, y0, x1, y1);
-};
+        const x = p.x + s.x / 2;
+        const y = p.y + s.y / 2;
 
-/**
- *
- * @param {Vector2} result
- */
-Rectangle.prototype.computeCenter = function (result) {
-    const p = this.position;
-    const s = this.size;
+        result.set(x, y);
+    }
 
-    const x = p.x + s.x / 2;
-    const y = p.y + s.y / 2;
+    /**
+     *
+     * @return {number}
+     */
+    computeArea() {
+        return this.size.x * this.size.y;
+    }
 
-    result.set(x, y);
-};
+    /**
+     *
+     * @param {Array.<number>|Float32Array|Float64Array|Uint8Array} target
+     * @param {number} [targetOffset=0]
+     */
+    toArray(target, targetOffset = 0) {
+        target[targetOffset] = this.position.x;
+        target[targetOffset + 1] = this.position.y;
+        target[targetOffset + 2] = this.size.x;
+        target[targetOffset + 3] = this.size.y;
+    }
 
-/**
- *
- * @return {number}
- */
-Rectangle.prototype.computeArea = function () {
-    return this.size.x * this.size.y;
-};
+    toJSON() {
+        return {
+            position: this.position.toJSON(),
+            size: this.size.toJSON()
+        };
+    }
+
+    fromJSON(json) {
+        this.position.fromJSON(json.position);
+        this.size.fromJSON(json.size);
+    }
+}
 
 /**
- *
- * @param {Array.<number>|Float32Array|Float64Array|Uint8Array} target
- * @param {number} [targetOffset=0]
+ * @readonly
+ * @type {boolean}
  */
-Rectangle.prototype.toArray = function (target, targetOffset = 0) {
-    target[targetOffset] = this.position.x;
-    target[targetOffset + 1] = this.position.y;
-    target[targetOffset + 2] = this.size.x;
-    target[targetOffset + 3] = this.size.y;
-};
-
-Rectangle.prototype.toJSON = function () {
-    return {
-        position: this.position.toJSON(),
-        size: this.size.toJSON()
-    };
-};
-
-Rectangle.prototype.fromJSON = function (json) {
-    this.position.fromJSON(json.position);
-    this.size.fromJSON(json.size);
-};
+Rectangle.prototype.isRectangle = true;
 
 class VisualTip {
     /**