@woosh/meep-engine 2.33.4 → 2.33.9

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

package/core/geom/3d/frustum/array_normalize_plane.js

@@ -0,0 +1,25 @@
+import { v3_length } from "../../Vector3.d.ts";
+
+/**
+ * Normalize a plane in-place
+ * @param {number[]} source
+ * @param {number} source_offset
+ */
+function array_normalize_plane(source, source_offset) {
+    const _x = source[source_offset];
+    const _y = source[source_offset + 1];
+    const _z = source[source_offset + 2];
+
+    const length = v3_length(_x, _y, _z);
+
+    const inverseNormalLength = 1.0 / length;
+
+    /*
+    By re-using values already in the registers instead of using *= we save a few extra READ ops
+     */
+    source[source_offset] = _x * inverseNormalLength;
+    source[source_offset + 1] = _y * inverseNormalLength;
+    source[source_offset + 2] = _z * inverseNormalLength;
+
+    source[source_offset + 3] *= inverseNormalLength;
+}

package/core/geom/3d/frustum/array_setFromProjectionMatrix.js

@@ -0,0 +1,60 @@
+import { v3_length } from "../../Vector3.js";
+
+/**
+ *
+ * @param {number[]} destination
+ * @param {number} destination_offset
+ * @param {number} x
+ * @param {number} y
+ * @param {number} z
+ * @param {number} w
+ */
+function array_set_plane_normalized(destination, destination_offset, x, y, z, w) {
+    const length = v3_length(x, y, z);
+
+    const inverseNormalLength = 1.0 / length;
+
+    destination[destination_offset] = x * inverseNormalLength;
+    destination[destination_offset + 1] = y * inverseNormalLength;
+    destination[destination_offset + 2] = z * inverseNormalLength;
+    destination[destination_offset + 3] = w * inverseNormalLength;
+}
+
+/**
+ * Set frustum from projection matrix
+ * @param {number[]|Float32Array} frustum_planes
+ * @param {number[]} me
+ */
+export function array_setFromProjectionMatrix(frustum_planes, me) {
+
+    const me0 = me[0];
+    const me3 = me[3];
+
+    const me4 = me[4];
+    const me7 = me[7];
+
+    const me8 = me[8];
+    const me11 = me[11];
+
+    const me12 = me[12];
+    const me15 = me[15];
+
+    array_set_plane_normalized(frustum_planes, 0, me3 - me0, me7 - me4, me11 - me8, me15 - me12);
+    array_set_plane_normalized(frustum_planes, 4, me3 + me0, me7 + me4, me11 + me8, me15 + me12);
+
+    const me1 = me[1];
+    const me5 = me[5];
+    const me9 = me[9];
+    const me13 = me[13];
+
+    array_set_plane_normalized(frustum_planes, 8, me3 + me1, me7 + me5, me11 + me9, me15 + me13);
+    array_set_plane_normalized(frustum_planes, 12, me3 - me1, me7 - me5, me11 - me9, me15 - me13);
+
+    const me2 = me[2];
+    const me6 = me[6];
+    const me10 = me[10];
+    const me14 = me[14];
+
+    array_set_plane_normalized(frustum_planes, 16, me3 - me2, me7 - me6, me11 - me10, me15 - me14);
+    array_set_plane_normalized(frustum_planes, 20, me3 + me2, me7 + me6, me11 + me10, me15 + me14);
+}

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 = [];

package/{engine/graphics/micron/build → core}/graph/SquareMatrix.js

