@woosh/meep-engine 2.56.1 → 2.57.0

package/src/core/fsm/StateMachine.js

@@ -1,440 +0,0 @@
-/**
- * Created by Alex on 01/09/2014.
- */
-
-
-import { assert } from "../assert.js";
-import { dispatchViaProxy } from "../events/signal/Signal.js";
-import Graph from "../graph/Graph.js";
-import Future from "../process/Future.js";
-import Transition from "./Transition.js";
-
-/**
- *
- * @enum {number}
- */
-export const StateMachineEventType = {
-    StateEntered: 0,
-    StateExited: 1
-};
-
-/**
- * @template {T}
- * @constructor
- */
-function StateMachine() {
-    this.graph = new Graph();
-    this.state = null;
-    this.isLocked = false;
-
-    /**
-     *
-     * @type {Map<any, Array>}
-     */
-    this.stateProcessorMap = new Map();
-
-    this.stateEntryHandlers = new Map();
-    this.stateExitHandlers = new Map();
-
-    /**
-     * Used for debug mainly
-     * @type {Array<T>}
-     * @private
-     */
-    this.__history = [];
-}
-
-/**
- *
- * @param {T} source
- * @param {T} target
- * @param {Transition~action} action
- * @param {Transition~condition} [condition]
- * @returns {Transition}
- */
-StateMachine.prototype.createTransition = function (source, target, action, condition) {
-    const transition = new Transition(source, target, action, condition);
-    this.addTransition(transition);
-    return transition;
-};
-
-/**
- *
- * @param {T} state
- * @param {StateMachineEventType} type
- * @param {function} handler
- */
-StateMachine.prototype.addEventHandler = function (state, type, handler) {
-    let eventMap;
-
-    if (type === StateMachineEventType.StateEntered) {
-        eventMap = this.stateEntryHandlers;
-    } else if (type === StateMachineEventType.StateExited) {
-        eventMap = this.stateExitHandlers;
-    } else {
-        throw new Error(`Unknown event type '${type}'`);
-    }
-
-    const handlers = eventMap.get(state);
-    if (handlers === undefined) {
-        eventMap.set(state, [handler]);
-    } else {
-        handlers.push(handler);
-    }
-};
-
-/**
- *
- * @param {T} state
- * @param {StateMachineEventType} type
- * @param {function} handler
- */
-StateMachine.prototype.removeEventHandler = function (state, type, handler) {
-    let eventMap;
-
-    if (type === StateMachineEventType.StateEntered) {
-        eventMap = this.stateEntryHandlers;
-    } else if (type === StateMachineEventType.StateExited) {
-        eventMap = this.stateExitHandlers;
-    } else {
-        throw new Error(`Unknown event type '${type}'`);
-    }
-
-
-    const handlers = eventMap.get(state);
-    if (handlers === undefined) {
-        //no handlers, clearly handler was not registered
-        console.warn('No listeners registered');
-    } else {
-        const i = handlers.indexOf(handler);
-
-        if (i === -1) {
-            console.warn('Listener not found');
-            return;
-        }
-
-        handlers.splice(i, 1);
-    }
-};
-
-/**
- *
- * @param {Transition} t
- */
-StateMachine.prototype.addTransition = function (t) {
-    this.graph.addEdge(t);
-};
-
-/**
- *
- * @param {T} s
- */
-StateMachine.prototype.addState = function (s) {
-    this.graph.addNode(s);
-};
-
-/**
- *
- * @param {T} state
- * @param {function():Promise<T>} processor
- */
-StateMachine.prototype.addStateProcessor = function (state, processor) {
-    assert.notEqual(state, undefined, 'state was undefined');
-    assert.equal(typeof processor, 'function', `processor must be a function, instead was '${typeof processor}'`)
-
-    if (!this.graph.containsNode(state)) {
-        throw new Error(`State ${state} is not found in the graph`);
-    }
-
-    const processors = this.stateProcessorMap.get(state);
-
-    if (processors === undefined) {
-        this.stateProcessorMap.set(state, [processor]);
-    } else {
-        processors.push(state);
-    }
-};
-
-/**
- *
- * @param {Array.<*>} states
- */
-StateMachine.prototype.addAllStates = function (states) {
-    let i = 0;
-    const l = states.length;
-    for (; i < l; i++) {
-        this.addState(states[i]);
-    }
-};
-
-
-/**
- *
- * @param {T} s
- */
-StateMachine.prototype.setState = function (s) {
-    // console.warn('setState', s);
-
-    const oldState = this.state;
-
-    this.state = s;
-
-    const exitHandlers = this.stateExitHandlers.get(oldState);
-
-    if (exitHandlers !== undefined) {
-        dispatchViaProxy(exitHandlers, [oldState, s]);
-    }
-
-    const entryHandlers = this.stateEntryHandlers.get(s);
-
-    if (entryHandlers !== undefined) {
-        dispatchViaProxy(entryHandlers, [s, oldState]);
-    }
-
-    this.__history.push(s);
-};
-
-/**
- *
- * @returns {T}
- */
-StateMachine.prototype.getState = function () {
-    return this.state;
-};
-
-/**
- * Causes the state machine to enter a given state
- * @param {T} s
- */
-StateMachine.prototype.enterState = function (s) {
-    if (this.isLocked) {
-        throw new Error(`State Machine is locked, unable to set state from '${this.state}' to '${s}'`);
-    }
-
-    this.setState(s);
-
-    //try all state processors in turn until all have been tried and failed or one has succeeded
-    const processors = this.stateProcessorMap.get(s);
-
-    const self = this;
-
-
-    function executeStateProcessors(sm, processors) {
-
-        let i = 0;
-        const numProcessors = processors.length;
-
-        function lockSM() {
-            sm.isLocked = true;
-        }
-
-        function unlockSM() {
-            sm.isLocked = false;
-        }
-
-        function executeNext() {
-
-            const processor = processors[i];
-
-            i++;
-
-            let pendingProcess;
-
-            try {
-                pendingProcess = processor();
-            } catch (e) {
-                console.warn('Exception in state processor function, treating as failure and continuing.', e);
-                handleTaskFailure();
-                return;
-            }
-
-            assert.ok((pendingProcess instanceof Promise || pendingProcess instanceof Future), `processor must return a promise or a future, instead returned something else (${pendingProcess})`);
-
-            self.__pendingProcess = pendingProcess;
-
-            pendingProcess.then(handleTaskCompletion, handleTaskFailure);
-        }
-
-        function handleTaskCompletion(newState) {
-            if (!self.graph.containsNode(newState)) {
-                //produced state is not contained in the graph, treat as failure
-                console.error(`Processor produced state that is not present in the graph, treating as failure.`);
-
-                handleTaskFailure();
-            } else {
-                let foundTraversableEdge = false;
-
-                self.graph.findTraversableEdges(s, newState, function (edge) {
-                    foundTraversableEdge = true;
-                });
-
-                if (!foundTraversableEdge) {
-                    console.error(`Processor requests an illegal move from state '${s}' to '${newState}', no valid transition exists. Treating as failure`);
-                    handleTaskFailure();
-                } else {
-                    //unlock
-                    unlockSM();
-                    //transition
-                    self.enterState(newState);
-                }
-            }
-        }
-
-        function handleTaskFailure() {
-            if (i === numProcessors) {
-                //we're done
-                unlockSM();
-            } else {
-                executeNext();
-            }
-        }
-
-        lockSM();
-
-        executeNext();
-    }
-
-    if (processors === undefined || processors.length === 0) {
-        //no state processors
-    } else {
-        executeStateProcessors(this, processors);
-    }
-};
-
-StateMachine.prototype.canTransitionTo = function (nextState) {
-    const source = this.state;
-    let result = false;
-    this.traverseValidTransitions(function (node, edge) {
-        if (node === nextState && edge.condition(source, node)) {
-            result = true;
-            //stop traversal
-            return false;
-        }
-    });
-    return result;
-};
-
-/**
- *
- * @param {Graph~visitor} visitor
- */
-StateMachine.prototype.traverseValidTransitions = function (visitor) {
-    const source = this.state;
-    this.graph.traverseSuccessors(source, function (node, edge) {
-        if (edge.condition(source, node)) {
-            return visitor(node, edge);
-        }
-    });
-};
-
-
-/**
- *
- * @param {Transition} transition
- * @param {T} targetState
- * @returns {Promise}
- */
-StateMachine.prototype.transitionOn = function (transition, targetState) {
-    assert.equal(transition.second, targetState, `transition destination is not equal to targetState`);
-
-    const sm = this;
-    return new Promise(function (resolve, reject) {
-        if (transition === null) {
-            //no transition was found
-            reject("no transition found");
-        }
-        //check lock on state machine
-        if (sm.isLocked) {
-            reject("state machine is locked, can not execute transition");
-        }
-
-        const stateFrom = sm.state;
-
-        //lock state machine
-        sm.isLocked = true;
-
-        let promise;
-
-        try {
-            promise = transition.action(stateFrom, targetState);
-        } catch (e) {
-            //failed to perform transition
-            promise = Promise.reject(e);
-        }
-
-        function handleTransitionSuccess() {
-            sm.isLocked = false;
-            sm.enterState(targetState);
-            resolve();
-        }
-
-        function handleTransitionFailed(e) {
-            sm.isLocked = false;
-            reject(e);
-        }
-
-        promise.then(handleTransitionSuccess, handleTransitionFailed);
-    });
-};
-
-/**
- *
- * @param {T} nextState Adjacent state
- * @returns {Promise}
- */
-StateMachine.prototype.transitionTo = function (nextState) {
-    const sm = this;
-    const state = sm.state;
-
-    return new Promise(function (resolve, reject) {
-        if (state === nextState) {
-            //already there
-            resolve();
-        }
-        let transition = null;
-
-        sm.traverseValidTransitions(function (target, t) {
-            if (t.second !== nextState) {
-                //wrong target
-                return;
-            }
-
-            transition = t;
-            //stop traversal
-            return false;
-        });
-
-        sm.transitionOn(transition, nextState).then(resolve, reject);
-    });
-};
-
-/**
- *
- * @param {*} targetState
- * @returns {Promise}
- */
-StateMachine.prototype.navigateTo = function (targetState) {
-    //find path
-    const graph = this.graph;
-
-    const start = this.state;
-
-    const path = graph.findPath(start, targetState);
-
-    if (path === null) {
-        return Promise.reject(`no path found from ${start} to '${targetState}'`);
-    }
-
-    let result = Promise.resolve();
-
-    let i = 1;
-    const l = path.length;
-    for (; i < l; i++) {
-        const next = path[i];
-        result = result.then(this.transitionTo(next));
-    }
-
-    return result;
-};
-
-export { StateMachine };

