@woosh/meep-engine 2.31.1 → 2.31.5

package/core/binary/BitSet.js

@@ -112,6 +112,10 @@ function BitSet() {
     this.__firstClearBitIndex = 0;
 }
 
+BitSet.prototype.preventShrink = function () {
+    this.__shrinkFactor = 0;
+}
+
 /**
  *
  * @param {number} numBits
@@ -145,7 +149,7 @@ BitSet.prototype.capacity = function () {
  * @private
  */
 BitSet.prototype.__resize = function (bitCapacity) {
-    assert.ok(Number.isInteger(bitCapacity), `bitCapacity must be an integer, instead was '${bitCapacity}'`)
+    assert.isNonNegativeInteger(bitCapacity, 'bitCapacity');
 
     const byteCapacity = Math.ceil(bitCapacity / 8);
 

package/core/collection/RingBuffer.js

@@ -29,7 +29,22 @@ export class RingBuffer {
      * @return {V}
      */
     getHead() {
-        return this.data[this.head];
+        return this.data[this.head - 1];
+    }
+
+    /**
+     *
+     * @param {number} offset
+     * @returns {V}
+     */
+    getFromHead(offset) {
+        let i = this.head - (offset + 1);
+
+        while (i < 0) {
+            i += this.size;
+        }
+
+        return this.data[i];
     }
 
     clear() {

package/core/geom/Vector1.js

@@ -9,267 +9,276 @@ import { clamp } from "../math/clamp.js";
 import { computeHashFloat } from "../math/MathUtils.js";
 
 
-/**
- *
- * @param {number} [x=0]
- * @constructor
- * @class
- * @property {number} x
- */
-function Vector1(x = 0) {
-    assert.equal(typeof x, "number", `X must be of type "number", instead was "${typeof x}"`);
+class Vector1 extends Number {
+    /**
+     *
+     * @param {number} [x=0]
+     * @constructor
+     * @class
+     * @property {number} x
+     */
+    constructor(x = 0) {
+        super();
 
-    assert.ok(!Number.isNaN(x), `X must be a valid number, instead was NaN`);
+        assert.equal(typeof x, "number", `X must be of type "number", instead was "${typeof x}"`);
 
-    this.x = x;
-    this.onChanged = new Signal();
-}
+        assert.ok(!Number.isNaN(x), `X must be a valid number, instead was NaN`);
 
-Vector1.typeName = "Vector1";
+        this.x = x;
 
-Vector1.prototype = Object.create(Number.prototype);
+        this.onChanged = new Signal();
+    }
 
-/**
- * @readonly
- * @type {boolean}
- */
-Vector1.prototype.isVector1 = true;
+    /**
+     * Inherited from Number class
+     * @returns {number}
+     */
+    valueOf() {
+        return this.x;
+    }
 
-/**
- * Inherited from Number class
- * @returns {number}
- */
-Vector1.prototype.valueOf = function () {
-    return this.x;
-};
+    /**
+     *
+     * @returns {string}
+     */
+    toString() {
+        return String(this.x);
+    }
 
-/**
- *
- * @returns {string}
- */
-Vector1.prototype.toString = function () {
-    return String(this.x);
-};
+    /**
+     *
+     * @returns {number}
+     */
+    getValue() {
+        return this.x;
+    }
 
-/**
- *
- * @returns {number}
- */
-Vector1.prototype.getValue = function () {
-    return this.x;
-};
+    /**
+     *
+     * @param {Vector1} other
+     * @returns {number}
+     */
+    compareTo(other) {
+        return this.x - other.x;
+    }
 
-/**
- *
- * @param {Vector1} other
- * @returns {number}
- */
-Vector1.prototype.compareTo = function (other) {
-    return this.x - other.x;
-};
+    /**
+     *
+     * @param {number} x
+     * @returns {Vector1}
+     */
+    set(x) {
+        assert.equal(typeof x, "number", `X must be of type "number", instead was "${typeof x}"`);
 
-/**
- *
- * @param {Vector1} a
- * @param {Vector1} b
- * @return {number}
- */
-Vector1.compare = function (a, b) {
-    return a.x - b.x;
-};
+        assert.ok(!Number.isNaN(x), `X must be a valid number, instead was NaN`);
 
-/**
- *
- * @param {number} x
- * @returns {Vector1}
- */
-Vector1.prototype.set = function (x) {
-    assert.equal(typeof x, "number", `X must be of type "number", instead was "${typeof x}"`);
+        const oldValue = this.x;
+        if (oldValue !== x) {
+            this.x = x;
+
+            if (this.onChanged.hasHandlers()) {
+                this.onChanged.send2(x, oldValue);
+            }
+        }
 
-    assert.ok(!Number.isNaN(x), `X must be a valid number, instead was NaN`);
+        return this;
+    }
 
-    const oldValue = this.x;
-    if (oldValue !== x) {
+    /**
+     * Set value without triggering {@link #onChanged} signal
+     * @param {number} x
+     */
+    setSilent(x) {
         this.x = x;
+    }
 
-        if (this.onChanged.hasHandlers()) {
-            this.onChanged.send2(x, oldValue);
-        }
+    /**
+     *
+     * @return {boolean}
+     */
+    isZero() {
+        return this.x === 0;
     }
 
-    return this;
-};
+    increment() {
+        this._add(1);
+    }
 
-/**
- * Set value without triggering {@link #onChanged} signal
- * @param {number} x
- */
-Vector1.prototype.setSilent = function (x) {
-    this.x = x;
-};
+    decrement() {
+        this._add(-1);
+    }
 
-/**
- *
- * @return {boolean}
- */
-Vector1.prototype.isZero = function () {
-    return this.x === 0;
-}
+    /**
+     *
+     * @param {Number} v
+     * @return {Vector1}
+     */
+    _add(v) {
+        return this.set(this.x + v);
+    }
 
-Vector1.prototype.increment = function () {
-    this._add(1);
-};
+    /**
+     *
+     * @param {Vector1|Vector2|Vector3|Vector4} other
+     */
+    add(other) {
+        return this._add(other.x);
+    }
 
-Vector1.prototype.decrement = function () {
-    this._add(-1);
-};
+    /**
+     *
+     * @param {Number} v
+     * @return {Vector1}
+     */
+    _sub(v) {
+        return this._add(-v);
+    }
 
-/**
- *
- * @param {Number} v
- * @return {Vector1}
- */
-Vector1.prototype._add = function (v) {
-    return this.set(this.x + v);
-};
+    /**
+     *
+     * @param {Vector1} other
+     * @returns {Vector1}
+     */
+    sub(other) {
+        return this._sub(other.x);
+    }
 
-/**
- *
- * @param {Vector1|Vector2|Vector3|Vector4} other
- */
-Vector1.prototype.add = function (other) {
-    return this._add(other.x);
-};
+    /**
+     *
+     * @param {Vector1} other
+     * @returns {Vector1}
+     */
+    multiply(other) {
+        return this.set(this.x * other.x);
+    }
 
-/**
- *
- * @param {Number} v
- * @return {Vector1}
- */
-Vector1.prototype._sub = function (v) {
-    return this._add(-v);
-};
+    /**
+     *
+     * @param {number} v
+     */
+    multiplyScalar(v) {
+        this.set(this.x * v);
+    }
 
-/**
- *
- * @param {Vector1} other
- * @returns {Vector1}
- */
-Vector1.prototype.sub = function (other) {
-    return this._sub(other.x);
-};
+    /**
+     *
+     * @param {number} low
+     * @param {number} high
+     * @returns {Vector1}
+     */
+    clamp(low, high) {
+        return this.set(clamp(this.x, low, high));
+    }
 
-/**
- *
- * @param {Vector1} other
- * @returns {Vector1}
- */
-Vector1.prototype.multiply = function (other) {
-    return this.set(this.x * other.x);
-};
+    /**
+     *
+     * @param {Vector1|Vector2|Vector3|Vector4} other
+     */
+    copy(other) {
+        this.set(other.x);
+    }
 
-/**
- *
- * @param {number} v
- */
-Vector1.prototype.multiplyScalar = function (v) {
-    this.set(this.x * v);
-};
+    /**
+     *
+     * @returns {Vector1}
+     */
+    clone() {
+        return new Vector1(this.x);
+    }
 
-/**
- *
- * @param {number} low
- * @param {number} high
- * @returns {Vector1}
- */
-Vector1.prototype.clamp = function (low, high) {
-    return this.set(clamp(this.x, low, high));
-};
+    /**
+     *
+     * @param {Vector1} other
+     * @returns {boolean}
+     */
+    equals(other) {
+        return this.x === other.x;
+    }
 
-/**
- *
- * @param {Vector1|Vector2|Vector3|Vector4} other
- */
-Vector1.prototype.copy = function (other) {
-    this.set(other.x);
-};
+    /**
+     * @returns {number}
+     */
+    hash() {
+        return computeHashFloat(this.x);
+    }
 
-/**
- *
- * @returns {Vector1}
- */
-Vector1.prototype.clone = function () {
-    return new Vector1(this.x);
-};
+    /**
+     *
+     * @param {function(newValue:number, oldValue:number)} handler
+     */
+    process(handler) {
+        handler(this.x, this.x);
+        this.onChanged.add(handler);
+    }
 
-/**
- *
- * @param {Vector1} other
- * @returns {boolean}
- */
-Vector1.prototype.equals = function (other) {
-    return this.x === other.x;
-};
+    toJSON() {
+        return this.x;
+    }
 
-/**
- * @returns {number}
- */
-Vector1.prototype.hash = function () {
-    return computeHashFloat(this.x);
-};
+    fromJSON(val) {
+        this.set(val);
+    }
 
-/**
- *
- * @param {function(newValue:number, oldValue:number)} handler
- */
-Vector1.prototype.process = function (handler) {
-    handler(this.x, this.x);
-    this.onChanged.add(handler);
-};
+    /**
+     *
+     * @param {number[]} array
+     * @param {number} offset
+     */
+    readFromArray(array, offset) {
+        this.set(array[offset]);
+    }
 
-Vector1.prototype.toJSON = function () {
-    return this.x;
-};
+    /**
+     *
+     * @param {number[]} array
+     * @param {number} offset
+     */
+    writeToArray(array, offset) {
+        array[offset] = this.x;
+    }
 
-Vector1.prototype.fromJSON = function (val) {
-    this.set(val);
-};
+    /**
+     *
+     * @param {BinaryBuffer} buffer
+     */
+    toBinaryBuffer(buffer) {
+        buffer.writeFloat64(this.x);
+    }
 
-/**
- *
- * @param {number[]} array
- * @param {number} offset
- */
-Vector1.prototype.readFromArray = function (array, offset) {
-    this.set(array[offset]);
-};
+    /**
+     *
+     * @param {BinaryBuffer} buffer
+     */
+    fromBinaryBuffer(buffer) {
+        const x = buffer.readFloat64();
 
-/**
- *
- * @param {number[]} array
- * @param {number} offset
- */
-Vector1.prototype.writeToArray = function (array, offset) {
-    array[offset] = this.x;
-};
+        this.set(x);
+    }
 
-/**
- *
- * @param {BinaryBuffer} buffer
- */
-Vector1.prototype.toBinaryBuffer = function (buffer) {
-    buffer.writeFloat64(this.x);
-};
+    /**
+     *
+     * @param {Vector1} a
+     * @param {Vector1} b
+     * @return {number}
+     */
+    static compare(a, b) {
+        return a.x - b.x;
+    }
+
+    * [Symbol.iterator]() {
+
+        yield this.x;
+
+    }
+}
 
 /**
- *
- * @param {BinaryBuffer} buffer
+ * @readonly
+ * @type {boolean}
  */
-Vector1.prototype.fromBinaryBuffer = function (buffer) {
-    const x = buffer.readFloat64();
+Vector1.prototype.isVector1 = true;
 
-    this.set(x);
-};
+Vector1.typeName = "Vector1";
 
 /**
  * @readonly