@woosh/meep-engine 2.33.2 → 2.33.6

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";
 
 
 /**
@@ -718,6 +719,23 @@ AABB3.prototype.getCorners = function (result) {
     );
 };
 
+/**
+ *
+ * @param {number[]|Float32Array|Float64Array} result
+ * @param {number} offset
+ */
+AABB3.prototype.writeToArray = function (result, offset) {
+    assert.isNonNegativeInteger(offset, 'offset');
+
+    result[offset] = this.x0;
+    result[offset + 1] = this.y0;
+    result[offset + 2] = this.z0;
+
+    result[offset + 3] = this.x1;
+    result[offset + 4] = this.y1;
+    result[offset + 5] = this.z1;
+};
+
 /**
  * @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

@@ -0,0 +1,38 @@
+import { aabb3_computeDistanceAbovePlane } from "../../geom/3d/aabb/aabb3_computeDistanceAbovePlane.js";
+
+/**
+ *
+ * @param {Float32Array|number[]} aabb
+ * @param {Float32Array|number[]} frustum
+ * @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];
+        const plane_n_y = frustum[i + 1];
+        const plane_n_z = frustum[i + 2];
+        const plane_constant = frustum[i + 3];
+
+        const plane_distance = aabb3_computeDistanceAbovePlane(
+            plane_n_x, plane_n_y, plane_n_z, plane_constant,
+            x0, y0, z0,
+            x1, y1, z1
+        );
+
+        if (plane_distance < 0) {
+            return false;
+        }
+
+    }
+
+    return true;
+}

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/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/geom/3d/aabb/aabb3_compute_projected_area.js

@@ -1,5 +1,3 @@
-const scratch_corners = new Float32Array(24);
-
 /*
 
     one option of Algorithm (problem-orthogonal only, rectangles under perspective projection do not behave this way):
@@ -12,13 +10,13 @@ const scratch_corners = new Float32Array(24);
 
 
 /**
+ * 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 {AABB2} result
- * @param {AABB3} bounds
+ * @param {number[]} aabb_corners
  * @param {number[]|mat4|Float32Array} projection_matrix
+ * @returns {number}
  */
