@woosh/meep-engine 2.49.9 → 2.50.0

package/src/core/geom/2d/aabb/AABB2.js

@@ -8,10 +8,12 @@ import { assert } from "../../../assert.js";
 import { clamp } from "../../../math/clamp.js";
 import { max2 } from "../../../math/max2.js";
 import { min2 } from "../../../math/min2.js";
-import LineSegment2 from "../LineSegment2.js";
 import Vector2 from "../../Vector2.js";
 import { aabb2_compute_overlap } from "./aabb2_compute_overlap.js";
 import { aabb2_overlap_exists } from "./aabb2_overlap_exists.js";
+import {
+    line_segment_compute_line_segment_intersection_2d
+} from "../line/line_segment_compute_line_segment_intersection_2d.js";
 
 /**
  *
@@ -215,7 +217,7 @@ class AABB2 {
     }
 
     /**
-     *
+     * NOTE: only 1 intersection point is produced
      * @param {Vector2} p0
      * @param {Vector2} p1
      * @param {Vector2} result
@@ -227,19 +229,19 @@ class AABB2 {
         const x1 = this.x1;
         const y1 = this.y1;
 
-        if (LineSegment2.intersectionPointRaw(p0.x, p0.y, p1.x, p1.y, x0, y0, x1, y0, result)) {
+        if (line_segment_compute_line_segment_intersection_2d(p0.x, p0.y, p1.x, p1.y, x0, y0, x1, y0, result)) {
             //top
             return true;
         }
-        if (LineSegment2.intersectionPointRaw(p0.x, p0.y, p1.x, p1.y, x0, y1, x1, y1, result)) {
+        if (line_segment_compute_line_segment_intersection_2d(p0.x, p0.y, p1.x, p1.y, x0, y1, x1, y1, result)) {
             //bottom
             return true;
         }
-        if (LineSegment2.intersectionPointRaw(p0.x, p0.y, p1.x, p1.y, x0, y0, x0, y1, result)) {
+        if (line_segment_compute_line_segment_intersection_2d(p0.x, p0.y, p1.x, p1.y, x0, y0, x0, y1, result)) {
             //left
             return true;
         }
-        if (LineSegment2.intersectionPointRaw(p0.x, p0.y, p1.x, p1.y, x1, y0, x1, y1, result)) {
+        if (line_segment_compute_line_segment_intersection_2d(p0.x, p0.y, p1.x, p1.y, x1, y0, x1, y1, result)) {
             //right
             return true;
         }
@@ -486,7 +488,7 @@ class AABB2 {
     }
 
     /**
-     *
+     * Set bounds without having to maintain constraint that x0 >= x1 and y0 >= y1
      * @param {number} x0
      * @param {number} y0
      * @param {number} x1

package/src/core/geom/2d/aabb/AABB2.spec.js

@@ -1,4 +1,5 @@
 import AABB2 from "./AABB2.js";
+import Vector2 from "../../Vector2.js";
 
 test('copy', () => {
     const a = new AABB2(1, 2, 5, 11);
@@ -51,3 +52,102 @@ test('equals', () => {
     expect(a.equals(e)).toBe(false);
     expect(a.equals(f)).toBe(false);
 });
+
+test("lineIntersectionPoint", () => {
+    const aabb = new AABB2(1, 1, 2, 2);
+
+    const result = new Vector2();
+
+    expect(aabb.lineIntersectionPoint(new Vector2(0, 0), new Vector2(-1, -1), result)).toBe(false);
+
+    expect(aabb.lineIntersectionPoint(new Vector2(0, 1.5), new Vector2(3, 1.5), result)).toBe(true);
+});
+
+/**
+ *
+ * @param {AABB2} aabb
+ * @param {number} x0
+ * @param {number} y0
+ * @param {number} x1
+ * @param {number} y1
+ */
+function expect_aabb_equals(aabb, x0, y0, x1, y1) {
+    expect(aabb.x0).toEqual(x0);
+    expect(aabb.y0).toEqual(y0);
+    expect(aabb.x1).toEqual(x1);
+    expect(aabb.y1).toEqual(y1);
+}
+
+test("setBoundsUnordered", () => {
+
+    const aabb = new AABB2();
+
+    aabb.setBoundsUnordered(2, 3, -5, -7);
+
+    expect_aabb_equals(aabb, -5, -7, 2, 3);
+
+    aabb.setBoundsUnordered(-5, -7, 2, 3);
+
+    expect_aabb_equals(aabb, -5, -7, 2, 3);
+
+    aabb.setBoundsUnordered(-5, 3, 2, -7);
+
+    expect_aabb_equals(aabb, -5, -7, 2, 3);
+
+    aabb.setBoundsUnordered(2, -7, -5, 3);
+
+    expect_aabb_equals(aabb, -5, -7, 2, 3);
+});
+
+test("toJSON", () => {
+
+    const aabb = new AABB2(1, 3, 5, 7);
+
+    expect(aabb.toJSON()).toEqual({
+        x0: 1,
+        y0: 3,
+        x1: 5,
+        y1: 7
+    });
+
+});
+
+test("fromJSON", () => {
+
+    const aabb = new AABB2();
+
+    aabb.fromJSON({
+        x0: 1,
+        y0: 3,
+        x1: 5,
+        y1: 7
+    });
+
+    expect_aabb_equals(aabb, 1, 3, 5, 7);
+});
+
+test("_expandToFitPoint", () => {
+
+    const aabb = new AABB2();
+
+    aabb._expandToFitPoint(0, 0);
+
+    expect_aabb_equals(aabb, 0, 0, 0, 0);
+
+    aabb._expandToFitPoint(-1, 0);
+
+    expect_aabb_equals(aabb, -1, 0, 0, 0);
+
+    aabb._expandToFitPoint(0, -1);
+
+    expect_aabb_equals(aabb, -1, -1, 0, 0);
+
+    aabb._expandToFitPoint(3, 5);
+
+    expect_aabb_equals(aabb, -1, -1, 3, 5);
+
+    aabb._expandToFitPoint(7, 0);
+
+    expect_aabb_equals(aabb, -1, -1, 7, 5);
+
+});