package/src/core/fsm/Transition.js

@@ -1,65 +0,0 @@
-/**
- * Created by Alex on 24/03/2016.
- */
-
-
-import { Edge, EdgeDirectionType } from "../graph/Edge.js";
-
-const TransitionExecutionMode = {
-    Synchronous: 0,
-    Asynchronous: 1
-};
-
-/**
- * @callback Transition~action
- * @param {*} source Node of transition origin
- * @param {*} target Node of destination
- * @returns {Promise} Promise is evaluated to perform transition, and transition is not finished until promise is resolved
- */
-
-/**
- * @callback Transition~condition
- * @param {*} source
- * @param {*} target
- * @returns {boolean} judgement on validity of transition from source to target
- */
-
-/**
- *
- * @param {*} source
- * @param {*} target
- * @returns {boolean}
- */
-function fTrue(source, target) {
-    return true;
-}
-
-class Transition extends Edge {
-    /**
-     *
-     * @param {*} source
-     * @param {*} target
-     * @param {Transition~action} action
-     * @param {Transition~condition} condition
-     * @constructor
-     * @extends Edge
-     */
-    constructor(source, target, action, condition) {
-        super(source, target);
-        //make it a directed edge
-        this.direction = EdgeDirectionType.Forward;
-
-        this.action = action;
-        this.condition = (typeof condition === "function") ? condition : fTrue;
-    }
-
-    /**
-     * @inheritDoc Transition~action
-     */
-    static EmptyAction(source, target) {
-        return Promise.resolve();
-    }
-}
-
-
-export default Transition;

