@woosh/meep-engine 2.33.23 → 2.33.24

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

package/core/math/hash/computeHashFloat.js

@@ -0,0 +1,17 @@
+/**
+ *
+ * @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;
+}

package/core/math/hash/computeHashFloatArray.js

@@ -0,0 +1,34 @@
+import { computeHashFloat } from "./computeHashFloat.js";
+
+/**
+ *
+ * @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;
+}

package/core/math/hash/computeObjectHash.js

@@ -0,0 +1,54 @@
+import { computeStringHash } from "../../primitives/strings/computeStringHash.js";
+import { computeHashFloat } from "./computeHashFloat.js";
+
+/**
+ * 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;
+}

package/core/math/intersects1D.js

@@ -0,0 +1,19 @@
+import { assert } from "../assert.js";
+
+/**
+ * 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.isNumber(a0, "a0");
+    assert.isNumber(a1, "a1");
+    assert.isNumber(b0, "b0");
+    assert.isNumber(b1, "b1");
+
+    return a1 >= b0 && b1 >= a0;
+}

package/core/math/interval/NumericInterval.js

@@ -7,7 +7,7 @@
 import { assert } from "../../assert.js";
 import Signal from "../../events/signal/Signal.js";
 import { inverseLerp } from "../inverseLerp.js";
-import { computeHashFloat } from "../MathUtils.js";
+import { computeHashFloat } from "../hash/computeHashFloat.js";
 
 export class NumericInterval {
     /**
@@ -61,7 +61,7 @@ export class NumericInterval {
             this.max = max;
 
             if (this.onChanged.hasHandlers()) {
-                this.onChanged.dispatch(min, max, oldMin, oldMax);
+                this.onChanged.send4(min, max, oldMin, oldMax);
             }
         }
     }

package/core/math/isValueBetween.js

@@ -0,0 +1,10 @@
+/**
+ * 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);
+}

package/core/math/isValueBetweenInclusive.js

@@ -0,0 +1,10 @@
+/**
+ * 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);
+}

package/core/math/noise/curl_noise_3dt.js

@@ -16,7 +16,7 @@ export function curl_noise_3dt(result, x, y, z, w) {
 
     sdnoise3(p_x0, x + w, y, z);
     sdnoise3(p_y0, x + 31.341, y - 43.23 + w, z + 12.34);
-    sdnoise3(p_z0, x - 231.141, y + 124.123, z + -54.4341 + w);
+    sdnoise3(p_z0, x - 231.141, y + 124.123, z - 54.4341 + w);
 
     const _x = p_z0[1] - p_y0[2];
     const _y = p_x0[2] - p_z0[0];

package/core/math/noise/sdnoise.js

@@ -161,7 +161,7 @@ function grad2(result, hash) {
  * @param {number[]} result
  * @param {number} hash
  */
-function grad3(result, hash,) {
+function grad3(result, hash) {
     const h = hash & 15;
 
     const h3 = h * 3;
@@ -253,8 +253,8 @@ function sdnoise1(derivatives, x) {
  * F2 = 0.5*(sqrt(3.0)-1.0)
  * G2 = (3.0-Math.sqrt(3.0))/6.0
  */
-const F2 = .366025403;
-const G2 = .211324865;
+const F2 = 0.3660254037844386;
+const G2 = 0.21132486540518713;
 
 /** 2D simplex noise with derivatives.
  * If the last two arguments are not null, the analytic derivative
@@ -398,8 +398,8 @@ function sdnoise2(derivatives, x, y) {
 /* Skewing factors for 3D simplex grid:
  * F3 = 1/3
  * G3 = 1/6 */
-const F3 = .333333333;
-const G3 = .166666667;
+const F3 = 0.3333333333333333;
+const G3 = 0.16666666666666666;
 
 
 /** 3D simplex noise with derivatives.
@@ -519,9 +519,9 @@ export function sdnoise3(derivatives, x, y, z) {
     const z3 = z0 - 1.0 + G9;
 
     /* Wrap the integer indices at 256, to avoid indexing perm[] out of bounds */
-    const ii = i % 256;
-    const jj = j % 256;
-    const kk = k % 256;
+    const ii = i & 255;
+    const jj = j & 255;
+    const kk = k & 255;
 
     /* Calculate the contribution from the four corners */
     t0 = 0.6 - x0 * x0 - y0 * y0 - z0 * z0;
@@ -652,8 +652,8 @@ export function sdnoise3(derivatives, x, y, z) {
 }
 
 // The skewing and unskewing factors are hairy again for the 4D case
-const F4 = 0.309016994;// F4 = (Math.sqrt(5.0)-1.0)/4.0
-const G4 = 0.138196601; // G4 = (5.0-Math.sqrt(5.0))/20.0
+const F4 = 0.30901699437494745;// F4 = (Math.sqrt(5.0)-1.0)/4.0
+const G4 = 0.1381966011250105; // G4 = (5.0-Math.sqrt(5.0))/20.0
 
 /**
  * 4D simplex noise with derivatives.

package/core/math/overlap1D.js

@@ -0,0 +1,19 @@
+import { assert } from "../assert.js";
+
+/**
+ * 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.isNumber(a0, "a0");
+    assert.isNumber(a1, "a1");
+    assert.isNumber(b0, "b0");
+    assert.isNumber(b1, "b1");
+
+    return a1 > b0 && b1 > a0;
+}

package/core/math/pingpong.js

@@ -0,0 +1,17 @@
+// compute euclidian modulo of m % n
+// https://en.wikipedia.org/wiki/Modulo_operation
+function euclideanModulo(n, m) {
+
+    return ((n % m) + m) % m;
+
+}
+
+/**
+ *
+ * @param {number} x
+ * @param {number} length
+ * @return {number}
+ */
+export function pingpong(x, length = 1) {
+    return length - Math.abs(euclideanModulo(x, length * 2) - length);
+}