@woosh/meep-engine 2.43.13 → 2.43.14

package/core/bvh2/aabb3/aabb3_detailed_volume_intersection.js

@@ -4,9 +4,9 @@ import { plane3_computeLineSegmentIntersection } from "../../geom/Plane.js";
 import { aabb3_corner_edge_mapping } from "./aabb3_corner_edge_mapping.js";
 import { aabb3_edge_corner_mapping } from "./aabb3_edge_corner_mapping.js";
 import { plane_computeConvex3PlaneIntersection } from "../../geom/3d/plane/plane_computeConvex3PlaneIntersection.js";
-import { EPSILON } from "../../math/MathUtils.js";
 import { is_point_within_planes } from "../../geom/3d/plane/is_point_within_planes.js";
 import { v3_distance_above_plane } from "../../geom/v3_distance_above_plane.js";
+import { EPSILON } from "../../math/EPSILON.js";
 
 /**
  * Common piece of continuous memory for better cache coherence

package/core/bvh2/traversal/__process_point_if_within_planes.js

@@ -1,5 +1,5 @@
-import { EPSILON } from "../../math/MathUtils.js";
 import { v3_distance_above_plane } from "../../geom/v3_distance_above_plane.js";
+import { EPSILON } from "../../math/EPSILON.js";
 
 /**
  *

package/core/geom/3d/plane/is_point_within_planes.js

@@ -1,5 +1,5 @@
-import { EPSILON } from "../../../math/MathUtils.js";
 import { v3_distance_above_plane } from "../../v3_distance_above_plane.js";
+import { EPSILON } from "../../../math/EPSILON.js";
 
 /**
  *

package/core/geom/3d/plane/plane3_slerp.js

@@ -1,9 +1,9 @@
 import { lerp } from "../../../math/lerp.js";
-import { EPSILON } from "../../../math/MathUtils.js";
 import Vector3 from "../../Vector3.js";
 import { v3_dot } from "../../v3_dot.js";
 import { v3_length_sqr } from "../../v3_length_sqr.js";
 import { v3_slerp } from "../../v3_slerp.js";
+import { EPSILON } from "../../../math/EPSILON.js";
 
 const e = new Vector3();
 

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

@@ -1,5 +1,6 @@
-import { EPSILON, epsilonEquals } from "../../../math/MathUtils.js";
 import { mortonEncode_magicbits } from "../morton/mortonEncode_magicbits.js";
+import { epsilonEquals } from "../../../math/epsilonEquals.js";
+import { EPSILON } from "../../../math/EPSILON.js";
 
 /**
  *

package/core/geom/3d/topology/simplify/decimate_edge_collapse_snap.js

@@ -5,11 +5,11 @@ import { compute_edge_collapse_cost_quadratic } from "./quadratic/compute_edge_c
 import { tm_vertex_compute_normal } from "../tm_vertex_compute_normal.js";
 import { min2 } from "../../../../math/min2.js";
 import { vec3 } from "gl-matrix";
-import { EPSILON } from "../../../../math/MathUtils.js";
 import { tm_edge_collapse_is_degenerate_flip } from "./tm_edge_collapse_is_degenerate_flip.js";
 import { query_edge_is_boundary } from "../query/query_edge_is_boundary.js";
 import { tm_edge_kill } from "../tm_edge_kill.js";
 import { squirrel3 } from "../../../../math/hash/squirrel3.js";
+import { EPSILON } from "../../../../math/EPSILON.js";
 
 /**
  *

package/core/geom/3d/topology/simplify/quadratic/Quadratic3.js

@@ -1,8 +1,8 @@
 import { v3_dot } from "../../../../v3_dot.js";
 import { fabsf } from "../../../../../math/fabsf.js";
-import { EPSILON } from "../../../../../math/MathUtils.js";
 import { vec3 } from "gl-matrix";
 import { compute_triangle_normal } from "../../struct/TopoTriangle.js";
+import { EPSILON } from "../../../../../math/EPSILON.js";
 
 const scratch_v3 = new Float32Array(3);
 

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

@@ -1,7 +1,7 @@
 import { computeTopoMeshVertexDuplicates } from "./computeTopoMeshVertexDuplicates.js";
-import { EPSILON } from "../../../math/MathUtils.js";
 import { tm_vert_splice } from "./tm_vert_splice.js";
 import { debugValidateMesh } from "./debugValidateMesh.js";
+import { EPSILON } from "../../../math/EPSILON.js";
 
 /**
  *

package/core/geom/ConicRay.js

@@ -1,8 +1,9 @@
 import { assert } from "../assert.js";
-import { EPSILON, epsilonEquals } from "../math/MathUtils.js";
 import Vector3 from "./Vector3.js";
 import { computeHashIntegerArray } from "../collection/array/computeHashIntegerArray.js";
 import { computeHashFloat } from "../math/hash/computeHashFloat.js";
+import { epsilonEquals } from "../math/epsilonEquals.js";
+import { EPSILON } from "../math/EPSILON.js";
 
 
 /**

package/core/geom/Quaternion.js

@@ -8,11 +8,12 @@ import { assert } from "../assert.js";
 import Signal from "../events/signal/Signal.js";
 import { clamp } from "../math/clamp.js";
 import { lerp } from "../math/lerp.js";
-import { EPSILON, epsilonEquals } from "../math/MathUtils.js";
 import Vector3 from "./Vector3.js";
 import { v3_dot } from "./v3_dot.js";
 import { min2 } from "../math/min2.js";
 import { computeHashFloat } from "../math/hash/computeHashFloat.js";
+import { epsilonEquals } from "../math/epsilonEquals.js";
+import { EPSILON } from "../math/EPSILON.js";
 
 const matrix = new ThreeMatrix4();
 

package/core/geom/Vector3.js

@@ -6,7 +6,6 @@
 import { assert } from "../assert.js";
 import Signal from "../events/signal/Signal.js";
 import { lerp } from "../math/lerp.js";
-import { EPSILON, epsilonEquals } from "../math/MathUtils.js";
 import { sign } from "../math/sign.js";
 import { v3_dot } from "./v3_dot.js";
 import { v3_length_sqr } from "./v3_length_sqr.js";
@@ -15,6 +14,8 @@ import { v3_angle_between } from "./v3_angle_between.js";
 import { v3_lerp } from "./v3_lerp.js";
 import { v3_slerp } from "./v3_slerp.js";
 import { computeHashFloat } from "../math/hash/computeHashFloat.js";
+import { epsilonEquals } from "../math/epsilonEquals.js";
+import { EPSILON } from "../math/EPSILON.js";
 
 class Vector3 {
     /**
@@ -650,7 +651,9 @@ class Vector3 {
      * @return {boolean}
      */
     _roughlyEquals(x, y, z, tolerance = EPSILON) {
-        return epsilonEquals(this.x, x, tolerance) && epsilonEquals(this.y, y, tolerance) && epsilonEquals(this.z, z, tolerance);
+        return epsilonEquals(this.x, x, tolerance)
+            && epsilonEquals(this.y, y, tolerance)
+            && epsilonEquals(this.z, z, tolerance);
     }
 
     floor() {

package/core/geom/normalize_angle_rad.js

@@ -1,4 +1,4 @@
-import { PI2 } from "../math/MathUtils.js";
+import { PI2 } from "../math/PI2.js";
 
 /**
  * Force angle to [-PI, +PI] range

package/core/geom/random/randomPointInCircle.js

@@ -1,4 +1,4 @@
-import { PI2 } from "../../math/MathUtils.js";
+import { PI2 } from "../../math/PI2.js";
 
 /**
  * Pick a random point within a unit circle

package/core/geom/random/randomPointInSphere.js

@@ -1,4 +1,4 @@
-import { PI2 } from "../../math/MathUtils.js";
+import { PI2 } from "../../math/PI2.js";
 
 /**
  *

package/core/math/EPSILON.js

@@ -0,0 +1,5 @@
+/**
+ * Very small value, used for comparison when compensation for rounding error is required
+ * @type {number}
+ */
+export const EPSILON = 0.000001;

package/core/math/PI2.js

@@ -0,0 +1,5 @@
+/**
+ * Pi*2
+ * @type {number}
+ */
+export const PI2 = Math.PI * 2;

package/core/math/PI_HALF.js

@@ -0,0 +1,5 @@
+/**
+ * Pi/2
+ * @type {number}
+ */
+export const PI_HALF = Math.PI / 2;

package/core/math/bezierCurve.js

@@ -0,0 +1,22 @@
+/**
+ * 3-rd degree bezier curve
+ * @param {number} t
+ * @param {number} p0 start point
+ * @param {number} p1 control point
+ * @param {number} p2 control point
+ * @param {number} p3 end point
+ * @returns {number}
+ */
+function bezierCurve(t, p0, p1, p2, p3) {
+    const nt = 1 - t;
+
+    const nt_2 = nt * nt;
+
+    const nt_3 = nt_2 * nt;
+
+    const t_2 = t * t;
+
+    const t_3 = t_2 * t;
+
+    return nt_3 * p0 + 3 * nt_2 * t * p1 + 3 * nt * t_2 * p2 + t_3 * p3;
+}

package/core/math/clamp.spec.js

@@ -0,0 +1,15 @@
+import { clamp } from "./clamp.js";
+
+test('clamp', () => {
+    expect(clamp(0, 0, 0)).toBe(0);
+
+    expect(clamp(0, 1, 1)).toBe(1);
+
+    expect(clamp(0, -1, -1)).toBe(-1);
+
+    expect(clamp(3, 1, 2)).toBe(2);
+
+    expect(clamp(0, 1, 2)).toBe(1);
+
+    expect(clamp(2, 1, 3)).toBe(2);
+});

package/core/math/computeGreatestCommonDivisor.js

@@ -0,0 +1,28 @@
+import { assert } from "../assert.js";
+import { min2 } from "./min2.js";
+
+/**
+ * Find the greatest common divisor (denominator/factor)
+ * @param {number} a
+ * @param {number} b
+ * @returns {number}
+ */
+export function computeGreatestCommonDivisor(a, b) {
+    assert.typeOf(a, 'number', 'a');
+    assert.typeOf(b, 'number', 'b');
+
+    // start with the lowest of the two as a guess
+    let result = min2(a, b);
+
+    while (result > 1) {
+        if (a % result === 0 && b % result === 0) {
+            // found a common divisor
+            break;
+        }
+
+        // keep going down
+        result--;
+    }
+
+    return result;
+}

package/core/math/computeIsoscelesTriangleApexAngle.js

@@ -0,0 +1,17 @@
+/**
+ *
+ * @param {number} side length of the side
+ * @param {number} base length of the base
+ * @returns {number}
+ */
+export function computeIsoscelesTriangleApexAngle(side, base) {
+    const b2 = base * base;
+    const s2 = side * side;
+
+    const upper = (2 * s2 - b2);
+    const lower = (2 * s2);
+
+    const cosAlpha = upper / lower;
+
+    return Math.acos(cosAlpha);
+}

package/core/math/computeWholeDivisorLow.js

@@ -0,0 +1,30 @@
+import { assert } from "../assert.js";
+
+/**
+ * Compute lowest positive integer divisor of a given "product" value
+ * @param {number} product
+ * @param {number} limit
+ * @returns {number}
+ */
+export function computeWholeDivisorLow(product, limit) {
+    assert.typeOf(product, 'number', 'product');
+    assert.typeOf(limit, 'number', 'limit');
+
+
+    assert.ok(Number.isInteger(product), `expected product to be an integer, instead got '${product}'`);
+    assert.ok(Number.isInteger(limit), `expected limit to be an integer, instead got '${limit}'`);
+
+    let i = limit;
+
+    while (i > 1) {
+
+        if (product % i === 0) {
+            break;
+        }
+
+        i--;
+
+    }
+
+    return i;
+}

package/core/math/computeWholeDivisorLow.spec.js

@@ -0,0 +1,9 @@
+import { computeWholeDivisorLow } from "./computeWholeDivisorLow.js";
+
+test('computeWholeDivisorLow 1/1', () => {
+    expect(computeWholeDivisorLow(1, 1)).toEqual(1);
+});
+
+test('computeWholeDivisorLow 16/5', () => {
+    expect(computeWholeDivisorLow(16, 5)).toEqual(4);
+});

package/core/math/copysign.spec.js

@@ -0,0 +1,13 @@
+import { copysign } from "./copysign.js";
+
+test('copysign', () => {
+    expect(copysign(1, 2)).toBe(1);
+    expect(copysign(2, 1)).toBe(2);
+
+    expect(copysign(2, -1)).toBe(-2);
+    expect(copysign(-2, 1)).toBe(2);
+    expect(copysign(-2, -1)).toBe(-2);
+
+    expect(copysign(3, 7)).toBe(3);
+    expect(copysign(3, -7)).toBe(-3);
+});

package/core/math/cubicCurve.js

@@ -0,0 +1,34 @@
+/**
+ *
+ * @param {Number} t
+ * @param {Number} p0
+ * @param {Number} p1
+ * @param {Number} p2
+ * @param {Number} p3
+ * @return {Number}
+ */
+export function cubicCurve(t, p0, p1, p2, p3) {
+    /**
+     *
+     * @type {number}
+     */
+    const cX = 3 * (p1 - p0);
+
+    /**
+     *
+     * @type {number}
+     */
+    const bX = 3 * (p2 - p1) - cX;
+
+    /**
+     *
+     * @type {number}
+     */
+    const aX = p3 - p0 - cX - bX;
+
+    const t_2 = t * t;
+
+    const t_3 = t_2 * t;
+
+    return (aX * t_3) + (bX * t_2) + (cX * t) + p0;
+}

package/core/math/cubicCurve.spec.js

@@ -0,0 +1,13 @@
+import { cubicCurve } from "./cubicCurve.js";
+
+test("cubicCurve", () => {
+    expect(cubicCurve(0, 1, 2, 3, 4)).toBe(1);
+
+    expect(cubicCurve(0, 2, 3, 4, 5)).toBe(2);
+
+    expect(cubicCurve(1, 2, 3, 4, 5)).toBe(5);
+
+    expect(cubicCurve(1, 3, 4, 5, 6)).toBe(6);
+
+    expect(cubicCurve(2, 2, 2, 2, 3)).toBe(10);
+});

package/core/math/epsilonEquals.js

@@ -0,0 +1,16 @@
+import { assert } from "../assert.js";
+
+/**
+ * Comparison of two numbers with a given tolerance
+ * @param {number} a
+ * @param {number} b
+ * @param {number} tolerance
+ * @returns {boolean}
+ */
+export function epsilonEquals(a, b, tolerance) {
+    assert.isNumber(a, 'a');
+    assert.isNumber(b, 'b');
+    assert.isNumber(tolerance, 'tolerance');
+
+    return Math.abs(a - b) <= tolerance;
+}

package/core/math/hash/computeHashFloat.spec.js

@@ -0,0 +1,7 @@
+import { computeHashFloat } from "./computeHashFloat.js";
+
+test("computeHashFloat", () => {
+    expect(computeHashFloat(500)).toEqual(computeHashFloat(500));
+
+    expect(computeHashFloat(500)).not.toEqual(computeHashFloat(400))
+});

package/core/math/inverseLerp.spec.js

@@ -0,0 +1,13 @@
+import { inverseLerp } from "./inverseLerp.js";
+
+test('inverseLerp', () => {
+    expect(inverseLerp(0, 5, 0.5)).toBe(0.1);
+
+    expect(inverseLerp(-5, 5, 0)).toBe(0.5);
+
+    expect(inverseLerp(0, 0, 0)).toBe(0);
+
+    expect(inverseLerp(1, 2, 1)).toBe(0);
+
+    expect(inverseLerp(1, 2, 2)).toBe(1);
+});

package/core/math/isValueBetween.spec.js

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

package/core/math/isValueBetweenInclusive.spec.js

@@ -0,0 +1,16 @@
+import { isValueBetweenInclusive } from "./isValueBetweenInclusive.js";
+
+
+test("isValueBetweenInclusive", () => {
+    expect(isValueBetweenInclusive(1, 1, 2)).toBe(true);
+
+    expect(isValueBetweenInclusive(2, 1, 2)).toBe(true);
+
+    expect(isValueBetweenInclusive(1.5, 1, 2)).toBe(true);
+
+    expect(isValueBetweenInclusive(0.5, 1, 2)).toBe(false);
+
+    expect(isValueBetweenInclusive(3, 1, 2)).toBe(false);
+});
+
+

package/core/math/lerp.spec.js

@@ -0,0 +1,15 @@
+import { lerp } from "./lerp.js";
+
+test('lerp', () => {
+    expect(lerp(0, 5, 0.1)).toBe(0.5);
+
+    expect(lerp(-5, 5, 0.5)).toBe(0);
+
+    expect(lerp(0, 0, 0)).toBe(0);
+
+    expect(lerp(0, 0, 1)).toBe(0);
+
+    expect(lerp(1, 2, 0)).toBe(1);
+
+    expect(lerp(1, 2, 1)).toBe(2);
+});

package/core/math/makeCubicCurve.js

@@ -0,0 +1,15 @@
+import { cubicCurve } from "./cubicCurve.js";
+
+/**
+ *
+ * @param {Number} p0
+ * @param {Number} p1
+ * @param {Number} p2
+ * @param {Number} p3
+ * @return {function(number): Number}
+ */
+export function makeCubicCurve(p0, p1, p2, p3) {
+    return function (v) {
+        return cubicCurve(v, p0, p1, p2, p3);
+    }
+}

package/core/math/makeCubicCurve.spec.js

@@ -0,0 +1,9 @@
+import { makeCubicCurve } from "./makeCubicCurve.js";
+
+test("makeCubicCurve", () => {
+    const f = makeCubicCurve(1, 2, 3, 4);
+    expect(f(0)).toBe(1);
+
+    expect(f(1)).toBe(4);
+});
+

package/core/math/makeSequenceLoop.js

@@ -0,0 +1,20 @@
+/**
+ * @template T
+ * @param {T[]} sequence
+ * @returns {function(): T}
+ */
+export function makeSequenceLoop(sequence) {
+    let i = 0;
+
+    const data = sequence.slice();
+    const n = data.length;
+
+
+    return function sequenceLoop() {
+        const datum = data[i % n];
+
+        i++;
+
+        return datum;
+    }
+}

package/core/math/max2.spec.js

@@ -0,0 +1,13 @@
+import { max2 } from "./max2.js";
+
+test('max2', () => {
+    expect(max2(0, 0)).toBe(0);
+
+    expect(max2(2, 1)).toBe(2);
+
+    expect(max2(1, 2)).toBe(2);
+
+    expect(max2(-1, 1)).toBe(1);
+
+    expect(max2(1, -1)).toBe(1);
+});

package/core/math/max3.spec.js

@@ -0,0 +1,27 @@
+import { max3 } from "./max3.js";
+
+test("max3", () => {
+    expect(max3(-1, -3, 1)).toBe(1);
+
+    expect(max3(-3, -1, 1)).toBe(1);
+
+    expect(max3(-3, 1, -1)).toBe(1);
+
+    expect(max3(-1, 1, -3)).toBe(1);
+
+    expect(max3(1, -1, -3)).toBe(1);
+
+    expect(max3(1, -3, -1)).toBe(1);
+
+    expect(max3(-3, 1, 1)).toBe(1);
+
+    expect(max3(3, 1, 1)).toBe(3);
+
+    expect(max3(3, 3, -1)).toBe(3);
+
+    expect(max3(3, 3, 4)).toBe(4);
+
+    expect(max3(3, 0, 3)).toBe(3);
+
+    expect(max3(3, 4, 3)).toBe(4);
+});

package/core/math/min2.spec.js

@@ -23,3 +23,15 @@ test("0,-1", () => {
 test("Infinity,-Infinity", () => {
     expect(min2(Infinity, -Infinity)).toBe(-Infinity);
 });
+
+test('min2', () => {
+    expect(min2(0, 0)).toBe(0);
+
+    expect(min2(2, 1)).toBe(1);
+
+    expect(min2(1, 2)).toBe(1);
+
+    expect(min2(-1, 1)).toBe(-1);
+
+    expect(min2(1, -1)).toBe(-1);
+});

package/core/math/min3.spec.js

@@ -0,0 +1,27 @@
+import { min3 } from "./min3.js";
+
+test("min3", () => {
+    expect(min3(-1, -3, 1)).toBe(-3);
+
+    expect(min3(-3, -1, 1)).toBe(-3);
+
+    expect(min3(-1, 1, -3)).toBe(-3);
+
+    expect(min3(1, -3, -1)).toBe(-3);
+
+    expect(min3(-3, 1, -1)).toBe(-3);
+
+    expect(min3(1, -1, -3)).toBe(-3);
+
+    expect(min3(-3, 1, 1)).toBe(-3);
+
+    expect(min3(2, 1, 1)).toBe(1);
+
+    expect(min3(3, 3, -1)).toBe(-1);
+
+    expect(min3(3, 3, 4)).toBe(3);
+
+    expect(min3(3, 0, 3)).toBe(0);
+
+    expect(min3(3, 4, 3)).toBe(3);
+});

package/core/math/normalizeArrayVector.js

@@ -0,0 +1,25 @@
+/**
+ * Assuming the input is an N-dimension vector, normalizes the vector to magnitude of 1
+ * @param {number[]|Float32Array} result
+ * @param {number[]|Float32Array} data
+ * @param {number} [length] number of dimensions
+ */
+export function normalizeArrayVector(result, data, length = data.length) {
+
+    let magnitude2 = 0;
+
+    for (let i = 0; i < length; i++) {
+        const value = data[i];
+
+        const value2 = value * value;
+
+        magnitude2 += value2;
+    }
+
+    const magnitude_inv = 1 / Math.sqrt(magnitude2);
+
+    for (let i = 0; i < length; i++) {
+        result[i] = data[i] * magnitude_inv;
+    }
+
+}

package/core/math/overlap1D.spec.js

@@ -0,0 +1,10 @@
+import { overlap1D } from "./overlap1D.js";
+
+test('overlap1D', () => {
+    expect(overlap1D(0, 0, 0, 0)).toBe(false);
+    expect(overlap1D(-3, -1, -2, -0.5)).toBe(true);
+    expect(overlap1D(-1, 2, 1, 1)).toBe(true);
+    expect(overlap1D(1, 1, -1, 2)).toBe(true);
+
+    expect(overlap1D(1, 2, 2, 3)).toBe(false);
+});

package/core/math/quadraticCurve.js

@@ -0,0 +1,11 @@
+/**
+ *
+ * @param {Number} t
+ * @param {Number} p0
+ * @param {Number} p1
+ * @param {Number} p2
+ * @return {number}
+ */
+export function quadraticCurve(t, p0, p1, p2) {
+    return (1 - t) * (1 - t) * p0 + 2 * (1 - t) * t * p1 + t * t * p2;
+}