@woosh/meep-engine 2.33.4 → 2.33.9

package/core/binary/BinaryBuffer.js

@@ -342,7 +342,7 @@ BinaryBuffer.prototype.readInt32Array = function (destination, destination_offse
  *
  * @param {number} destination_offset starting index in the destination array
  * @param {number} length number of elements to read
- * @param {Float32Array} destination
+ * @param {Float32Array|number[]} destination
  */
 BinaryBuffer.prototype.readFloat32Array = function (destination, destination_offset, length) {
     for (let i = 0; i < length; i++) {
@@ -366,7 +366,7 @@ BinaryBuffer.prototype.readFloat64Array = function (destination, destination_off
  *
  * @param {number} source_offset starting index in the source array
  * @param {number} length number of elements to read
- * @param {Float32Array} source
+ * @param {Float32Array|number[]} source
  */
 BinaryBuffer.prototype.writeFloat32Array = function (source, source_offset, length) {
     for (let i = 0; i < length; i++) {
@@ -452,6 +452,18 @@ BinaryBuffer.prototype.writeUint8 = function (value) {
     this.position = end;
 };
 
+/**
+ *
+ * @param {Uint8Array|number[]} source
+ * @param {number} source_offset
+ * @param {number} length
+ */
+BinaryBuffer.prototype.writeUint8Array = function (source, source_offset, length) {
+    for (let i = 0; i < length; i++) {
+        this.writeUint8(source[source_offset + i]);
+    }
+}
+
 /**
  *
  * @param {number} value
@@ -491,6 +503,18 @@ BinaryBuffer.prototype.writeUint16LE = function (value) {
     this.position = end;
 };
 
+/**
+ *
+ * @param {Uint16Array|number[]} source
+ * @param {number} source_offset
+ * @param {number} length
+ */
+BinaryBuffer.prototype.writeUint16Array = function (source, source_offset, length) {
+    for (let i = 0; i < length; i++) {
+        this.writeUint16(source[source_offset + i]);
+    }
+}
+
 /**
  *
  * @param {number} value

package/core/bvh2/LeafNode.js

@@ -83,10 +83,15 @@ LeafNode.prototype.move = function (dx, dy, dz) {
 LeafNode.prototype.resize = function (x0, y0, z0, x1, y1, z1) {
     this.setBounds(x0, y0, z0, x1, y1, z1);
 
+    this.bubbleRefit();
+};
+
+LeafNode.prototype.bubbleRefit = function (){
+
     if (this.parentNode !== null) {
         this.parentNode.bubbleRefit();
     }
-};
+}
 
 /**
  *

package/core/bvh2/aabb3/AABB3.js

@@ -8,6 +8,7 @@ import { computeAABB3PlaneSide } from "../../geom/3d/aabb/computeAABB3PlaneSide.
 import computeMortonCode from "../../geom/3d/morton/Morton.js";
 import { _boxSurfaceArea2, intersectRay, intersectSegment } from "./AABB3Math.js";
 import { aabb3_build_corners } from "../../geom/3d/aabb/aabb3_build_corners.js";
+import { assert } from "../../assert.js";
 
 
 /**
@@ -724,7 +725,9 @@ AABB3.prototype.getCorners = function (result) {
  * @param {number} offset
  */
 AABB3.prototype.writeToArray = function (result, offset) {
-    result[offset + 0] = this.x0;
+    assert.isNonNegativeInteger(offset, 'offset');
+
+    result[offset] = this.x0;
     result[offset + 1] = this.y0;
     result[offset + 2] = this.z0;
 
@@ -733,6 +736,23 @@ AABB3.prototype.writeToArray = function (result, offset) {
     result[offset + 5] = this.z1;
 };
 
+/**
+ *
+ * @param {number[]|Float32Array|Float64Array} source
+ * @param {number} offset
+ */
+AABB3.prototype.readFromArray = function (source, offset) {
+    assert.isNonNegativeInteger(offset, 'offset');
+
+    this.x0 = source[offset];
+    this.y0 = source[offset + 1];
+    this.z0 = source[offset + 2];
+
+    this.x1 = source[offset + 3];
+    this.y1 = source[offset + 4];
+    this.z1 = source[offset + 5];
+};
+
 /**
  * @param {THREE.Plane} plane
  * @returns {int} 2,0,or -2; 2: above, -2 : below, 0 : intersects plane

package/core/collection/RingBuffer.js

@@ -7,14 +7,32 @@ export class RingBuffer {
      * @constructor
      */
     constructor(size) {
-        assert.equal(typeof size, "number", `Type of 'size' must be 'number', was '${typeof size}' instead`);
+        assert.isNumber(size, 'size');
         assert.greaterThan(size, 0, `size`);
+        assert.isNonNegativeInteger(size, 'size');
 
+        /**
+         *
+         * @type {number}
+         */
         this.size = size;
 
+        /**
+         *
+         * @type {number}
+         */
         this.head = 0;
+
+        /**
+         *
+         * @type {number}
+         */
         this.tail = 0;
 
+        /**
+         *
+         * @type {number}
+         */
         this.count = 0;
 
         /**
@@ -62,13 +80,15 @@ export class RingBuffer {
 
         this.data[head] = element;
 
-        const newHead = (head + 1) % this.size;
+        const size = this.size;
+
+        const newHead = (head + 1) % size;
 
         this.head = newHead;
 
-        if (this.count === this.size) {
+        if (this.count === size) {
             //update tail
-            this.tail = (this.tail + 1) % this.size;
+            this.tail = (this.tail + 1) % size;
         } else {
             this.count++;
         }
@@ -130,11 +150,15 @@ export class RingBuffer {
      * @returns {V|undefined}
      */
     removeIf(condition, thisArg) {
+        const count = this.count;
+        const size = this.size;
 
-        for (let i = 0; i < this.count; i++) {
-            const index = (this.tail + i) % this.size;
+        const tail = this.tail;
+        const data = this.data;
 
-            const el = this.data[index];
+        for (let i = 0; i < count; i++) {
+            const index = (tail + i) % size;
+            const el = data[index];
 
             if (condition.call(thisArg, el)) {
 
@@ -151,10 +175,16 @@ export class RingBuffer {
      * @param {*} [thisArg]
      */
     forEach(visitor, thisArg) {
-        for (let i = 0; i < this.count; i++) {
-            const index = (this.tail + i) % this.size;
+        const count = this.count;
+        const size = this.size;
+
+        const tail = this.tail;
+        const data = this.data;
+
+        for (let i = 0; i < count; i++) {
 
-            const el = this.data[index];
+            const index = (tail + i) % size;
+            const el = data[index];
 
             visitor.call(thisArg, el);
         }

package/core/collection/array/copyArray.js

@@ -25,9 +25,9 @@ export function copyArray(source, target) {
  * Follows Java System.arraycopy interface
  * Copy data from one array to another
  * @template T
- * @param {T[]|ArrayLike<T>|TypedArray} source The source array
+ * @param {T[]|ArrayLike<T>|TypedArray|Uint8ClampedArray|Uint8Array} source The source array
  * @param {number} source_position Starting position where to copy from inside the source array
- * @param {T[]|ArrayLike<T>|TypedArray} destination The destination array
+ * @param {T[]|ArrayLike<T>|TypedArray|Uint8ClampedArray|Uint8Array} destination The destination array
  * @param {number} destination_position Starting position where to copy to inside the destination array
  * @param {number} length How many elements should be copied
  */

package/core/collection/array/typed/typed_array_copy.js

@@ -3,8 +3,8 @@ import { array_copy } from "../copyArray.js";
 
 /**
  *
- * @param {TypedArray} source
- * @param {TypedArray} destination
+ * @param {TypedArray|Float32Array} source
+ * @param {TypedArray|Float32Array} destination
  */
 export function typed_array_copy(source, destination) {
     const destination_size = destination.length;

package/core/collection/set/compute_set_difference.js

@@ -0,0 +1,32 @@
+/**
+ * @template T
+ * @returns Set<T>
+ * @param {Set<T>} a
+ * @param {Set<T>} b
+ */
+export function compute_set_difference(a, b) {
+    const result = new Set();
+
+    const a_array = Array.from(a);
+    const a_count = a_array.length;
+    for (let i = 0; i < a_count; i++) {
+        const t = a_array[i];
+
+        if (!b.has(t)) {
+            result.add(t);
+        }
+    }
+
+    const b_array = Array.from(b);
+    const b_count = b_array.length;
+    for (let i = 0; i < b_count; i++) {
+        const t = b_array[i];
+
+        if (!a.has(t)) {
+            result.add(t);
+        }
+    }
+
+
+    return result;
+}

package/core/collection/set/compute_set_intersection.js

@@ -0,0 +1,22 @@
+/**
+ * @template T
+ * @returns Set<T>
+ * @param {Set<T>} a
+ * @param {Set<T>} b
+ */
+export function compute_set_intersection(a, b) {
+    const result = new Set();
+
+    const a_array = Array.from(a);
+
+    const n = a_array.length;
+    for (let i = 0; i < n; i++) {
+        const t = a_array[i];
+
+        if (b.has(t)) {
+            result.add(t);
+        }
+    }
+
+    return result;
+}

package/core/collection/set/set_remove.js

@@ -0,0 +1,15 @@
+/**
+ * @template T
+ * @param {Set<T>} a
+ * @param {Set<T>} b
+ */
+export function set_remove(a, b) {
+    const bs = Array.from(b);
+
+    const n = bs.length;
+    for (let i = 0; i < n; i++) {
+        const t = bs[i];
+
+        a.delete(t);
+    }
+}

package/core/collection/table/DataType2TypedArrayConstructorMapping.js

@@ -12,6 +12,8 @@ export const DataType2TypedArrayConstructorMapping = {
     [DataType.Int8]: Int8Array,
     [DataType.Int16]: Int16Array,
     [DataType.Int32]: Int32Array,
+    // No float16 array type, using uint16 as a backing instead
+    [DataType.Float16]: Uint16Array,
     [DataType.Float32]: Float32Array,
     [DataType.Float64]: Float64Array,
 }

package/core/collection/table/DataTypeByteSizes.js

@@ -0,0 +1,21 @@
+import { DataType } from "./DataType.js";
+
+/**
+ * @readonly
+ * @enum {number}
+ */
+export const DataTypeByteSizes = {
+    [DataType.Uint8]: 1,
+    [DataType.Uint16]: 2,
+    [DataType.Uint32]: 4,
+    [DataType.Uint64]: 8,
+
+    [DataType.Int8]: 1,
+    [DataType.Int16]: 2,
+    [DataType.Int32]: 4,
+    [DataType.Int64]: 8,
+
+    [DataType.Float16]: 2,
+    [DataType.Float32]: 4,
+    [DataType.Float64]: 8
+};

package/core/collection/table/RowFirstTable.js

@@ -6,7 +6,6 @@
 import { assert } from "../../assert.js";
 import Signal from "../../events/signal/Signal.js";
 import { max2 } from "../../math/max2.js";
-import { DataTypeIndices } from "./DataTypeIndices.js";
 import { RowFirstTableSpec } from "./RowFirstTableSpec.js";
 
 
@@ -439,92 +438,6 @@ RowFirstTable.prototype.printToConsole = function () {
     console.table(rows);
 };
 
-/**
- *
- * @param {BinaryBuffer} buffer
- * @param {RowFirstTable} table
- */
-function serializeRowFirstTable(buffer, table) {
-    //write types
-    buffer.writeUint16(table.types.length);
-    table.types.forEach(function (type) {
-        const typeIndex = DataTypeIndices[type];
-        buffer.writeUint8(typeIndex);
-    });
-
-    //write record length
-    buffer.writeUint32(table.bytesPerRecord);
-
-    //write number of records
-    buffer.writeUint32(table.length);
-
-    //write data
-    const numDataBytes = table.length * table.bytesPerRecord;
-    buffer.writeBytes(new Uint8Array(table.data), 0, numDataBytes);
-}
-
-/**
- *
- * @param {BinaryBuffer} buffer
- * @param {RowFirstTable} table
- */
-function deserializeRowFirstTable(buffer, table) {
-    /**
-     *
-     * @param {number} index
-     * @returns {DataType|null}
-     */
-    function typeByIndex(index) {
-        for (let type in DataTypeIndices) {
-            if (!DataTypeIndices.hasOwnProperty(type)) {
-                continue;
-            }
-
-            const typeIndex = DataTypeIndices[type];
-            if (typeIndex === index) {
-                return type;
-            }
-        }
-
-        return null;
-    }
-
-    //read types
-    const numTypes = buffer.readUint16();
-    const types = [];
-    for (let i = 0; i < numTypes; i++) {
-        const typeIndex = buffer.readUint8();
-        const type = typeByIndex(typeIndex);
-        if (type === null) {
-            throw new Error(`Unknown DataType index ${typeIndex}`);
-        }
-        types[i] = type;
-    }
-
-    //record size
-    const bytesPerRecord = buffer.readUint32();
-
-    //read number of records
-    const numRecords = buffer.readUint32();
-
-    const numDataBytes = bytesPerRecord * numRecords;
-    const data = new Uint8Array(numDataBytes);
-
-    //read data
-    buffer.readBytes(data, 0, numDataBytes);
-
-    //update table
-    table.spec = RowFirstTableSpec.get(types);
-    table.length = numRecords;
-    table.capacity = numRecords;
-    table.data = data.buffer;
-    table.dataView = new DataView(table.data);
-
-    table.initialize();
-}
-
 export {
-    RowFirstTable,
-    serializeRowFirstTable,
-    deserializeRowFirstTable
+    RowFirstTable
 };

package/core/collection/table/RowFirstTable.spec.js

@@ -1,7 +1,9 @@
 import { BinaryBuffer } from "../../binary/BinaryBuffer.js";
 import { DataType } from "./DataType.js";
-import { deserializeRowFirstTable, RowFirstTable, serializeRowFirstTable } from "./RowFirstTable.js";
+import { RowFirstTable } from "./RowFirstTable.js";
 import { RowFirstTableSpec } from "./RowFirstTableSpec.js";
+import { serializeRowFirstTable } from "./serializeRowFirstTable.js";
+import { deserializeRowFirstTable } from "./deserializeRowFirstTable.js";
 
 test("constructor doesn't throw", () => {
     new RowFirstTable(new RowFirstTableSpec([]));

package/core/collection/table/RowFirstTableSpec.js

@@ -8,6 +8,7 @@ import { FunctionCompiler } from "../../function/FunctionCompiler.js";
 import { computeStringHash } from "../../primitives/strings/computeStringHash.js";
 import { isArrayEqualStrict } from "../array/isArrayEqualStrict.js";
 import { DataType } from "./DataType.js";
+import { DataTypeByteSizes } from "./DataTypeByteSizes.js";
 
 /**
  * @readonly
@@ -47,25 +48,6 @@ export const DataType2DataViewWriters = {
     "float64": "setFloat64"
 };
 
-/**
- * @readonly
- * @enum {number}
- */
-export const DataTypeByteSizes = {
-    [DataType.Uint8]: 1,
-    [DataType.Uint16]: 2,
-    [DataType.Uint32]: 4,
-    [DataType.Uint64]: 8,
-
-    [DataType.Int8]: 1,
-    [DataType.Int16]: 2,
-    [DataType.Int32]: 4,
-    [DataType.Int64]: 8,
-
-    [DataType.Float32]: 4,
-    [DataType.Float64]: 8
-};
-
 /**
  *
  * @param {DataType[]} types
@@ -234,6 +216,14 @@ export function RowFirstTableSpec(types, endianType = EndianType.BigEndian) {
     }
 }
 
+/**
+ *
+ * @return {number}
+ */
+RowFirstTableSpec.prototype.getColumnCount = function () {
+    return this.types.length;
+}
+
 /**
  *
  * @param {RowFirstTableSpec} other

package/core/collection/table/computeDataTypeByIndex.js

@@ -0,0 +1,21 @@
+import { DataTypeIndices } from "./DataTypeIndices.js";
+
+/**
+ *
+ * @param {number} index
+ * @returns {DataType|undefined}
+ */
+export function computeDataTypeByIndex(index) {
+    for (let type in DataTypeIndices) {
+        if (!DataTypeIndices.hasOwnProperty(type)) {
+            continue;
+        }
+
+        const typeIndex = DataTypeIndices[type];
+        if (typeIndex === index) {
+            return type;
+        }
+    }
+
+    return undefined;
+}

package/core/collection/table/deserializeRowFirstTable.js

@@ -0,0 +1,48 @@
+import { RowFirstTableSpec } from "./RowFirstTableSpec.js";
+import { computeDataTypeByIndex } from "./computeDataTypeByIndex.js";
+
+/**
+ *
+ * @param {BinaryBuffer} buffer
+ * @param {RowFirstTable} table
+ */
+function deserializeRowFirstTable(buffer, table) {
+
+
+    //read types
+    const numTypes = buffer.readUint16();
+    const types = [];
+    for (let i = 0; i < numTypes; i++) {
+        const typeIndex = buffer.readUint8();
+
+        const type = computeDataTypeByIndex(typeIndex);
+
+        if (type === undefined) {
+            throw new Error(`Unknown DataType index ${typeIndex}`);
+        }
+        types[i] = type;
+    }
+
+    //record size
+    const bytesPerRecord = buffer.readUint32();
+
+    //read number of records
+    const numRecords = buffer.readUint32();
+
+    const numDataBytes = bytesPerRecord * numRecords;
+    const data = new Uint8Array(numDataBytes);
+
+    //read data
+    buffer.readBytes(data, 0, numDataBytes);
+
+    //update table
+    table.spec = RowFirstTableSpec.get(types);
+    table.length = numRecords;
+    table.capacity = numRecords;
+    table.data = data.buffer;
+    table.dataView = new DataView(table.data);
+
+    table.initialize();
+}
+
+export { deserializeRowFirstTable };

package/core/collection/table/serializeRowFirstTable.js

@@ -0,0 +1,27 @@
+import { DataTypeIndices } from "./DataTypeIndices.js";
+
+/**
+ *
+ * @param {BinaryBuffer} buffer
+ * @param {RowFirstTable} table
+ */
+function serializeRowFirstTable(buffer, table) {
+    //write types
+    buffer.writeUint16(table.types.length);
+    table.types.forEach(function (type) {
+        const typeIndex = DataTypeIndices[type];
+        buffer.writeUint8(typeIndex);
+    });
+
+    //write record length
+    buffer.writeUint32(table.bytesPerRecord);
+
+    //write number of records
+    buffer.writeUint32(table.length);
+
+    //write data
+    const numDataBytes = table.length * table.bytesPerRecord;
+    buffer.writeBytes(new Uint8Array(table.data), 0, numDataBytes);
+}
+
+export { serializeRowFirstTable };

package/core/color/Color.js

@@ -407,6 +407,7 @@ Color.fromRGB = function (r, g, b) {
 
 Color.parse = function (str) {
     const r = new Color();
+
     r.parse(str);
 
     return r;

package/core/color/ColorUtils.js

@@ -146,18 +146,21 @@ function int2rgb(value) {
     }
 }
 
+const rgbRegEx = /rgb\(([0-9]+),\s*([0-9]+),\s*([0-9]+)\)/;
+const hsvRegEx = /hsv\(([0-9]+(?:\.[0-9]*)?),\s*([0-9]+(?:\.[0-9]*)?),\s*([0-9]+(?:\.[0-9]*)?)\)/;
+
 /**
  *
  * @param {string|number} c
  * @returns {number[]} Numeric array, values are in Uint range
  */
 export function parseColor(c) {
-    const rgbRegEx = /rgb\(([0-9]+),\s*([0-9]+),\s*([0-9]+)\)/;
-    const hsvRegEx = /hsv\(([0-9]+(?:\.[0-9]*)?),\s*([0-9]+(?:\.[0-9]*)?),\s*([0-9]+(?:\.[0-9]*)?)\)/;
 
     const result = [];
 
-    if (typeof c === "string") {
+    const type_of_code = typeof c;
+
+    if (type_of_code === "string") {
         const cL = c.toLowerCase();
 
         let match;
@@ -191,6 +194,12 @@ export function parseColor(c) {
         } else {
             throw new Error(`Failed to decode color string '${c}' `);
         }
+    } else if(type_of_code === 'number'){
+
+        result[0] = c >> 16;
+        result[1] = (c >> 8) & 0xFF;
+        result[2] = (c) & 0xFF;
+
     } else {
         throw new Error(`Failed to decode color '${c}'`);
     }

package/core/geom/3d/aabb/aabb3_compute_projected_area.js

@@ -10,6 +10,7 @@
 
 
 /**
+ * NOTE: Consider using an optimized aabb projection method based on Jim Arvo's Graphics Gems algorithm: https://stackoverflow.com/a/58630206/3973586
  * Almost everything is inlined for speed
  * @param {number[]} aabb_corners
  * @param {number[]|mat4|Float32Array} projection_matrix
@@ -55,7 +56,7 @@ export function aabb3_project_to_2d(aabb_corners, projection_matrix) {
         const t_w = a3 * _x + b3 * _y + c3 * _z + d3;
 
         // perspective divide and normalization (-1,1 space projected to -0.5,0.5)
-        const d = 0.5 / Math.abs(t_w);
+        const d = 0.5 / t_w;
 
         // finally compute screen-space coordinates of the corner
         const x = t_x * d;
@@ -64,13 +65,14 @@ export function aabb3_project_to_2d(aabb_corners, projection_matrix) {
         if (x0 > x) {
             x0 = x;
         }
-        if (y0 > y) {
-            y0 = y;
-        }
 
         if (x1 < x) {
             x1 = x;
         }
+
+        if (y0 > y) {
+            y0 = y;
+        }
         if (y1 < y) {
             y1 = y;
         }