@woosh/meep-engine 2.33.3 → 2.33.8

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/bvh2/aabb3/aabb3_intersects_frustum.js

@@ -7,6 +7,14 @@ import { aabb3_computeDistanceAbovePlane } from "../../geom/3d/aabb/aabb3_comput
  * @return {boolean}
  */
 export function aabb3_intersects_frustum(aabb, frustum) {
+
+    const x0 = aabb[0];
+    const y0 = aabb[1];
+    const z0 = aabb[2];
+    const x1 = aabb[3];
+    const y1 = aabb[4];
+    const z1 = aabb[5];
+
     for (let i = 0; i < 24; i += 4) {
 
         const plane_n_x = frustum[i];
@@ -16,8 +24,8 @@ export function aabb3_intersects_frustum(aabb, frustum) {
 
         const plane_distance = aabb3_computeDistanceAbovePlane(
             plane_n_x, plane_n_y, plane_n_z, plane_constant,
-            aabb[0], aabb[1], aabb[2],
-            aabb[3], aabb[4], aabb[5]
+            x0, y0, z0,
+            x1, y1, z1
         );
 
         if (plane_distance < 0) {

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/RowFirstTableSpec.js

@@ -234,6 +234,14 @@ export function RowFirstTableSpec(types, endianType = EndianType.BigEndian) {
     }
 }
 
+/**
+ *
+ * @return {number}
+ */
+RowFirstTableSpec.prototype.getColumnCount = function () {
+    return this.types.length;
+}
+
 /**
  *
  * @param {RowFirstTableSpec} other

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;
         }

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

@@ -0,0 +1,59 @@
+const scratch_aabb = new Float32Array(4);
+
+
+/**
+ * NOTE: tends to overestimate the area
+ * @param {number[]} aabb
+ * @param {number[]} matrix
+ * @return {number}
+ */
+export function aabb3_estimate_projected_area2(aabb, matrix) {
+    // extract translation from matrix
+    scratch_aabb[0] = scratch_aabb[2] = matrix[12];
+    scratch_aabb[1] = scratch_aabb[3] = matrix[13];
+
+    // apply 3x3 matrix transform
+    for (let i = 0; i < 2; i++) {
+        for (let j = 0; j < 3; j++) {
+
+            const m_a = i * 4 + j;
+            const m_v = matrix[m_a];
+
+            const a = m_v * aabb[j];
+            const b = m_v * aabb[j + 3];
+
+            if (a < b) {
+                scratch_aabb[i] += a;
+                scratch_aabb[i + 2] += b;
+            } else {
+                scratch_aabb[i] += b;
+                scratch_aabb[i + 2] += a;
+            }
+        }
+    }
+
+
+    const x1 = scratch_aabb[2];
+    const x0 = scratch_aabb[0];
+
+    const dx = x1 - x0;
+
+    const y1 = scratch_aabb[3];
+    const y0 = scratch_aabb[1];
+
+    const dy = y1 - y0;
+    const a = dx * dy;
+
+    const cx = (aabb[0] + aabb[3]) * 0.5;
+    const cy = (aabb[1] + aabb[4]) * 0.5;
+    const cz = (aabb[2] + aabb[5]) * 0.5;
+
+    /* compute W projection value, using conservative estimate
+       @see https://twitter.com/SebAaltonen/status/1332332808979832832
+       @see https://gist.github.com/slembcke/b2b2af4dede1d5702a635dc2d0e45d54
+    */
+    const w = matrix[3] * cx + matrix[7] * cy + matrix[11] * cz + matrix[15];
+    const d = 0.5 / Math.abs(w);
+
+    return a * d * d;
+}

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

@@ -0,0 +1,33 @@
+
+/**
+ * NOTE: Based on Transforming Axis-Aligned Bounding Boxes by Jim Arvo from "Graphics Gems", Academic Press, 1990
+ * @param {number[]} result
+ * @param {number[]} aabb
+ * @param {number[]} matrix 4x4 matrix
+ */
+export function aabb3_matrix4_project(result, aabb, matrix) {
+    // extract translation from matrix
+    result[0] = result[3] = matrix[12];
+    result[1] = result[4] = matrix[13];
+    result[2] = result[5] = matrix[14];
+
+    // apply 3x3 matrix transform
+    for (let i = 0; i < 3; i++) {
+        for (let j = 0; j < 3; j++) {
+
+            const m_a = i * 4 + j;
+            const m_v = matrix[m_a];
+
+            const a = m_v * aabb[j];
+            const b = m_v * aabb[j + 3];
+
+            if (a < b) {
+                result[i] += a;
+                result[i + 3] += b;
+            } else {
+                result[i] += b;
+                result[i + 3] += a;
+            }
+        }
+    }
+}

package/core/geom/3d/aabb/aabb3_matrix4_project.spec.js

@@ -0,0 +1,41 @@
+import { aabb3_matrix4_project } from "./aabb3_matrix4_project.js";
+
+test('identity', () => {
+    const r = [];
+
+    aabb3_matrix4_project(r, [1, 2, 3, 5, 7, 9], [
+        1, 0, 0, 0,
+        0, 1, 0, 0,
+        0, 0, 1, 0,
+        0, 0, 0, 1
+    ]);
+
+    expect(r).toEqual([1, 2, 3, 5, 7, 9]);
+});
+
+test('translation case', () => {
+    const r = [];
+
+    aabb3_matrix4_project(r, [1, 2, 3, 5, 7, 9], [
+        1, 0, 0, 0,
+        0, 1, 0, 0,
+        0, 0, 1, 0,
+        13, -17, 23, 1
+    ]);
+
+    expect(r).toEqual([14, -15, 26, 18, -10, 32]);
+});
+
+
+test('scale case', () => {
+    const r = [];
+
+    aabb3_matrix4_project(r, [1, 2, 3, 5, 7, 9], [
+        -1, 0, 0, 0,
+        0, 2, 0, 0,
+        0, 0, -3, 0,
+        0, 0, 0, 1
+    ]);
+
+    expect(r).toEqual([-5, 4, -27, -1, 14, -9]);
+});

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";
 
 /**
  *