@woosh/meep-engine 2.78.1 → 2.80.0

package/src/engine/simulation/Ticker.js

@@ -1,27 +1,42 @@
 /**
  * Created by Alex on 06/05/2015.
  */
-import Clock from '../Clock.js';
-import { SignalHandler } from "../../core/events/signal/SignalHandler.js";
 import { assert } from "../../core/assert.js";
+import Signal from "../../core/events/signal/Signal.js";
+import Clock from '../Clock.js';
 
+/**
+ * Simulation tick generator
+ * Dispatches "tick" every animation frame or "maxDelay" time, whichever happens to be soonest
+ * This is essentially the timing bus that all the simulation systems subscribe to for their step advancement
+ */
 class Ticker {
     /**
      * @readonly
      * @type {Clock}
      */
     clock = new Clock();
+
     /**
      * @private
      * @type {boolean}
      */
-    isRunning = false;
+    #isRunning = false;
+
 
     /**
-     *
-     * @type {SignalHandler[]}
+     * Dispatches time delta in seconds since last tick
+     * @readonly
+     * @type {Signal<number>}
      */
-    callbacks = [];
+    onTick = new Signal();
+
+    /**
+     * @deprecated
+     */
+    get callbacks() {
+        throw new Error('deprecated, use onTick signal instead');
+    }
 
     /**
      *
@@ -32,80 +47,44 @@ class Ticker {
     }
 
     /**
-     *
+     * @deprecated use onTick signal directly instead
      * @param {function} callback
      * @param {*} [thisArg]
      */
     subscribe(callback, thisArg) {
-        const handler = new SignalHandler(callback, thisArg);
-
-        this.callbacks.push(handler);
+        this.onTick.add(callback, thisArg);
     }
 
     /**
-     *
+     * @deprecated use onTick signal directly instead
      * @param {function} callback
      * @param {*} [thisArg]
      */
     unsubscribe(callback, thisArg) {
-        assert.isFunction(callback, 'callback');
-
-        const callbacks = this.callbacks;
-        const n = callbacks.length;
-        for (let i = 0; i < n; i++) {
-            const cb = callbacks[i];
-
-            if (cb.handle === callback) {
-                if (thisArg !== undefined) {
-                    if (thisArg === cb.context) {
-                        callbacks.splice(i, 1);
-                        return;
-                    }
-                } else {
-                    callbacks.splice(i, 1);
-                    return;
-                }
-            }
-        }
-
+        this.onTick.remove(callback, thisArg);
     }
 
     /**
      *
-     * @param {number} maxTimeout
+     * @param {number} [maxTimeout]
      */
     start({ maxTimeout = 100 } = {}) {
-        assert.typeOf(maxTimeout, 'number', 'maxTimeout');
+        assert.isNumber(maxTimeout, 'maxTimeout');
+        assert.greaterThan(maxTimeout, 0);
 
-
-        const self = this;
         let timeout = null;
         let animationFrame = null;
 
-        this.isRunning = true;
-
-        function update() {
-            if (self.isRunning) {
-
-                const delta = self.clock.getDelta();
+        this.#isRunning = true;
 
-                const callbacks = self.callbacks;
-
-                for (let i = 0; i < callbacks.length; i++) {
-                    const callback = callbacks[i];
-
-                    try {
-                        callback.handle.call(callback.context, delta);
-                    } catch (e) {
-                        console.error('Error in ticker subscription:', e);
-                    }
-
-                }
+        const update = () => {
+            if (!this.#isRunning) {
+                return;
             }
-        }
 
-        function cycle() {
-            update();
+            const delta = this.clock.getDelta();
+
+            this.onTick.send1(delta);
         }
 
         function timeoutCallback() {
@@ -122,22 +101,22 @@ class Ticker {
 
         function animate() {
             animationFrame = requestAnimationFrame(animationFrameCallback);
-            cycle();
+            update();
             timeout = setTimeout(timeoutCallback, maxTimeout);
         }
 
-        self.clock.getDelta(); //purge delta
-        self.clock.start();
+        this.clock.getDelta(); //purge delta
+        this.clock.start();
 
         requestAnimationFrame(animationFrameCallback);
     }
 
     pause() {
-        this.isRunning = false;
+        this.#isRunning = false;
     }
 
     resume() {
-        this.isRunning = true;
+        this.#isRunning = true;
     }
 }
 

package/src/core/geom/LineSegment.js

@@ -1,207 +0,0 @@
-/**
- * Created by Alex on 18/03/14.
- */
-import Vector3 from "./Vector3.js";
-import { clamp01 } from "../math/clamp01.js";
-
-
-const SMALL_NUM = 1e-9;
-/**
- * @param {Vector3} first
- * @param {Vector3} second
- * @constructor
- */
-const LineSegment = function (first, second) {
-    this.p0 = first || null;
-    this.p1 = second || null;
-
-};
-
-LineSegment.prototype.closestPointToPointParameter = function (point, clampToLine) {
-
-
-    const startP = point.clone().sub(this.p0);
-    const startEnd = this.p1.clone().sub(this.p0);
-
-    const startEnd2 = startEnd.dot(startEnd);
-    const startEnd_startP = startEnd.dot(startP);
-
-    let t = startEnd_startP / startEnd2;
-
-    if (clampToLine) {
-
-        t = clamp01(t);
-
-    }
-
-    return t;
-
-};
-
-LineSegment.prototype.closestPointToPoint = function (point) {
-
-    const t = this.closestPointToPointParameter(point, true);
-
-    const result = this.p1.clone().sub(this.p0);
-    return result.scale(t).add(this.p0);
-
-};
-/**
- * @param {Vector3} p
- * @returns {number}
- */
-LineSegment.prototype.distanceToPoint = function (p) {
-    const closestPointToPoint = this.closestPointToPoint(p);
-    return closestPointToPoint.sub(p).length();
-};
-/**
- * @param {LineSegment} other
- * @returns {number}
- */
-LineSegment.prototype.distanceToSegment = function (other) {
-    const u = this.p1.clone().sub(this.p0);
-    const v = other.p1.clone().sub(other.p0);
-    const w = this.p0.clone().sub(other.p0);
-    const a = u.dot(u);         // always >= 0
-    const b = u.dot(v);
-    const c = v.dot(v);         // always >= 0
-    let d = u.dot(w);
-    const e = v.dot(w);
-    const D = a * c - b * b;        // always >= 0
-    let sc, sN, sD = D;       // sc = sN / sD, default sD = D >= 0
-    let tc, tN, tD = D;       // tc = tN / tD, default tD = D >= 0
-
-    // compute the line parameters of the two closest points
-    if (D < SMALL_NUM) { // the lines are almost parallel
-        sN = 0.0;         // force using point P0 on segment S1
-        sD = 1.0;         // to prevent possible division by 0.0 later
-        tN = e;
-        tD = c;
-    } else {                 // get the closest points on the infinite lines
-        sN = (b * e - c * d);
-        tN = (a * e - b * d);
-        if (sN < 0.0) {        // sc < 0 => the s=0 edge is visible
-            sN = 0.0;
-            tN = e;
-            tD = c;
-        } else if (sN > sD) {  // sc > 1  => the s=1 edge is visible
-            sN = sD;
-            tN = e + b;
-            tD = c;
-        }
-    }
-
-    if (tN < 0.0) {            // tc < 0 => the t=0 edge is visible
-        tN = 0.0;
-        // recompute sc for this edge
-        if (-d < 0.0)
-            sN = 0.0;
-        else if (-d > a)
-            sN = sD;
-        else {
-            sN = -d;
-            sD = a;
-        }
-    } else if (tN > tD) {      // tc > 1  => the t=1 edge is visible
-        tN = tD;
-        // recompute sc for this edge
-        if ((-d + b) < 0.0)
-            sN = 0;
-        else if ((-d + b) > a)
-            sN = sD;
-        else {
-            sN = (-d + b);
-            sD = a;
-        }
-    }
-    // finally do the division to get sc and tc
-    sc = (Math.abs(sN) < SMALL_NUM ? 0.0 : sN / sD);
-    tc = (Math.abs(tN) < SMALL_NUM ? 0.0 : tN / tD);
-
-    // get the difference of the two closest points
-    const dP = w.clone().add(
-        u.clone().scale(sc).sub(
-            v.clone().scale(tc)
-        )
-    );  // =  S1(sc) - S2(tc)
-
-    return dP.length();   // return the closest distance
-};
-LineSegment.prototype.clone = function () {
-    return new LineSegment(this.p0, this.p1);
-};
-LineSegment.prototype.midPoint = function () {
-    return this.p1.lerp(this.p0, 0.5);
-};
-LineSegment.prototype.shrinkByScalar = function (scalar) {
-    const length = this.length();
-    const newScale = (length - scalar) / length;
-    const halfScaleDelta = (1 - newScale) / 2;
-    //find mid point
-    let midPoint = this.midPoint();
-    //pull edges towards the midpoint
-    const newP0 = this.p0.clone().lerp(this.p1, halfScaleDelta);
-    const newP1 = this.p1.clone().lerp(this.p0, halfScaleDelta);
-    this.p0 = newP0;
-    this.p1 = newP1;
-    //new length should now be equal to oldLength - scalar;
-    return this;
-};
-LineSegment.prototype.length = function () {
-    return this.p0.distanceTo(this.p1);
-};
-LineSegment.prototype.translate = function (vector) {
-    this.p0.add(vector);
-    this.p1.add(vector);
-};
-
-
-/**
- *
- * @param {Vector3} a0
- * @param {Vector3} a1
- * @param {Vector3} b0
- * @param {Vector3} b1
- * @param {Vector3} result
- * @returns {boolean}
- */
-LineSegment.intersectionPoint = (function () {
-    const cross_da_db = new Vector3();
-    const cross_dc_db = new Vector3();
-    const dc = new Vector3();
-    const da = new Vector3();
-    const db = new Vector3();
-
-    /**
-     *
-     * @param {Vector3} a0
-     * @param {Vector3} a1
-     * @param {Vector3} b0
-     * @param {Vector3} b1
-     * @param {Vector3} result
-     * @returns {boolean}
-     */
-    function intersectionPoint(a0, a1, b0, b1, result) {
-        da.copy(a1).sub(a0);
-        db.copy(b1).sub(b0);
-        dc.copy(b0).sub(a0);
-
-        cross_da_db.copy(da).cross(db);
-        if (dc.dot(cross_da_db) !== 0.0) {
-            // lines are not coplanar
-            return false;
-        }
-
-        cross_dc_db.copy(dc).cross(db);
-        const s = cross_dc_db.dot(cross_da_db) / cross_da_db.lengthSqr();
-        result.copy(da).multiplyScalar(s).add(a0);
-        if (s >= 0.0 && s <= 1.0) {
-            return true;
-        }
-
-        return false;
-    }
-
-    return intersectionPoint;
-})();
-export default LineSegment;

package/src/core/primitives/strings/prefixTree/PrefixTree.js

@@ -1,225 +0,0 @@
-import { PrefixTreeLeaf } from "./PrefixTreeLeaf.js";
-import { PrefixTreeNode } from "./PrefixTreeNode.js";
-
-export class PrefixTree extends PrefixTreeNode {
-    constructor() {
-        super();
-
-        /**
-         *
-         * @type {string}
-         */
-        this.character = "";
-
-        /**
-         *
-         * @type {PrefixTreeNode[]}
-         */
-        this.children = [];
-    }
-
-    /**
-     *
-     * @param {PrefixTreeNode} node
-     */
-    addChild(node) {
-        node.depth = this.depth + 1;
-        node.parent = this;
-
-        this.children.push(node);
-    }
-
-    /**
-     *
-     * @param {string} character
-     * @return {PrefixTree|undefined}
-     */
-    findChildByCharacter(character) {
-        const n = this.children.length;
-
-        for (let i = 0; i < n; i++) {
-            const child = this.children[i];
-
-            if (!child.isPrefixTree) {
-                continue;
-            }
-
-            if (child.character === character) {
-                return child;
-            }
-        }
-    }
-
-    /**
-     *
-     * @param {string} word
-     * @returns {PrefixTreeLeaf|undefined}
-     */
-    findLeafByWord(word) {
-
-        const n = this.children.length;
-
-        for (let i = 0; i < n; i++) {
-            const child = this.children[i];
-
-            if (!child.isPrefixTreeLeaf) {
-                continue;
-            }
-
-            if (child.word === word) {
-                return child;
-            }
-        }
-    }
-
-    /**
-     *
-     * @param {string[]} result
-     */
-    collectValues(result) {
-        const children = this.children;
-        const n = children.length;
-
-        for (let i = 0; i < n; i++) {
-            const node = children[i];
-
-            if (node.isPrefixTree) {
-                node.collectValue(result);
-            } else {
-                const values = node.values;
-                const valueCount = values.length;
-
-                for (let j = 0; j < valueCount; j++) {
-                    const value = values[j];
-
-                    result.push(value);
-                }
-            }
-        }
-    }
-
-    /**
-     *
-     * @param {string[]} result
-     * @param {string} prefix
-     */
-    findValuesByPrefix(result, prefix) {
-        const l = prefix.length;
-
-        let n = this;
-
-        for (let i = 0; i < l; i++) {
-
-            const character = prefix.charAt(i);
-            n = n.findChildByCharacter(character)
-
-            if (n === undefined) {
-                return;
-            }
-        }
-
-
-    }
-
-    /**
-     *
-     * @param {string} text
-     * @param {RegExp} splitExpression
-     * @param {boolean} stripSpecial
-     * @param {boolean} stripPunctuation
-     * @param {boolean} forceLowerCase
-     * @param {*} value
-     */
-    insertText({ text, splitExpression = /\s/, stripSpecial = true, stripPunctuation = true, forceLowerCase = true, value }) {
-        const strings = text.split(splitExpression);
-
-        const words = [];
-
-        const n = strings.length;
-
-        let i;
-
-        for (i = 0; i < n; i++) {
-            const input = strings[i];
-
-            let output = input;
-
-            if (stripSpecial) {
-                output = output.replace(/[\n\t\r]/g, '');
-            }
-
-            if (stripPunctuation) {
-                output = output.replace(/[\,\.\!\?\-\+\[\]\(\)\=\"\']/g, '');
-            }
-
-            if (forceLowerCase) {
-                output = output.toLocaleLowerCase();
-            }
-
-            if (output.length === 0) {
-                continue;
-            }
-
-            if (words.indexOf(output) !== -1) {
-                //skip, already recorded
-                continue;
-            }
-
-            words.push(output);
-        }
-
-        const wordCount = words.length;
-
-        for (i = 0; i < wordCount; i++) {
-
-            const word = words[i];
-
-            this.insertWord(word, value);
-        }
-    }
-
-    /**
-     *
-     * @param {string} word
-     * @param {*} value
-     */
-    insertWord(word, value) {
-        const n = word.length;
-
-        if (n <= this.depth) {
-            //last letter
-            let leaf = this.findLeafByWord(word);
-
-            if (leaf === undefined) {
-                leaf = new PrefixTreeLeaf();
-
-                leaf.word = word;
-
-                this.addChild(leaf);
-            }
-
-            leaf.values.push(value);
-
-        } else {
-
-            const char = word.charAt(this.depth);
-
-            let child = this.findChildByCharacter(char);
-
-            if (child === undefined) {
-                child = new PrefixTree();
-                child.character = char;
-
-                this.addChild(child);
-            }
-
-            child.insertWord(word, value);
-        }
-    }
-}
-
-/**
- * @readonly
- * @type {boolean}
- */
-PrefixTree.prototype.isPrefixTree = true;

package/src/core/primitives/strings/prefixTree/PrefixTree.spec.js

@@ -1,39 +0,0 @@
-import { PrefixTree } from "./PrefixTree.js";
-
-test('inset one letter', () => {
-    const t = new PrefixTree();
-
-    t.insertWord('a');
-
-    const child = t.findChildByCharacter('a');
-
-    expect(child.character).toBe('a');
-    expect(child.children[0].word).toBe('a');
-    expect(child.children[0].values.length).toBe(1);
-});
-
-test('insert one letter twice', () => {
-
-    const t = new PrefixTree();
-
-    t.insertWord('a');
-    t.insertWord('a');
-
-    const child = t.findChildByCharacter('a');
-
-    expect(child.character).toBe('a');
-    expect(child.children[0].word).toBe('a');
-    expect(child.children[0].values.length).toBe(2);
-});
-
-
-test('complex', () => {
-
-    const t = new PrefixTree();
-
-    "cat sat on a mat. Horse smoked a camel. Bear snored, slithered and slobbered".split(/\s/).forEach(word => {
-        t.insertWord(word);
-    });
-
-    console.log("");
-});

package/src/core/primitives/strings/prefixTree/PrefixTreeLeaf.js

@@ -1,25 +0,0 @@
-import { PrefixTreeNode } from "./PrefixTreeNode.js";
-
-export class PrefixTreeLeaf extends PrefixTreeNode {
-    constructor() {
-        super();
-
-        /**
-         * Values associated with the word
-         * @type {Array}
-         */
-        this.values = [];
-
-        /**
-         * Actual word
-         * @type {string}
-         */
-        this.word = "";
-    }
-}
-
-/**
- * @readonly
- * @type {boolean}
- */
-PrefixTreeLeaf.prototype.isPrefixTreeLeaf = true;

package/src/core/primitives/strings/prefixTree/PrefixTreeNode.js

@@ -1,16 +0,0 @@
-export class PrefixTreeNode {
-    constructor() {
-
-        /**
-         *
-         * @type {number}
-         */
-        this.depth = 0;
-
-        /**
-         *
-         * @type {PrefixTree|null}
-         */
-        this.parent = null;
-    }
-}