@@ -1,5 +1,5 @@
-import { DataType2TypedArrayConstructorMapping } from "../../../../../core/collection/table/DataType2TypedArrayConstructorMapping.js";
-import { assert } from "../../../../../core/assert.js";
+import { DataType2TypedArrayConstructorMapping } from "../collection/table/DataType2TypedArrayConstructorMapping.js";
+import { assert } from "../assert.js";
 
 export class SquareMatrix {
     /**

package/{engine/graphics/micron/build → core}/graph/SquareMatrix.spec.js

@@ -1,5 +1,5 @@
 import { SquareMatrix } from "./SquareMatrix.js";
-import { DataType } from "../../../../../core/collection/table/DataType.js";
+import { DataType } from "../collection/table/DataType.js";
 
 test('set/get cell', () => {
     const m = new SquareMatrix(2, DataType.Uint8);

package/{engine/graphics/micron/build → core}/graph/WeightedEdge.js

@@ -1,4 +1,4 @@
-import { Edge } from "../../../../../core/graph/Edge.js";
+import { Edge } from "./Edge.js";
 
 export class WeightedEdge extends Edge {
     constructor(a, b) {

package/{engine/graphics/micron/build → core}/graph/build_face_graph_from_mesh.js

@@ -1,6 +1,6 @@
-import { Graph } from "../../../../../core/graph/v2/Graph.js";
+import { Graph } from "./v2/Graph.js";
 import { MultiNode } from "./MultiNode.js";
-import { compute_face_connection_weight } from "../clustering/compute_face_connection_weight.js";
+import { compute_face_connection_weight } from "../../engine/graphics/micron/build/clustering/compute_face_connection_weight.js";
 import { WeightedEdge } from "./WeightedEdge.js";
 import { graph_compute_disconnected_clusters } from "./graph_compute_disconnected_clusters.js";
 

package/{engine/graphics/micron/build/clustering → core/graph}/cluster_mesh_metis.js

@@ -1,5 +1,5 @@
-import { Metis } from "../graph/metis/metis.js";
-import { metis_options } from "../graph/metis/metis_options.js";
+import { Metis } from "./metis/metis.js";
+import { metis_options } from "./metis/metis_options.js";
 
 /**
  * How many times to retry partitioning before giving up
@@ -7,10 +7,6 @@ import { metis_options } from "../graph/metis/metis_options.js";
  */
 const MAX_STEPS = 50;
 
-function cluster_mesh_metis_detailed(mesh, patch_size) {
-
-}
-
 /**
  *
  * @param {Uint32Array} result

package/{engine/graphics/micron/build → core}/graph/coarsen_graph.js

@@ -1,4 +1,4 @@
-import FastBinaryHeap from "../../../../navigation/grid/FastBinaryHeap.js";
+import FastBinaryHeap from "../../engine/navigation/grid/FastBinaryHeap.js";
 import { mn_graph_collapse_weighted_edge } from "./mn_graph_collapse_weighted_edge.js";
 import { WeightedEdge } from "./WeightedEdge.js";
 

package/{engine/graphics/micron/build → core}/graph/coarsen_graph.spec.js

@@ -1,4 +1,4 @@
-import { Graph } from "../../../../../core/graph/v2/Graph.js";
+import { Graph } from "./v2/Graph.js";
 import { MultiNode } from "./MultiNode.js";
 import { WeightedEdge } from "./WeightedEdge.js";
 import { coarsen_graph } from "./coarsen_graph.js";

package/{engine/graphics/micron/build → core}/graph/eigen/eigen.spec.js

@@ -1,5 +1,5 @@
 import { SquareMatrix } from "../SquareMatrix.js";
-import { DataType } from "../../../../../../core/collection/table/DataType.js";
+import { DataType } from "../../collection/table/DataType.js";
 import { matrix_eigenvalues_in_place } from "./eigen.js";
 
 function roughly_equal_array_vectors(actual, expected) {

package/{engine/graphics/micron/build → core}/graph/graph_k_means_cluster.js

@@ -1,10 +1,10 @@
 //
-import { seededRandom } from "../../../../../core/math/random/seededRandom.js";
-import { randomIntegerBetween } from "../../../../../core/math/MathUtils.js";
+import { seededRandom } from "../math/random/seededRandom.js";
+import { randomIntegerBetween } from "../math/MathUtils.js";
 import { SquareMatrix } from "./SquareMatrix.js";
-import { DataType } from "../../../../../core/collection/table/DataType.js";
-import { BitSet } from "../../../../../core/binary/BitSet.js";
-import FastBinaryHeap from "../../../../navigation/grid/FastBinaryHeap.js";
+import { DataType } from "../collection/table/DataType.js";
+import { BitSet } from "../binary/BitSet.js";
+import FastBinaryHeap from "../../engine/navigation/grid/FastBinaryHeap.js";
 
 /**
  * @template N

package/{engine/graphics/micron/build → core}/graph/graph_laplacian_matrix.js

@@ -1,6 +1,6 @@
 import { graph_degree_matrix } from "./graph_degree_matrix.js";
 import { SquareMatrix } from "./SquareMatrix.js";
-import { DataType } from "../../../../../core/collection/table/DataType.js";
+import { DataType } from "../collection/table/DataType.js";
 import { graph_adjacency_matrix } from "./graph_adjacency_matrix.js";
 
 /**

package/{engine/graphics/micron/build → core}/graph/metis/metis.js

@@ -1,5 +1,5 @@
-import WorkerBuilder from "../../../../../../core/process/worker/WorkerBuilder.js";
-import { OnDemandWorkerManager } from "../../../../../../core/process/worker/OnDemandWorkerManager.js";
+import WorkerBuilder from "../../process/worker/WorkerBuilder.js";
+import { OnDemandWorkerManager } from "../../process/worker/OnDemandWorkerManager.js";
 
 
 export class Metis {

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