@woosh/meep-engine 2.33.22 → 2.33.26

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

package/core/math/random/makeRangedRandom.js

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

package/core/math/random/randomFloatBetween.js

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

package/core/math/random/randomFromArray.js

@@ -0,0 +1,19 @@
+import { assert } from "../../assert.js";
+import { min2 } from "../min2.js";
+
+/**
+ * @template T
+ * @param {function} random
+ * @param {T[]} array
+ * @returns {T}
+ */
+export function randomFromArray(random, array) {
+    assert.isArray(array, 'array');
+    assert.isFunction(random, 'random');
+
+    const length = array.length;
+
+    const i = min2(length - 1, Math.floor(random() * length));
+
+    return array[i];
+}

package/core/math/random/randomGaussian.js

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

package/core/math/random/randomIntegerBetween.js

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

package/core/math/random/roundFair.js

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

package/core/math/separation1D.js

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

package/core/math/solveQuadratic.js

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

package/core/model/BoundedValue.js

@@ -5,7 +5,7 @@
 
 import Signal from "../events/signal/Signal.js";
 import { inverseLerp } from "../math/inverseLerp.js";
-import { computeHashFloat } from "../math/MathUtils.js";
+import { computeHashFloat } from "../math/hash/computeHashFloat.js";
 
 /**
  *

package/core/model/node-graph/node/NodeInstancePortReference.js

@@ -1,5 +1,5 @@
 import { assert } from "../../../assert.js";
-import { computeHashIntegerArray } from "../../../math/MathUtils.js";
+import { computeHashIntegerArray } from "../../../collection/array/computeHashIntegerArray.js";
 
 /**
  * Reference for a port of a node instance

package/core/model/node-graph/node/Port.js

@@ -1,6 +1,6 @@
-import { computeHashIntegerArray } from "../../../math/MathUtils.js";
 import { computeStringHash } from "../../../primitives/strings/computeStringHash.js";
 import { PortDirection } from "./PortDirection.js";
+import { computeHashIntegerArray } from "../../../collection/array/computeHashIntegerArray.js";
 
 export class Port {
     constructor() {

package/core/model/reactive/evaluation/MultiPredicateEvaluator.spec.js

@@ -1,4 +1,3 @@
-import { randomFloatBetween, randomFromArray, randomIntegerBetween } from "../../../math/MathUtils.js";
 import { seededRandom } from "../../../math/random/seededRandom.js";
 import DataType from "../../../parser/simple/DataType.js";
 import { ReactiveLiteralBoolean } from "../model/terminal/ReactiveLiteralBoolean.js";
@@ -7,6 +6,9 @@ import { ReactiveLiteralString } from "../model/terminal/ReactiveLiteralString.j
 import { ReactiveReference } from "../model/terminal/ReactiveReference.js";
 import { createRandomReactiveExpression } from "../model/util/createRandomReactiveExpression.js";
 import { MultiPredicateEvaluator } from "./MultiPredicateEvaluator.js";
+import { randomFromArray } from "../../../math/random/randomFromArray.js";
+import { randomFloatBetween } from "../../../math/random/randomFloatBetween.js";
+import { randomIntegerBetween } from "../../../math/random/randomIntegerBetween.js";
 
 test.skip('performance', () => {
     const random = seededRandom(12319);

package/core/model/reactive/model/ReactiveBinaryExpression.js

@@ -1,6 +1,6 @@
 import { assert } from "../../../assert.js";
-import { computeHashIntegerArray } from "../../../math/MathUtils.js";
 import { ReactiveExpression } from "./ReactiveExpression.js";
+import { computeHashIntegerArray } from "../../../collection/array/computeHashIntegerArray.js";
 
 /**
  * @extends {ReactiveExpression}

package/core/model/reactive/model/terminal/ReactiveLiteralNumber.js

@@ -1,8 +1,8 @@
 import { assert } from "../../../../assert.js";
 import Signal from "../../../../events/signal/Signal.js";
-import { computeHashFloat } from "../../../../math/MathUtils.js";
 import DataType from "../../../../parser/simple/DataType.js";
 import { ReactiveExpression } from "../ReactiveExpression.js";
+import { computeHashFloat } from "../../../../math/hash/computeHashFloat.js";
 
 const dummySignal = new Signal();
 

package/core/model/reactive/model/terminal/ReactiveReference.js

@@ -1,8 +1,8 @@
 import { assert } from "../../../../assert.js";
-import { computeHashIntegerArray } from "../../../../math/MathUtils.js";
 import DataType from "../../../../parser/simple/DataType.js";
 import { computeStringHash } from "../../../../primitives/strings/computeStringHash.js";
 import { ReactiveExpression } from "../ReactiveExpression.js";
+import { computeHashIntegerArray } from "../../../../collection/array/computeHashIntegerArray.js";
 
 
 /**

package/core/model/reactive/model/util/createRandomReactiveExpression.js

@@ -4,7 +4,6 @@
  * @param {ReactiveExpression} b
  * @returns {ReactiveExpression}
  */
-import { randomFromArray } from "../../../../math/MathUtils.js";
 import DataType from "../../../../parser/simple/DataType.js";
 import { ReactiveAdd } from "../arithmetic/ReactiveAdd.js";
 import { ReactiveDivide } from "../arithmetic/ReactiveDivide.js";