package/src/core/geom/2d/aabb/aabb2_compute_center_from_multiple.spec.js

@@ -0,0 +1,11 @@
+import { aabb2_compute_center_from_multiple } from "./aabb2_compute_center_from_multiple.js";
+import AABB2 from "./AABB2.js";
+import Vector2 from "../../Vector2.js";
+
+test("single box", () => {
+    const center = aabb2_compute_center_from_multiple([
+        new AABB2(-1, -3, 0, -2)
+    ]);
+
+    expect(center.roughlyEquals(new Vector2(-0.5, -2.5))).toBe(true);
+});

package/src/core/geom/2d/aabb/aabb2_compute_overlap.spec.js

@@ -0,0 +1,56 @@
+import { aabb2_compute_overlap } from "./aabb2_compute_overlap.js";
+import AABB2 from "./AABB2.js";
+
+test("no overlap", () => {
+
+    const aabb = new AABB2();
+
+    expect(aabb2_compute_overlap(
+        -1, -1, -1, -1,
+        1, 1, 1, 1,
+        aabb
+    )).toBe(false);
+
+    expect(aabb2_compute_overlap(
+        0, 0, 0, 0,
+        -1, 1, 1, 1,
+        aabb
+    )).toBe(false);
+
+    expect(aabb2_compute_overlap(
+        0, 0, 0, 0,
+        1, -1, 1, 1,
+        aabb
+    )).toBe(false);
+
+    expect(aabb2_compute_overlap(
+        -1, 1, 1, 1,
+        0, 0, 0, 0,
+        aabb
+    )).toBe(false);
+
+    expect(aabb2_compute_overlap(
+        1, -1, 1, 1,
+        0, 0, 0, 0,
+        aabb
+    )).toBe(false);
+
+});
+
+test("partial complex overlap", () => {
+
+    const aabb = new AABB2();
+
+    expect(aabb2_compute_overlap(
+        0, 0, 7, 3,
+        5, 1, 11, 2,
+        aabb
+    )).toBe(true);
+
+    expect(aabb.toJSON()).toEqual({
+        x0: 5,
+        y0: 1,
+        x1: 7,
+        y1: 2
+    });
+});

package/src/core/geom/2d/aabb/aabb2_contains.spec.js

