@woosh/meep-engine 2.33.6 → 2.33.11

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

@@ -736,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/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

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_from_min_max.js

@@ -0,0 +1,15 @@
+/**
+ *
+ * @param {number[]|Float32Array|Float64Array} result
+ * @param {{x:number,y:number,z:number}} min
+ * @param {{x:number,y:number,z:number}} max
+ */
+export function aabb3_from_min_max(result, min, max) {
+    result[0] = min.x;
+    result[1] = min.y;
+    result[2] = min.z;
+
+    result[3] = max.x;
+    result[4] = max.y;
+    result[5] = max.z;
+}

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

@@ -0,0 +1,96 @@
+import { assert } from "../../../assert.js";
+
+/**
+ *
+ * @param {number[]|Float32Array} result
+ * @param {number[]|Float32Array|Float64Array} aabb_corners
+ * @param {number[]|Float32Array} projection_matrix
+ */
+export function aabb3_matrix4_project_by_corners(result, aabb_corners, projection_matrix) {
+    assert.greaterThanOrEqual(result.length, 6, 'result.length must >= 6');
+    assert.greaterThanOrEqual(aabb_corners.length, 24, 'aabb_corners.length must >= 24');
+    assert.greaterThanOrEqual(projection_matrix.length, 16, 'projection_matrix.length must >= 16');
+
+    // read matrix into local variables for speed
+    const a0 = projection_matrix[0];
+    const a1 = projection_matrix[1];
+    const a2 = projection_matrix[2];
+    const a3 = projection_matrix[3];
+
+    const b0 = projection_matrix[4];
+    const b1 = projection_matrix[5];
+    const b2 = projection_matrix[6];
+    const b3 = projection_matrix[7];
+
+    const c0 = projection_matrix[8];
+    const c1 = projection_matrix[9];
+    const c2 = projection_matrix[10];
+    const c3 = projection_matrix[11];
+
+    const d0 = projection_matrix[12];
+    const d1 = projection_matrix[13];
+    const d2 = projection_matrix[14];
+    const d3 = projection_matrix[15];
+
+    // initialize bounds
+    let x0 = Number.POSITIVE_INFINITY;
+    let y0 = Number.POSITIVE_INFINITY;
+    let z0 = Number.POSITIVE_INFINITY;
+
+    let x1 = Number.NEGATIVE_INFINITY;
+    let y1 = Number.NEGATIVE_INFINITY;
+    let z1 = Number.NEGATIVE_INFINITY;
+
+
+    for (let i = 0; i < 24; i += 3) {
+
+        // read corner
+        const _x = aabb_corners[i];
+        const _y = aabb_corners[i + 1];
+        const _z = aabb_corners[i + 2];
+
+        // apply transform
+        const t_x = a0 * _x + b0 * _y + c0 * _z + d0;
+        const t_y = a1 * _x + b1 * _y + c1 * _z + d1;
+        const t_z = a2 * _x + b2 * _y + c2 * _z + d2;
+        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 = 1 / t_w;
+
+        // finally compute screen-space coordinates of the corner
+        const x = t_x * d;
+        const y = t_y * d;
+        const z = t_z * d;
+
+        if (x0 > x) {
+            x0 = x;
+        }
+        if (x1 < x) {
+            x1 = x;
+        }
+
+        if (y0 > y) {
+            y0 = y;
+        }
+        if (y1 < y) {
+            y1 = y;
+        }
+
+        if (z0 > z) {
+            z0 = z;
+        }
+        if (z1 < z) {
+            z1 = z;
+        }
+
+    }
+
+    result[0] = x0;
+    result[1] = y0;
+    result[2] = z0;
+
+    result[3] = x1;
+    result[4] = y1;
+    result[5] = z1;
+}

package/{engine/graphics/micron/build/bounds → core/geom/3d}/compute_bounding_cone_of_2_cones.js

@@ -1,9 +1,9 @@
 //
 
 
-import Vector3 from "../../../../../core/geom/Vector3.js";
-import Quaternion, { quat3_createFromAxisAngle } from "../../../../../core/geom/Quaternion.js";
-import { max2 } from "../../../../../core/math/max2.js";
+import Vector3 from "../Vector3.js";
+import Quaternion, { quat3_createFromAxisAngle } from "../Quaternion.js";
+import { max2 } from "../../math/max2.js";
 
 const tangent = new Vector3();
 

package/{engine/graphics/micron/build/bounds → core/geom/3d}/compute_bounding_cone_of_2_cones.spec.js

@@ -1,5 +1,5 @@
 import { compute_bounding_cone_of_2_cones } from "./compute_bounding_cone_of_2_cones.js";
-import { ConicRay } from "../../../../../core/geom/ConicRay.js";
+import { ConicRay } from "../ConicRay.js";
 
 /**
  *

package/{engine/graphics/micron/build/bounds → core/geom/3d}/compute_bounding_sphere_of_2_spheres.js

@@ -2,9 +2,9 @@
 
 
 import { vec3 } from "gl-matrix";
-import { Miniball } from "../../../../../core/geom/packing/miniball/Miniball.js";
-import { PointSet } from "../../../../../core/geom/packing/miniball/PointSet.js";
-import { max2 } from "../../../../../core/math/max2.js";
+import { Miniball } from "../packing/miniball/Miniball.js";
+import { PointSet } from "../packing/miniball/PointSet.js";
+import { max2 } from "../../math/max2.js";
 
 /**
  *

package/{engine/graphics/micron/render/refinement → core/geom/3d/frustum}/array_normalize_plane.js

@@ -1,4 +1,4 @@
-import { v3_length } from "../../../../../core/geom/Vector3.js";
+import { v3_length } from "../../Vector3.d.ts";
 
 /**
  * Normalize a plane in-place

package/{engine/graphics/micron/render/refinement → core/geom/3d/frustum}/array_setFromProjectionMatrix.js

@@ -1,4 +1,4 @@
-import { v3_length } from "../../../../../core/geom/Vector3.js";
+import { v3_length } from "../../Vector3.js";
 
 /**
  *
@@ -21,7 +21,7 @@ function array_set_plane_normalized(destination, destination_offset, x, y, z, w)
 }
 
 /**
- *
+ * Set frustum from projection matrix
  * @param {number[]|Float32Array} frustum_planes
  * @param {number[]} me
  */

package/{engine/graphics/micron/util → core/geom/3d}/unit_hemioct.spec.js

@@ -1,5 +1,5 @@
 import { decode_hemioct_to_unit, encode_unit_to_hemioct } from "./encode_unit3_hemioct.js";
-import { v3_length } from "../../../../core/geom/Vector3.js";
+import { v3_length } from "../Vector3.d.ts";
 
 test('encode-decode', () => {
     const v0 = [];