-export function aabb3_project_to_2d(result, bounds, projection_matrix) {
-    bounds.getCorners(scratch_corners);
+export function aabb3_project_to_2d(aabb_corners, projection_matrix) {
 
     // read matrix into local variables for speed
     const a0 = projection_matrix[0];
@@ -48,9 +46,9 @@ export function aabb3_project_to_2d(result, bounds, projection_matrix) {
     for (let i = 0; i < 24; i += 3) {
 
         // read corner
-        const _x = scratch_corners[i];
-        const _y = scratch_corners[i + 1];
-        const _z = scratch_corners[i + 2];
+        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;
@@ -58,7 +56,7 @@ export function aabb3_project_to_2d(result, bounds, 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;
@@ -67,18 +65,22 @@ export function aabb3_project_to_2d(result, bounds, 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;
         }
 
     }
 
-    result.set(x0, y0, x1, y1);
+    const dx = x1 - x0;
+    const dy = y1 - y0;
+
+    return dx * dy;
 }

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_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/plane/plane3_lerp.js

@@ -1,5 +1,5 @@
 import { lerp } from "../../../math/lerp.js";
-import Vector3, { v3_dot, v3Length_i } from "../../Vector3.js";
+import Vector3, { v3_dot, v3_length } from "../../Vector3.js";
 import { plane3_intersect_plane } from "./plane3_intersect_plane.js";
 
 const v0 = new Vector3();
@@ -32,7 +32,7 @@ export function plane3_lerp(
     let normal_z = lerp(a_normal_z, b_normal_z, t);
 
     // normalize the normal vector
-    const normal_length = v3Length_i(normal_x, normal_y, normal_z);
+    const normal_length = v3_length(normal_x, normal_y, normal_z);
     const normal_length_inv = 1 / normal_length;
 
     normal_x *= normal_length_inv;

package/core/geom/3d/topology/TopoTriangle.js

@@ -1,4 +1,4 @@
-import { v3Length_i } from "../../Vector3.js";
+import { v3_length } from "../../Vector3.js";
 import { array_replace_all } from "../../../collection/array/array_replace_all.js";
 import { array_push_if_unique } from "../../../collection/array/array_push_if_unique.js";
 import { assert } from "../../../assert.js";
@@ -40,7 +40,7 @@ export function compute_triangle_normal(result, vA, vB, vC) {
     const crossY = vCBz * vABx - vCBx * vABz;
     const crossZ = vCBx * vABy - vCBy * vABx;
 
-    const l = v3Length_i(crossX, crossY, crossZ);
+    const l = v3_length(crossX, crossY, crossZ);
 
     if (l === 0) {
         // degenerate triangle, provide arbitrary invalid result

package/core/geom/AABB2.d.ts

@@ -20,5 +20,7 @@ export default class AABB2 {
 
     grow(size: number): void
 
+    shrink(size: number): void
+
     setNegativelyInfiniteBounds(): void
 }

package/core/geom/Matrix4.js

@@ -1,4 +1,4 @@
-import Vector3, { v3Length_i } from "./Vector3.js";
+import Vector3, { v3_length } from "./Vector3.js";
 
 const _z = new Vector3();
 const _x = new Vector3();
@@ -192,9 +192,9 @@ export class Matrix4 {
     decompose(position, rotation, scale) {
 
 
-        var sx = v3Length_i(this.a0, this.a1, this.a2);
-        var sy = v3Length_i(this.b0, this.b1, this.b2);
-        var sz = v3Length_i(this.c0, this.c1, this.c2);
+        var sx = v3_length(this.a0, this.a1, this.a2);
+        var sy = v3_length(this.b0, this.b1, this.b2);
+        var sz = v3_length(this.c0, this.c1, this.c2);
 
         // if determine is negative, we need to invert one scale
         var det = this.determinant();

package/core/geom/Vector3.js

@@ -883,7 +883,7 @@ class Vector3 {
      * @returns {number}
      */
     static distance(a, b) {
-        return v3Length_i(a.x - b.x, a.y - b.y, a.z - b.z);
+        return v3_length(a.x - b.x, a.y - b.y, a.z - b.z);
     }
 }
 
@@ -1008,10 +1008,10 @@ export function v3_distance_sqr(x0, y0, z0, x1, y1, z1) {
 
 
 function v3Length(v) {
-    return v3Length_i(v.x, v.y, v.z);
+    return v3_length(v.x, v.y, v.z);
 }
 
-export function v3Length_i(x, y, z) {
+export function v3_length(x, y, z) {
     return Math.sqrt(v3_length_sqr(x, y, z));
 }
 
@@ -1040,8 +1040,8 @@ export function v3_length_sqr(x, y, z) {
 export function v3_angleBetween(x0, y0, z0, x1, y1, z1) {
     const d = v3_dot(x0, y0, z0, x1, y1, z1);
 
-    const magnitude_0 = v3Length_i(x0, y0, z0);
-    const magnitude_1 = v3Length_i(x1, y1, z1);
+    const magnitude_0 = v3_length(x0, y0, z0);
+    const magnitude_1 = v3_length(x1, y1, z1);
 
     const l = magnitude_0 * magnitude_1;
 

package/core/model/reactive/model/terminal/ReactiveReference.js

@@ -64,9 +64,15 @@ export class ReactiveReference extends ReactiveExpression {
         assert.notEqual(source, null, 'source is null');
         assert.notEqual(source, undefined, 'source is undefined');
         assert.typeOf(source.onChanged, 'object', 'source.onChanged');
-        assert.typeOf(source.onChanged.add, 'function', 'source.onChanged.add');
+        assert.isFunction(source.onChanged.add, 'source.onChanged.add');
 
         if (this.source !== null) {
+
+            if (this.source === source) {
+                // already connected to this source, do nothing
+                return;
+            }
+
             throw new Error('source is already set. Already connected');
         }
 

package/core/process/undo/ActionProcessor.d.ts

@@ -17,6 +17,8 @@ export class ActionProcessor<CTX, MD> {
 
     redo(): void
 
+    navigateTo(mark: MD): boolean
+
     doMany(actions: Action<CTX>[]): void
 
     do(action: Action<CTX>): this

package/core/process/undo/ActionProcessor.js

@@ -202,6 +202,64 @@ export class ActionProcessor {
 
     }
 
+    /**
+     * Navigate to a specific mark back or forward
+     * @param {M} mark_descriptor specific mark description
+     * @returns {boolean} true on success, false otherwise (e.g. mark not found)
+     * @throws {Error} when mark is non-unique
+     */
+    navigateTo(mark_descriptor) {
+        // find all matching marks
+        const matching_marks = this.marks.filter(m => m.description === mark_descriptor);
+
+        if (matching_marks.length === 0) {
+            // not found
+            return false;
+        }
+
+        if (matching_marks.length > 1) {
+            throw new Error(`Attempting to navigate to a non-unique mark descriptor '${mark_descriptor}'. Mark descriptor must be unique, instead ${matching_marks.length} matches were found`);
+        }
+
+        const match = matching_marks[0];
+
+        const target = match.index;
+
+        let temp_cursor = this.cursor;
+
+        if (target > this.cursor) {
+
+            while (target > this.cursor) {
+                // navigate forward
+                this.redo();
+
+                if (temp_cursor === this.cursor) {
+                    // no cursor change
+                    return false;
+                }
+
+                temp_cursor = this.cursor;
+            }
+
+        } else if (target < this.cursor) {
+
+            while (target < this.cursor) {
+                // navigate backwards
+                this.undo();
+
+                if (temp_cursor === this.cursor) {
+                    // no cursor change
+                    return false;
+                }
+
+                temp_cursor = this.cursor;
+            }
+
+        }
+
+        return true;
+    }
+
     undo() {
         let markAddress = 0;
         /**
@@ -226,7 +284,7 @@ export class ActionProcessor {
             markAddress = 0;
         }
 
-        //keep rewinding until we hit mark
+        //keep rewinding until we hit a mark
         while (this.cursor > markAddress && this.cursor > 0) {
             this.cursor--;
             const action = this.history.get(this.cursor);

package/core/process/undo/ActionProcessor.spec.js

@@ -0,0 +1,59 @@
+import { ActionProcessor } from "./ActionProcessor.js";
+import { Action } from "./Action.js";
+
+class DummyContext {
+    constructor() {
+        this.value = 0;
+    }
+}
+
+class DummyAction extends Action {
+    apply(context) {
+        // do nothing
+        context.value++;
+    }
+
+    revert(context) {
+        context.value--;
+    }
+}
+
+test('navigateTo backwards', () => {
+    const ctx = new DummyContext();
+    const ap = new ActionProcessor(ctx);
+
+    ap.mark('a');
+    ap.do(new DummyAction());
+    ap.mark('b');
+    ap.do(new DummyAction());
+
+    expect(ap.navigateTo('a')).toBe(true);
+
+    expect(ctx.value).toBe(0);
+});
+
+test('navigateTo forward', () => {
+    const ctx = new DummyContext();
+    const ap = new ActionProcessor(ctx);
+
+    ap.mark('a');
+    ap.do(new DummyAction());
+    ap.mark('b');
+    ap.do(new DummyAction());
+    ap.mark('c');
+
+    ap.undo();
+    ap.undo();
+    ap.undo();
+
+    expect(ap.navigateTo('c')).toBe(true);
+
+    expect(ctx.value).toBe(2);
+});
+
+test('navigateTo non-existent on empty', () => {
+    const ctx = new DummyContext();
+    const ap = new ActionProcessor(ctx);
+
+    expect(ap.navigateTo('a')).toBe(false);
+});

package/core/process/undo/Mark.js

@@ -8,13 +8,14 @@ export class Mark {
      * @constructor
      */
     constructor(index, description) {
-        assert.typeOf(index, 'number', 'index');
+        assert.isNumber(index, 'index');
 
         /**
          *
          * @type {number}
          */
         this.index = index;
+
         /**
          *
          * @type {D}