@@ -0,0 +1,40 @@
+import { aabb2_contains } from "./aabb2_contains.js";
+
+test("test", () => {
+
+    expect(aabb2_contains(
+        0, 0, 0, 0,
+        -1, -1, 1, 1
+    )).toBe(false);
+
+    expect(aabb2_contains(
+        0, 0, 0, 0,
+        0, 0, 0, 0
+    )).toBe(true);
+
+    expect(aabb2_contains(
+        -1, -1, 1, 1,
+        0, 0, 0, 0
+    )).toBe(true);
+
+    expect(aabb2_contains(
+        -1, -1, 1, 1,
+        -2, 0, 0, 0
+    )).toBe(false);
+
+    expect(aabb2_contains(
+        -1, -1, 1, 1,
+        0, -2, 0, 0
+    )).toBe(false);
+
+    expect(aabb2_contains(
+        -1, -1, 1, 1,
+        0, 0, 2, 0
+    )).toBe(false);
+
+    expect(aabb2_contains(
+        -1, -1, 1, 1,
+        0, 0, 0, 2
+    )).toBe(false);
+
+});

package/src/core/geom/2d/bvh/Node2.js

@@ -1,4 +1,4 @@
-import AABB2 from "../../AABB2.js";
+import AABB2 from "../aabb/AABB2.js";
 
 export class Node2 extends AABB2 {
     constructor(x0, y0, x1, y1) {

package/src/core/geom/2d/convex-hull/fixed_convex_hull_humus.js

@@ -1,6 +1,6 @@
 //
 
-import { array_copy } from "../../../collection/array/copyArray.js";
+import { array_copy } from "../../../collection/array/array_copy.js";
 import { compute_polygon_area_2d } from "../compute_polygon_area_2d.js";
 import { intersect_ray_2d } from "../intersect_ray_2d.js";
 import { UintArrayForCount } from "../../../collection/array/typed/uint_array_for_count.js";

package/src/core/geom/2d/convex-hull/fixed_convex_hull_relaxation.js

@@ -1,4 +1,4 @@
-import { array_copy } from "../../../collection/array/copyArray.js";
+import { array_copy } from "../../../collection/array/array_copy.js";
 import { Uint32Heap } from "../../../collection/heap/Uint32Heap.js";
 import { intersect_ray_2d } from "../intersect_ray_2d.js";
 import { compute_triangle_area_2d } from "../compute_triangle_area_2d.js";

package/src/core/geom/2d/line/line_segment_compute_line_segment_intersection_2d.js

@@ -0,0 +1,35 @@
+import {
+    line_segment_compute_line_segment_intersection_array_2d
+} from "./line_segment_compute_line_segment_intersection_array_2d.js";
+
+const scratch_array = new Float32Array(2);
+
+/**
+ * @param {number} a0_x
+ * @param {number} a0_y
+ * @param {number} a1_x
+ * @param {number} a1_y
+ * @param {number} b0_x
+ * @param {number} b0_y
+ * @param {number} b1_x
+ * @param {number} b1_y
+ * @param {Vector2} result resulting intersection point will be stored here if intersection exists
+ * @returns {boolean} True if segments intersect, False otherwise
+ */
+export function line_segment_compute_line_segment_intersection_2d(
+    a0_x, a0_y, a1_x, a1_y,
+    b0_x, b0_y, b1_x, b1_y,
+    result
+) {
+    const collision = line_segment_compute_line_segment_intersection_array_2d(
+        scratch_array, 0,
+        a0_x, a0_y, a1_x, a1_y,
+        b0_x, b0_y, b1_x, b1_y,
+    );
+
+    if (collision) {
+        result.readFromArray(scratch_array);
+    }
+
+    return collision;
+}

package/src/core/geom/2d/line/line_segment_compute_line_segment_intersection_array_2d.js

@@ -0,0 +1,51 @@
+/**
+ *
+ * Find intersection point between two line segments if they intersect at all
+ * Adapted from answer by iMalc from stackoverflow.com "how do you detect where two line segments intersect"
+ * @link https://stackoverflow.com/questions/563198/how-do-you-detect-where-two-line-segments-intersect
+ *
+ * @param {number[]|Float32Array|Float64Array} result resulting intersection point will be stored here if intersection exists
+ * @param {number} result_offset
+ * @param {number} a0_x
+ * @param {number} a0_y
+ * @param {number} a1_x
+ * @param {number} a1_y
+ * @param {number} b0_x
+ * @param {number} b0_y
+ * @param {number} b1_x
+ * @param {number} b1_y
+ * @return {boolean} True if segments intersect, False otherwise
+ */
+export function line_segment_compute_line_segment_intersection_array_2d(
+    result, result_offset,
+    a0_x, a0_y, a1_x, a1_y,
+    b0_x, b0_y, b1_x, b1_y
+) {
+
+    const s1_x = a1_x - a0_x;
+    const s1_y = a1_y - a0_y;
+    const s2_x = b1_x - b0_x;
+    const s2_y = b1_y - b0_y;
+
+    const dy_02 = a0_y - b0_y;
+    const dx_02 = a0_x - b0_x;
+
+    const inv_denom = 1 / (-s2_x * s1_y + s1_x * s2_y);
+
+    const s = (-s1_y * dx_02 + s1_x * dy_02) * inv_denom;
+    const t = (s2_x * dy_02 - s2_y * dx_02) * inv_denom;
+
+    if (s >= 0 && s <= 1 && t >= 0 && t <= 1) {
+        // Collision detected
+
+        const intercept_x = a0_x + (t * s1_x);
+        const intercept_y = a0_y + (t * s1_y);
+
+        result[result_offset] = intercept_x;
+        result[result_offset + 1] = intercept_y;
+
+        return true;
+    }
+
+    return false; // No collision
+}

package/src/core/geom/2d/line/line_segment_compute_line_segment_intersection_vectors_2d.js

@@ -0,0 +1,15 @@
+import {
+    line_segment_compute_line_segment_intersection_2d
+} from "./line_segment_compute_line_segment_intersection_2d.js";
+
+/**
+ * @param {Vector2} a0 start of first segment
+ * @param {Vector2} a1 end of first segment
+ * @param {Vector2} b0 start of second segment
+ * @param {Vector2} b1 end of second segment
+ * @param {Vector2} result resulting intersection point will be stored here if intersection exists
+ * @returns {boolean} True if segments intersect, False otherwise
+ */
+export function line_segment_compute_line_segment_intersection_vectors_2d(a0, a1, b0, b1, result) {
+    return line_segment_compute_line_segment_intersection_2d(a0.x, a0.y, a1.x, a1.y, b0.x, b0.y, b1.x, b1.y, result);
+}

package/src/core/geom/2d/line/line_segment_compute_line_segment_intersection_vectors_array_2d.js

@@ -0,0 +1,30 @@
+import {
+    line_segment_compute_line_segment_intersection_array_2d
+} from "./line_segment_compute_line_segment_intersection_array_2d.js";
+
+/**
+ * @param {Vector2} p0
+ * @param {Vector2} p1
+ * @param {Vector2} p2
+ * @param {Vector2} p3
+ * @returns {[number,number]}
+ */
+export function line_segment_compute_line_segment_intersection_vectors_array_2d(p0, p1, p2, p3) {
+    const p0_x = p0.x;
+    const p0_y = p0.y;
+    const p1_x = p1.x;
+    const p1_y = p1.y;
+    const p2_x = p2.x;
+    const p2_y = p2.y;
+    const p3_x = p3.x;
+    const p3_y = p3.y;
+
+    const result = [];
+
+    if (line_segment_compute_line_segment_intersection_array_2d(result, 0, p0_x, p0_y, p1_x, p1_y, p2_x, p2_y, p3_x, p3_y)) {
+        return result;
+    } else {
+        return null; // No collision
+    }
+
+}

package/src/core/geom/2d/line/line_segment_line_segment_intersection_exists_2d.js

@@ -0,0 +1,29 @@
+/**
+ *
+ * @param {number} a0_x
+ * @param {number} a0_y
+ * @param {number} a1_x
+ * @param {number} a1_y
+ * @param {number} b0_x
+ * @param {number} b0_y
+ * @param {number} b1_x
+ * @param {number} b1_y
+ * @returns {boolean} True if segments intersect, False otherwise
+ * @public
+ */
+export function line_segment_line_segment_intersection_exists_2d(a0_x, a0_y, a1_x, a1_y, b0_x, b0_y, b1_x, b1_y) {
+    const s1_x = a1_x - a0_x;
+    const s1_y = a1_y - a0_y;
+    const s2_x = b1_x - b0_x;
+    const s2_y = b1_y - b0_y;
+
+    const dy_02 = a0_y - b0_y;
+    const dx_02 = a0_x - b0_x;
+
+    const inv_denom = 1 / (-s2_x * s1_y + s1_x * s2_y);
+
+    const s = (-s1_y * dx_02 + s1_x * dy_02) * inv_denom;
+    const t = (s2_x * dy_02 - s2_y * dx_02) * inv_denom;
+
+    return s >= 0 && s <= 1 && t >= 0 && t <= 1;
+}

package/src/core/geom/3d/aabb/AABB3.d.ts

@@ -12,6 +12,8 @@ export class AABB3 {
 
     setBounds(x0: number, y0: number, z0: number, x1: number, y1: number, z1: number): void
 
+    setBoundsUnordered(x0: number, y0: number, z0: number, x1: number, y1: number, z1: number): void
+
     getCenter(target: Vector3): void
 
     getCenterX(): number
@@ -43,4 +45,6 @@ export class AABB3 {
     equals(other: AABB3): boolean
 
     copy(other: AABB3): void
+
+    _isBelowPlane(nx: number, ny: number, nz: number, constant: number): boolean
 }

package/src/core/geom/3d/aabb/AABB3.spec.js

@@ -6,6 +6,12 @@ import { serializeAABB3 } from "./serializeAABB3.js";
 import { deserializeAABB3 } from "./deserializeAABB3.js";
 
 
+/**
+ *
+ * @param {AABB3} expected
+ * @param {AABB3} actual
+ * @param {number} [numDigits]
+ */
 function compareBounds(expected, actual, numDigits = 10) {
     expect(actual.x0).toBeCloseTo(expected.x0, numDigits);
     expect(actual.y0).toBeCloseTo(expected.y0, numDigits);
@@ -225,3 +231,27 @@ test("getExtentsZ", () => {
     expect(new AABB3(0, 0, 0, 0, 0, 1).getExtentsZ()).toBeCloseTo(1);
     expect(new AABB3(0, 0, -1, 0, 0, 1).getExtentsZ()).toBeCloseTo(2);
 });
+
+test("setBoundsUnordered", () => {
+    const aabb = new AABB3();
+
+    aabb.setBoundsUnordered(1, 2, 3, -5, -7, -11);
+
+    compareBounds(aabb, new AABB3(-5, -7, -11, 1,2,3));
+
+    aabb.setBoundsUnordered(-5, -7, -11, 1, 2, 3);
+
+    compareBounds(aabb, new AABB3(-5, -7, -11, 1,2,3));
+
+    aabb.setBoundsUnordered(1, -7, -11, -5, 2, 3);
+
+    compareBounds(aabb, new AABB3(-5, -7, -11, 1,2,3));
+
+    aabb.setBoundsUnordered(-5, 2, -11, 1, -7, 3);
+
+    compareBounds(aabb, new AABB3(-5, -7, -11, 1,2,3));
+
+    aabb.setBoundsUnordered(-5, -7, 3, 1, 2, -11);
+
+    compareBounds(aabb, new AABB3(-5, -7, -11, 1,2,3));
+});

package/src/core/geom/3d/matrix/m4_make_translation.js

@@ -1,4 +1,4 @@
-import { array_copy } from "../../../collection/array/copyArray.js";
+import { array_copy } from "../../../collection/array/array_copy.js";
 import { MATRIX_4_IDENTITY } from "./MATRIX_4_IDENTITY.js";
 
 /**

package/src/core/geom/3d/sphere/harmonics/sh3_dering_optimize_positive.js

@@ -1,6 +1,6 @@
 import { max2 } from "../../../../math/max2.js";
 import { mat3, vec3 } from "gl-matrix";
-import { array_copy } from "../../../../collection/array/copyArray.js";
+import { array_copy } from "../../../../collection/array/array_copy.js";
 import { min2 } from "../../../../math/min2.js";
 import { assert } from "../../../../assert.js";
 

package/src/core/geom/3d/tetrahedra/TetrahedralMesh.js

@@ -2,7 +2,7 @@ import { tetrahedron_contains_point } from "./tetrahedron_contains_point.js";
 import { typed_array_copy } from "../../../collection/array/typed/typed_array_copy.js";
 import { max3 } from "../../../math/max3.js";
 import { assert } from "../../../assert.js";
-import { array_copy } from "../../../collection/array/copyArray.js";
+import { array_copy } from "../../../collection/array/array_copy.js";
 import { array_quick_sort_by_comparator } from "../../../collection/array/arrayQuickSort.js";
 import { compareNumbersDescending } from "../../../function/Functions.js";
 import { BinaryBuffer } from "../../../binary/BinaryBuffer.js";

package/src/core/geom/3d/tetrahedra/compute_circumsphere.js

@@ -1,4 +1,4 @@
-import { array_copy } from "../../../collection/array/copyArray.js";
+import { array_copy } from "../../../collection/array/array_copy.js";
 import { v3_dot } from "../../v3_dot.js";
 
 const MAX_FLOAT32 = 3.4028234663852886e+38;

package/src/core/geom/3d/tetrahedra/delaunay/fill_in_a_cavity.js

@@ -1,5 +1,5 @@
 import { assert } from "../../../../assert.js";
-import { array_copy } from "../../../../collection/array/copyArray.js";
+import { array_copy } from "../../../../collection/array/array_copy.js";
 import { INVALID_NEIGHBOUR } from "../TetrahedralMesh.js";
 import { validate_neighbour } from "../validate_tetrahedral_mesh.js";
 

package/src/core/geom/3d/topology/bounds/computeTriangleClusterNormalBoundingCone.js

@@ -1,7 +1,7 @@
 import { Miniball } from "../../../packing/miniball/Miniball.js";
 import { PointSet } from "../../../packing/miniball/PointSet.js";
 import { ConicRay } from "../../../ConicRay.js";
-import { array_copy } from "../../../../collection/array/copyArray.js";
+import { array_copy } from "../../../../collection/array/array_copy.js";
 import { min2 } from "../../../../math/min2.js";
 import { v3_angle_between } from "../../../v3_angle_between.js";
 

package/src/core/geom/3d/topology/expandConnectivityByLocality.js

@@ -1,4 +1,4 @@
-import { array_copy } from "../../../collection/array/copyArray.js";
+import { array_copy } from "../../../collection/array/array_copy.js";
 import { computeTopoMeshVertexDuplicates } from "./computeTopoMeshVertexDuplicates.js";
 import { arraySetSortingDiff } from "../../../collection/array/arraySetSortingDiff.js";
 import { compareFaces } from "./compareFaces.js";

package/src/core/geom/3d/topology/struct/binary/BinaryTopology.js

@@ -1,5 +1,5 @@
 import { BinaryElementPool } from "./BinaryElementPool.js";
-import { array_copy } from "../../../../../collection/array/copyArray.js";
+import { array_copy } from "../../../../../collection/array/array_copy.js";
 import { assert } from "../../../../../assert.js";
 
 /**

package/src/core/geom/Quaternion.d.ts

@@ -1,5 +1,6 @@
 import Signal from "../events/signal/Signal";
 import {Matrix4, Quaternion as ThreeQuaternion} from "three";
+import Vector3 from "./Vector3";
 
 interface Vector3Like {
     x: number,
@@ -28,12 +29,18 @@ export default class Quaternion {
 
     clone(): Quaternion
 
+    random(random?:()=>number):void
+
     equals(other: { x: number, y: number, z: number, w: number }): boolean
 
+    roughlyEquals(other: { x: number, y: number, z: number, w: number }, tolerance?: number): boolean
+
     slerp(other: Quaternion, t: number): void
 
     normalize(): void
 
+    length():number
+
     __setFromEuler(x: number, y: number, z: number, order?: string): void
 
     setFromRotationMatrix(m: Matrix4): void
@@ -54,6 +61,8 @@ export default class Quaternion {
 
     fromAxisAngle(axis: Vector3Like, angle: number): void
 
+    toAxisAngle(axis: Vector3):number
+
     computeTwistAngle(axis: Vector3Like): number
 
     multiplyQuaternions(a: Quaternion, b: Quaternion): void
@@ -69,4 +78,6 @@ export default class Quaternion {
     writeToArray(array: ArrayLike<number>, offset?: number): void
 
     asArray(): number[]
+
+    static readonly identity:Quaternion
 }