@@ -20,6 +19,7 @@ import { ReactiveAnd } from "../logic/ReactiveAnd.js";
 import { ReactiveOr } from "../logic/ReactiveOr.js";
 import { ReactiveLiteralNumber } from "../terminal/ReactiveLiteralNumber.js";
 import { ReactiveLiteralString } from "../terminal/ReactiveLiteralString.js";
+import { randomFromArray } from "../../../../math/random/randomFromArray.js";
 
 /**
  *

package/core/model/stat/LinearModifier.js

@@ -1,5 +1,5 @@
 import { assert } from "../../assert.js";
-import { computeHashFloat } from "../../math/MathUtils.js";
+import { computeHashFloat } from "../../math/hash/computeHashFloat.js";
 
 
 /**

package/core/primitives/array/computeIntegerArrayHash.js

@@ -7,7 +7,7 @@
 export function computeIntegerArrayHash(data, offset, length) {
     const end = offset + length;
 
-    let hash = 0;
+    let hash = length;
 
     for (let i = offset; i < end; i++) {
         const singleValue = data[i];

package/{engine/graphics/render/forward_plus/materials → core/primitives/strings}/insert_after.js

@@ -3,6 +3,7 @@
  * @param {string} source
  * @param {string} term
  * @param {string} extra
+ * @returns {string}
  */
 export function insert_after(source, term, extra) {
     const i = source.indexOf(term);
@@ -16,3 +17,5 @@ export function insert_after(source, term, extra) {
 
     return source.slice(0, end) + extra + source.slice(end);
 }
+
+

package/core/primitives/strings/insert_after_or_replace.js

@@ -0,0 +1,27 @@
+/**
+ *
+ * @param {string} source
+ * @param {string} insert_term
+ * @param {string} replace_term
+ * @param {string} value
+ * @returns {string}
+ */
+export function insert_after_or_replace(source, insert_term, replace_term, value) {
+    const insert_term_index = source.indexOf(insert_term);
+
+    if (insert_term_index !== -1) {
+        const end = insert_term_index + insert_term.length;
+        return source.slice(0, end) + value + source.slice(end);
+    }
+
+    const replace_term_index = source.indexOf(replace_term);
+
+    if (replace_term_index === -1) {
+        // not found
+        console.warn(`Neither insert term '${insert_term}', nor replacement term '${replace_term}' were found in the source`, source, value);
+        return source;
+    }
+
+
+    return source.slice(0, replace_term_index) + value + source.slice(replace_term_index + replace_term.length);
+}

package/editor/process/symbolic/makeHelperBoxGeometry.js

@@ -0,0 +1,44 @@
+import { BufferAttribute, BufferGeometry, Float32BufferAttribute } from "three";
+
+export function makeHelperBoxGeometry(sx = 1, sy = 1, sz = 1) {
+
+    const geometry = new BufferGeometry();
+
+    const dx = sx / 2;
+    const dy = sy / 2;
+    const dz = sz / 2;
+
+    const vertices = new Float32Array([
+        -dx, -dy, -dz,
+        dx, -dy, -dz,
+        dx, dy, -dz,
+        -dx, dy, -dz,
+
+        -dx, dy, dz,
+        dx, dy, dz,
+        dx, -dy, dz,
+        -dx, -dy, dz
+    ]);
+
+    geometry.setAttribute("position", new Float32BufferAttribute(vertices, 3));
+
+    geometry.setIndex(new BufferAttribute(new Uint8Array([
+        0, 1,
+        1, 2,
+        2, 3,
+        3, 0,
+
+        4, 5,
+        5, 6,
+        6, 7,
+        7, 4,
+
+
+        0, 7,
+        1, 6,
+        2, 5,
+        3, 4
+    ]), 1, false));
+
+    return geometry;
+}

package/editor/view/ecs/EntityEditor.js

@@ -38,7 +38,7 @@ import { HeadsUpDisplayController } from "./components/HeadsUpDisplayController.
 import { BlackboardController } from "./components/BlackboardController.js";
 import { GridObstacleController } from "./components/GridObstacleController.js";
 import { AttachmentSocketsController } from "./components/sockets/AttachmentSocketsController.js";
-import { ParticleEmitterSystem2 } from "../../../engine/graphics/particles/ecs/ParticleEmitterSystem2.js";
+import { ParticleEmitterSystem } from "../../../engine/graphics/particles/ecs/ParticleEmitterSystem.js";
 
 /**
  *
@@ -82,7 +82,7 @@ function prepareComponentFactory(factory, editor) {
         .register('ParticleEmitter', () => {
             const em = editor.engine.entityManager;
 
-            const particleEmitterSystem = em.getSystem(ParticleEmitterSystem2);
+            const particleEmitterSystem = em.getSystem(ParticleEmitterSystem);
 
             return new ParticleEmitterController(particleEmitterSystem);
         })

package/editor/view/ecs/components/particles/ParticleEmitterController.js

@@ -24,7 +24,7 @@ export function enumNameByValue(value, enumerable) {
 /**
  *
  * @param {ParticleEmitter} emitter
- * @param {ParticleEmitterSystem2} system
+ * @param {ParticleEmitterSystem} system
  * @param {function} op
  * @param {*} [arg0]
  */
@@ -61,7 +61,7 @@ function applyEmitterChanges(emitter, system, op, arg0) {
 export class ParticleEmitterController extends EmptyView {
     /**
      *
-     * @param {ParticleEmitterSystem2} particleEmitterSystem
+     * @param {ParticleEmitterSystem} particleEmitterSystem
      * @constructor
      */
     constructor(particleEmitterSystem) {