@woosh/meep-engine 2.33.22 → 2.33.26

package/core/geom/Plane.js

@@ -192,7 +192,8 @@ export function computePlaneLineIntersection(out, originX, originY, originZ, dir
 
 /**
  *
- * @param {Vector3} result
+ * @param {Float32Array|number[]|vec3} result
+ * @param {number} result_offset
  * @param {number} x0
  * @param {number} y0
  * @param {number} z0
@@ -205,30 +206,34 @@ export function computePlaneLineIntersection(out, originX, originY, originZ, dir
  * @param {number} dist
  * @returns {boolean}
  */
-export function plane3_computeLineSegmentIntersection(result, x0, y0, z0, x1, y1, z1, normalX, normalY, normalZ, dist) {
+export function plane3_computeLineSegmentIntersection(
+    result, result_offset,
+    x0, y0, z0,
+    x1, y1, z1,
+    normalX, normalY, normalZ, dist
+) {
+
     const directionX = x1 - x0;
     const directionY = y1 - y0;
     const directionZ = z1 - z0;
 
     const denom = v3_dot(directionX, directionY, directionZ, normalX, normalY, normalZ);
 
-    const p = v3_dot(normalX, normalY, normalZ, x0, y0, z0) + dist;
-
     if (denom === 0) {
         return false;
     }
 
+    const p = v3_dot(normalX, normalY, normalZ, x0, y0, z0) + dist;
+
     const t = -p / denom;
 
     if (t < 0 || t > 1) {
         return false;
     }
 
-    result.set(
-        directionX * t + x0,
-        directionY * t + y0,
-        directionZ * t + z0
-    );
+    result[result_offset] = directionX * t + x0;
+    result[result_offset + 1] = directionY * t + y0;
+    result[result_offset + 2] = directionZ * t + z0;
 
     return true;
 

package/core/geom/Rectangle.js

@@ -1,10 +1,11 @@
 /**
  * Created by Alex on 14/03/2016.
  */
-import { intersects1D, overlap1D } from "../math/MathUtils.js";
 import { max2 } from "../math/max2.js";
 import { min2 } from "../math/min2.js";
 import Vector2 from "./Vector2.js";
+import { intersects1D } from "../math/intersects1D.js";
+import { overlap1D } from "../math/overlap1D.js";
 
 
 /**

package/core/geom/Vector1.js

@@ -6,7 +6,7 @@
 import { assert } from "../assert.js";
 import Signal from "../events/signal/Signal.js";
 import { clamp } from "../math/clamp.js";
-import { computeHashFloat } from "../math/MathUtils.js";
+import { computeHashFloat } from "../math/hash/computeHashFloat.js";
 
 
 class Vector1 extends Number {

package/core/geom/Vector3.js

@@ -6,7 +6,7 @@
 import { assert } from "../assert.js";
 import Signal from "../events/signal/Signal.js";
 import { lerp } from "../math/lerp.js";
-import { computeHashFloat, EPSILON, epsilonEquals } from "../math/MathUtils.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";
@@ -14,6 +14,7 @@ import { v3_length } from "./v3_length.js";
 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";
 
 class Vector3 {
     /**

package/core/geom/Vector4.js

@@ -5,7 +5,8 @@
 import { assert } from "../assert.js";
 import { Signal } from "../events/signal/Signal.js";
 import { lerp } from "../math/lerp.js";
-import { computeHashFloat, computeHashIntegerArray } from "../math/MathUtils.js";
+import { computeHashIntegerArray } from "../collection/array/computeHashIntegerArray.js";
+import { computeHashFloat } from "../math/hash/computeHashFloat.js";
 
 /**
  *

package/core/geom/random/randomPointInBox.js

@@ -1,12 +1,16 @@
 /**
  *
  * @param {function} random
- * @param {Vector3} result
+ * @param {number[]} result
+ * @param {number} result_offset
  */
-export function randomPointInBox(random, result) {
+export function randomPointInBox(random, result, result_offset) {
     const x = random() - 0.5;
     const y = random() - 0.5;
     const z = random() - 0.5;
 
-    result.set(x, y, z);
+    //write the result
+    result[result_offset] = x;
+    result[result_offset + 1] = y;
+    result[result_offset + 2] = z;
 }

package/core/geom/random/randomPointInPoint.js

@@ -1,8 +1,11 @@
 /**
  * Volumetric sampling method, since sample volume is a point, it simply sets result to origin
  * @param {function} random
- * @param {Vector3} result
+ * @param {number[]} result
+ * @param {number} destination_offset
  */
-export function randomPointInPoint(random, result) {
-    result.set(0, 0, 0);
+export function randomPointInPoint(random, result, destination_offset) {
+    result[destination_offset] = 0;
+    result[destination_offset + 1] = 0;
+    result[destination_offset + 2] = 0;
 }

package/core/geom/random/randomPointInSphere.js

@@ -4,18 +4,20 @@ import { PI2 } from "../../math/MathUtils.js";
  *
  * @see based on python code suggested here: https://stackoverflow.com/questions/5408276/sampling-uniformly-distributed-random-points-inside-a-spherical-volume
  * @param {function} random
- * @param {Vector3} result
+ * @param {number[]} result
+ * @param {number} result_offset
  */
-export function randomPointInSphere(random, result) {
+export function randomPointInSphere(random, result, result_offset) {
     const phi = PI2 * random();
 
     const cosTheta = random() * 2 - 1;
 
-    const u = random() * 0.5;
+    const u = random();
 
     const theta = Math.acos(cosTheta);
 
-    const r = Math.cbrt(u);
+    // compute radius
+    const r = Math.cbrt(u) * 0.5;
 
     const sinTheta = Math.sin(theta);
 
@@ -27,5 +29,7 @@ export function randomPointInSphere(random, result) {
     const z = r * cosTheta;
 
     //write the result
-    result.set(x, y, z);
+    result[result_offset] = x;
+    result[result_offset + 1] = y;
+    result[result_offset + 2] = z;
 }

package/core/geom/random/randomPointOnBox.js

@@ -1,9 +1,10 @@
 /**
  *
  * @param {function} random
- * @param {Vector3} result
+ * @param {number[]} result
+ * @param {number} result_offset
  */
-export function randomPointOnBox(random, result) {
+export function randomPointOnBox(random, result, result_offset) {
     //pick a side
     const side = random();
 
@@ -29,5 +30,8 @@ export function randomPointOnBox(random, result) {
         z = fixedAxis;
     }
 
-    result.set(x, y, z);
+    //write the result
+    result[result_offset] = x;
+    result[result_offset + 1] = y;
+    result[result_offset + 2] = z;
 }

package/core/geom/random/randomPointOnSphere.js

@@ -2,9 +2,10 @@
  *
  * @see based on python code suggested here: https://stackoverflow.com/questions/5408276/sampling-uniformly-distributed-random-points-inside-a-spherical-volume
  * @param {function} random
- * @param {Vector3} result
+ * @param {number[]} result
+ * @param {number} result_offset
  */
-export function randomPointOnSphere(random, result) {
+export function randomPointOnSphere(random, result, result_offset) {
     const phi = Math.PI * 2 * random();
 
     const cosTheta = random() * 2 - 1;
@@ -23,5 +24,7 @@ export function randomPointOnSphere(random, result) {
     const z = r * cosTheta;
 
     //write the result
-    result.set(x, y, z);
+    result[result_offset] = x;
+    result[result_offset + 1] = y;
+    result[result_offset + 2] = z;
 }

package/core/geom/v3_length.js

@@ -1,5 +1,10 @@
-import { v3_length_sqr } from "./v3_length_sqr.js";
-
+/**
+ *
+ * @param {number} x
+ * @param {number} y
+ * @param {number} z
+ * @returns {number}
+ */
 export function v3_length(x, y, z) {
-    return Math.sqrt(v3_length_sqr(x, y, z));
+    return Math.hypot(x, y, z);
 }

package/core/graph/graph_k_means_cluster.js

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

package/core/json/resolvePathByArray.js

@@ -44,10 +44,10 @@ export function resolvePathByArray(object, parts, missingPropertyHandler) {
             } else {
                 const options = buildErrorSuggestions(current);
 
-                throw new Error(`failed to resolve path '${path}' at part ${i} [${part}]. Existing keys: ${options.join(", ")}`);
+                throw new Error(`failed to resolve path [${parts.join(',')}] at part ${i} [${part}]. Existing keys: ${options.join(", ")}`);
             }
         }
         current = current[part];
     }
     return current;
-}
+}

package/core/math/MathUtils.js

@@ -4,8 +4,6 @@
  */
 
 import { assert } from "../assert.js";
-import { computeStringHash } from "../primitives/strings/computeStringHash.js";
-import { max2 } from "./max2.js";
 import { min2 } from "./min2.js";
 
 /**
@@ -29,105 +27,6 @@ export function makeSequenceLoop(sequence) {
     }
 }
 
-/**
- * Performs a probabilistic rounding where a fraction is rounded up or down with probability equal to the fraction
- * @param {number} number
- * @param {function} random
- * @returns {int}
- */
-export function roundFair(number, random) {
-    const mantissa = number % 1;
-    const roll = random();
-    if (roll < mantissa) {
-        return Math.ceil(number);
-    } else {
-        return Math.floor(number);
-    }
-}
-
-/**
- * Returns a random number within a normal distribution (Bell/Gaussian curve)
- * @param {int} [quality=6] controls number of "die rolls" used to approximate curve, more rolls - better approximation but higher cost of computation
- * @param {function():number} random
- * @returns {number} value between 0 and 1 with normal weight at 0.5
- */
-export function randomGaussian(random, quality = 6) {
-    let s = 0;
-
-    for (let i = 0; i < quality; i++) {
-        s += random();
-    }
-
-    return s / quality;
-}
-
-/**
- * @template T
- * @param {function} random
- * @param {T[]} array
- * @returns {T}
- */
-export function randomFromArray(random, array) {
-    assert.isArray(array, 'array');
-    assert.typeOf(random, 'function', 'random');
-
-    const length = array.length;
-
-    const i = min2(length - 1, Math.floor(random() * length));
-
-    return array[i];
-}
-
-/**
- *
- * @param {function} random
- * @param {number} min
- * @param {number} max
- * @returns {number}
- */
-export function randomFloatBetween(random, min, max) {
-    const span = max - min;
-
-    const roll = random();
-
-    return roll * span + min;
-}
-
-/**
- * Inclusive random between two boundaries, result is integer
- * @param {function} random
- * @param {number} min lower boundary, must be an integer
- * @param {number} max upper boundary, must be an integer
- * @returns {number}
- */
-export function randomIntegerBetween(random, min, max) {
-    const span = max - min;
-
-    const roll = random();
-
-    return Math.round(roll * span) + min;
-}
-
-/**
- *
- * @param {function():number} random returns a number between 0 and 1
- * @param {number} min
- * @param {number} max
- * @returns {function():number} returns number between min and max
- */
-export function makeRangedRandom(random, min, max) {
-
-    if (min === 0 && max === 1) {
-        //input already returns values in correct range
-        return random;
-    }
-
-    const scale = max - min;
-    return function () {
-        return random() * scale + min;
-    };
-}
-
 /**
  * Compute lowest positive integer divisor of a given "product" value
  * @param {number} product
@@ -243,148 +142,6 @@ function bezierCurve(t, p0, p1, p2, p3) {
 }
 
 
-/**
- *
- * @param {number} v
- * @returns {number}
- */
-export function computeHashFloat(v) {
-    //we break the number up into fractional and whole parts
-    const fraction = v % 1;
-
-    const whole = v | 0;
-
-    //fractional part is scaled up into int32 range, this inexact method, as it will produce 0 hash for values below a certain threshold
-    const fractionHash = fraction * 1367130550;
-
-    //take XOR of both parts
-    return fractionHash ^ whole;
-}
-
-/**
- *
- * @param {number[]|Float32Array|Float64Array} values
- * @param {number} min
- * @param {number} max
- */
-export function computeHashFloatArray(values, min, max) {
-    const dataLength = values.length;
-
-    const dataRange = max - min;
-
-    /*
-     hash min and max
-     */
-    const minHash = computeHashFloat(min);
-    const maxHash = computeHashFloat(min);
-
-    let hash = ((minHash << 5) - minHash) + maxHash;
-
-    for (let i = 0; i < dataLength; i++) {
-        const singleValue = values[i];
-        //normalize value
-        const valueNormalized = (singleValue - min) / dataRange;
-        //scale value to integer range
-        const integerValue = valueNormalized * 4294967295;
-
-        hash = ((hash << 5) - hash) + integerValue;
-        hash |= 0; // Convert to 32bit integer
-    }
-
-    return hash;
-}
-
-/**
- * @template T
- * @param {T[]} array
- * @param {function(T):number} elementHashFunction
- */
-export function computeHashArray(array, elementHashFunction) {
-
-    const numArguments = array.length;
-    let hash = numArguments;
-
-    for (let i = 0; i < numArguments; i++) {
-
-        const singleValue = array[i];
-
-        const elementHash = elementHashFunction(singleValue);
-
-        hash = ((hash << 5) - hash) + elementHash;
-        hash |= 0; // Convert to 32bit integer
-    }
-
-    return hash;
-}
-
-/**
- * Computes hash on integer values
- * @param {...number} value
- * @returns {number}
- */
-export function computeHashIntegerArray(value) {
-    let hash = 0;
-    const numArguments = arguments.length;
-    for (let i = 0; i < numArguments; i++) {
-        const singleValue = arguments[i];
-        hash = ((hash << 5) - hash) + singleValue;
-        hash |= 0; // Convert to 32bit integer
-    }
-    return hash;
-}
-
-/**
- * Recursively computes object hash
- * @param {Object} value
- * @param {number} [depth=3] Maximum recursion depth
- * @returns {number}
- */
-export function computeObjectHash(value, depth = 3) {
-    if (value === undefined) {
-        return 1;
-    }
-
-    if (value === null) {
-        return 2;
-    }
-
-    let hash = 0;
-
-    for (let p in value) {
-
-        hash = ((hash << 5) - hash) + computeStringHash(p);
-
-        const pValue = value[p];
-
-        const pType = typeof pValue;
-
-        let pHash;
-        if (pType === "string") {
-            pHash = computeStringHash(pValue);
-        } else if (pType === "number") {
-            pHash = computeHashFloat(pValue);
-        } else if (pType === "boolean") {
-            pHash = pValue ? 1 : 0;
-        } else if (pType === "object") {
-
-            if (depth <= 0) {
-                pHash = 3;
-            } else {
-                pHash = computeObjectHash(pValue, depth - 1);
-            }
-
-        } else {
-            pHash = 0;
-        }
-
-        hash = ((hash << 5) - hash) + pHash;
-
-        hash |= 0; // Convert to 32bit integer
-    }
-
-    return hash;
-}
-
 /**
  *
  * @param {number} a
@@ -410,54 +167,6 @@ export function computeGreatestCommonDivisor(a, b) {
     return result;
 }
 
-/**
- * Exclusive test, boundaries are not included in positive test
- * @param {Number} value
- * @param {Number} v0
- * @param {Number} v1
- * @returns {boolean}
- */
-export function isValueBetween(value, v0, v1) {
-    return (v0 > value && value > v1) || (v1 > value && value > v0);
-}
-
-/**
- * Inclusive test, boundaries are included in positive test
- * @param {Number} value
- * @param {Number} v0
- * @param {Number} v1
- * @returns {boolean}
- */
-export function isValueBetweenInclusive(value, v0, v1) {
-    return (v0 >= value && value >= v1) || (v1 >= value && value >= v0);
-}
-
-
-/**
- * Return solutions for quadratic
- * @param {number} a
- * @param {number} b
- * @param {number} c
- * @returns {number[]|null}
- */
-export function solveQuadratic(a, b, c) {
-    let sol = null;
-    if (Math.abs(a) < 1e-6) {
-        if (Math.abs(b) < 1e-6) {
-            sol = Math.abs(c) < 1e-6 ? [0, 0] : null;
-        } else {
-            sol = [-c / b, -c / b];
-        }
-    } else {
-        let disc = b * b - 4 * a * c;
-        if (disc >= 0) {
-            disc = Math.sqrt(disc);
-            a = 2 * a;
-            sol = [(-b - disc) / a, (-b + disc) / a];
-        }
-    }
-    return sol;
-}
 
 /**
  *
@@ -492,60 +201,6 @@ export function epsilonEquals(a, b, tolerance) {
     return Math.abs(a - b) <= tolerance;
 }
 
-/**
- * Returns true if two 1D lines intersect, touch is treated as intersection
- * Parameters are assumed to be ordered, a1 >= a0, b1 >= b0
- * @param {Number} a0
- * @param {Number} a1
- * @param {Number} b0
- * @param {Number} b1
- * @returns {boolean}
- */
-export function intersects1D(a0, a1, b0, b1) {
-    assert.equal(typeof a0, "number");
-    assert.equal(typeof a1, "number");
-    assert.equal(typeof b0, "number");
-    assert.equal(typeof b1, "number");
-
-    return a1 >= b0 && b1 >= a0;
-}
-
-/**
- * Returns true if two 1D lines overlap, touch is not considered overlap
- * Parameters are assumed to be ordered, a1 > a0, b1 > b0
- * @param {Number} a0
- * @param {Number} a1
- * @param {Number} b0
- * @param {Number} b1
- * @returns {boolean}
- */
-export function overlap1D(a0, a1, b0, b1) {
-    assert.equal(typeof a0, "number");
-    assert.equal(typeof a1, "number");
-    assert.equal(typeof b0, "number");
-    assert.equal(typeof b1, "number");
-
-    return a1 > b0 && b1 > a0;
-}
-
-/**
- * Returns a number representing overlap distance between two 1D line segments.
- * Positive number indicates overlap, negative number indicates that segments do not overlap; 0 indicates that segments are touching.
- * @param {Number} a0
- * @param {Number} a1
- * @param {Number} b0
- * @param {Number} b1
- * @returns {number}
- */
-export function separation1D(a0, a1, b0, b1) {
-    assert.equal(typeof a0, "number");
-    assert.equal(typeof a1, "number");
-    assert.equal(typeof b0, "number");
-    assert.equal(typeof b1, "number");
-
-    return min2(a1, b1) - max2(a0, b0);
-}
-
 /**
  * Assuming the input is an N-dimension vector, normalizes the vector to magnitude of 1
  * @param {number[]|Float32Array} result
@@ -590,12 +245,3 @@ export const PI_HALF = Math.PI / 2;
  */
 export const EPSILON = 0.000001;
 
-/**
- *
- * @param {number} sigma
- * @param {number} v
- * @returns {number}
- */
-export function gaussian(sigma, v) {
-    return Math.exp(-(v * v) / (2 * sigma * sigma));
-}

package/core/math/MathUtils.spec.js

@@ -2,12 +2,18 @@ import { clamp } from "./clamp.js";
 import { copysign } from "./copysign.js";
 import { inverseLerp } from "./inverseLerp.js";
 import { lerp } from "./lerp.js";
-import { computeHashFloat, computeHashFloatArray, computeWholeDivisorLow, cubicCurve, isValueBetween, isValueBetweenInclusive, makeCubicCurve, overlap1D, quadraticCurve, solveQuadratic } from "./MathUtils.js";
+import { computeWholeDivisorLow, cubicCurve, makeCubicCurve, quadraticCurve } from "./MathUtils.js";
 import { max2 } from "./max2.js";
 import { max3 } from "./max3.js";
 import { min2 } from "./min2.js";
 import { min3 } from "./min3.js";
 import { sign } from "./sign.js";
+import { isValueBetween } from "./isValueBetween.js";
+import { isValueBetweenInclusive } from "./isValueBetweenInclusive.js";
+import { solveQuadratic } from "./solveQuadratic.js";
+import { overlap1D } from "./overlap1D.js";
+import { computeHashFloat } from "./hash/computeHashFloat.js";
+import { computeHashFloatArray } from "./hash/computeHashFloatArray.js";
 
 test('min2', () => {
     expect(min2(0, 0)).toBe(0);

package/core/math/gaussian.js

@@ -0,0 +1,9 @@
+/**
+ *
+ * @param {number} sigma
+ * @param {number} v
+ * @returns {number}
+ */
+export function gaussian(sigma, v) {
+    return Math.exp(-(v * v) / (2 * sigma * sigma));
+}