package/src/core/geom/Bezier.js

@@ -1,24 +0,0 @@
-/**
- *
- * @param {Vector2} result
- * @param {number} p0x
- * @param {number} p0y
- * @param {number} p1x
- * @param {number} p1y
- * @param {number} p2x
- * @param {number} p2y
- * @param {number} t
- */
-export function computeQuadraticBezier2D(result, p0x, p0y, p1x, p1y, p2x, p2y, t) {
-    const minus = 1 - t;
-    const minus2 = minus * minus;
-
-    const f = minus * 2 * t;
-    const t2 = t * t;
-
-
-    const x0 = p0x * minus2 + p1x * f + p2x * t2;
-    const y0 = p0y * minus2 + p1y * f + p2y * t2;
-
-    result.set(x0, y0);
-}

package/src/core/geom/Bezier.spec.js

@@ -1,16 +0,0 @@
-import { computeQuadraticBezier2D } from "./Bezier.js";
-import Vector2 from "./Vector2.js";
-
-test("computeQuadraticBezier2D hits knots",()=>{
-    const v2 = new Vector2();
-
-    computeQuadraticBezier2D(v2,1,3,5,7,11,13,0);
-
-    expect(v2.x).toBeCloseTo(1);
-    expect(v2.y).toBeCloseTo(3);
-
-    computeQuadraticBezier2D(v2,1,3,5,7,11,13,1);
-
-    expect(v2.x).toBeCloseTo(11);
-    expect(v2.y).toBeCloseTo(13);
-});

