@woosh/meep-engine 2.47.1 → 2.47.2

package/build/meep.module.js

@@ -48198,11 +48198,6 @@ class Sampler2D {
          * @type {number}
          */
         this.version = 0;
-        /**
-         * @readonly
-         * @type {boolean}
-         */
-        this.isSampler2D = true;
     }
 
     /**
@@ -48233,7 +48228,7 @@ class Sampler2D {
 
         if (l === 0) {
             //no data
-            return undefined;
+            return;
         }
 
         let bestValue = data[channel];
@@ -48259,8 +48254,6 @@ class Sampler2D {
         if (resultCount < result.length) {
             result.splice(resultCount, result.length - resultCount);
         }
-
-        return;
     }
 
     /**
@@ -48759,73 +48752,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.
@@ -49402,28 +49328,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');
     }
 
     /**
@@ -49431,24 +49336,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');
     }
 
     /**
@@ -49693,6 +49581,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/
@@ -62651,6 +62544,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);
     }
 };
@@ -62665,6 +62562,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;
@@ -105704,213 +105605,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 {
     /**

package/package.json

@@ -5,7 +5,7 @@
   "description": "Fully featured ECS game engine written in JavaScript",
   "type": "module",
   "author": "Alexander Goldring",
-  "version": "2.47.1",
+  "version": "2.47.2",
   "main": "build/meep.module.js",
   "module": "build/meep.module.js",
   "exports": {

package/src/core/collection/list/List.js

@@ -777,6 +777,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);
     }
 };
@@ -791,6 +795,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;