package/src/core/math/spline/quadraticCurve.js

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

package/src/core/math/spline/quadraticCurve.spec.js

@@ -1,13 +0,0 @@
-import { quadraticCurve } from "./quadraticCurve.js";
-
-test("quadraticCurve", () => {
-    expect(quadraticCurve(2, 0.1, 0.2, 3)).toBe(11.3);
-
-    expect(quadraticCurve(1, -1, -2, -3)).toBe(-3);
-
-    expect(quadraticCurve(-1, -1, 0, 0)).toBe(-4);
-
-    expect(quadraticCurve(-1, -1, 1, 0)).toBe(-8);
-
-    expect(quadraticCurve(-1, 0, 0, 0)).toBe(0);
-});

package/src/core/primitives/numbers/compareNumbers.js

@@ -1,9 +0,0 @@
-import { number_compare_ascending } from "./number_compare_ascending.js";
-
-/**
- * @deprecated use {@link number_compare_ascending} directly
- * @param {number} a
- * @param {number} b
- * @returns {number}
- */
-export const compareNumbers = number_compare_ascending;

package/src/engine/graphics/ecs/decal/Decal.js

@@ -1,10 +0,0 @@
-/**
- * Created by Alex on 16/09/2015.
- */
-const Decal = function (options) {
-    this.target = options.target;
-    this.size = options.size;
-    this.material = options.material;
-};
-
-export default Decal;

package/src/engine/graphics/ecs/decal/DecalSystem.js

@@ -1,99 +0,0 @@
-/**
- * Created by Alex on 16/09/2015.
- */
-import { System } from '../../../ecs/System.js';
-import { Euler as ThreeEuler, MaterialLoader, Mesh as ThreeMesh, Vector3 as ThreeVector3 } from 'three';
-import { Transform } from '../../../ecs/transform/Transform.js';
-import Mesh from '../mesh/Mesh.js';
-import Renderable from '../../../ecs/renderable/Renderable.js';
-import LoadMaterial from "../../material/LoadMaterial.js";
-
-import Decal from "./Decal.js";
-import DecalGeometry from "./threejs/DecalGeometry.js";
-import { computeStringHash } from "../../../../core/primitives/strings/computeStringHash.js";
-
-const MaterialCache = function () {
-    this.materialLoader = new MaterialLoader();
-    this.table = {};
-};
-
-MaterialCache.prototype.get = function (json) {
-    const str = JSON.stringify(json);
-    const hash = computeStringHash(str);
-    if (this.table.hasOwnProperty(hash)) {
-        return this.table[hash];
-    } else {
-        const options = Object.assign({ assetManager }, json);
-
-        const material = LoadMaterial(options);
-        material.depthTest = true;
-        material.depthWrite = false;
-        material.polygonOffset = true;
-        material.polygonOffsetFactor = -4;
-        this.table[hash] = material;
-        return material;
-    }
-};
-
-class DecalSystem extends System {
-    /**
-     *
-     * @param scene
-     * @param {AssetManager} assetManager
-     */
-    constructor(scene, assetManager) {
-        super();
-        this.scene = scene;
-        this.assetManager = assetManager;
-
-        this.dependencies = [Decal];
-
-        this.materialCache = new MaterialCache();
-    }
-
-    remove(component, entity) {
-        this.scene.remove(component.mesh);
-    }
-
-    add(component, entity) {
-        const meshes = [];
-
-        const targetModel = this.entityManager.getComponent(component.target, Mesh);
-        const targetRenderable = this.entityManager.getComponent(component.target, Renderable);
-
-        if (targetModel !== null) {
-            //TODO implement
-        }
-
-        if (targetRenderable !== null) {
-            processObjectTHREE(targetRenderable.mesh, meshes);
-        }
-
-        const transform = this.entityManager.getComponent(entity, Transform);
-
-        const material = this.materialCache.get(component.material);
-
-        const r = new ThreeEuler();
-        r.setFromQuaternion(transform.rotation);
-        const size = new ThreeVector3(component.size, component.size, component.size);
-        const check = new ThreeVector3(1, 1, 1);
-        const geometry = new DecalGeometry(meshes, transform.position, r, size, check);
-        const mesh = component.mesh = new ThreeMesh(geometry, material);
-        this.scene.add(mesh);
-    }
-}
-
-
-function processObjectTHREE(object, meshes) {
-    if (object.hasOwnProperty("geometry")) {
-        meshes.push(object);
-    }
-    let i = 0;
-    const l = object.children.length;
-    for (; i < l; i++) {
-        const c = object.children[i];
-        processObjectTHREE(c, meshes);
-    }
-}
-
-export default DecalSystem;