@vived/app 2.6.1 → 2.7.0

package/lib/Entities/OrbitCamera.d.ts

@@ -0,0 +1,17 @@
+import { Vector3 } from ".";
+export declare type OnOrbitCameraChange = () => void;
+export interface CameraLerper {
+    cancelLerp: () => void;
+}
+export interface OrbitCamera {
+    alpha: number;
+    beta: number;
+    radius: number;
+    target: Vector3;
+    registerLerp: (lerper: CameraLerper) => void;
+    lerpCompleted: () => void;
+    cancelLerp: () => void;
+    addObserver: (observer: OnOrbitCameraChange) => void;
+    removeObserver: (observer: OnOrbitCameraChange) => void;
+}
+export declare function makeOrbitCamera(): OrbitCamera;

package/lib/Entities/OrbitCamera.js

@@ -0,0 +1,74 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.makeOrbitCamera = void 0;
+const _1 = require(".");
+function makeOrbitCamera() {
+    return new OrbitCameraImp();
+}
+exports.makeOrbitCamera = makeOrbitCamera;
+class OrbitCameraImp {
+    constructor() {
+        this.observers = new _1.ObserverList();
+        this.memoizedAlpha = new _1.MemoizedNumber(0, this.observers.notify);
+        this.memoizedBeta = new _1.MemoizedNumber(0, this.observers.notify);
+        this.memoizedRadius = new _1.MemoizedNumber(1, this.observers.notify);
+        this.memoizedTarget = new _1.MemoizedVector3(_1.Vector3.Zero(), this.observers.notify);
+        this.registerLerp = (lerper) => {
+            if (this.currentLerp) {
+                this.currentLerp.cancelLerp();
+            }
+            this.currentLerp = lerper;
+        };
+        this.lerpCompleted = () => {
+            this.currentLerp = undefined;
+        };
+        this.cancelLerp = () => {
+            var _a;
+            (_a = this.currentLerp) === null || _a === void 0 ? void 0 : _a.cancelLerp();
+            this.currentLerp = undefined;
+        };
+        this.addObserver = (observer) => {
+            this.observers.add(observer);
+        };
+        this.removeObserver = (observer) => {
+            this.observers.remove(observer);
+        };
+    }
+    get alpha() {
+        return this.memoizedAlpha.val;
+    }
+    set alpha(val) {
+        this.memoizedAlpha.val = this.clampAngle(val);
+    }
+    get beta() {
+        return this.memoizedBeta.val;
+    }
+    set beta(val) {
+        this.memoizedBeta.val = this.clampAngle(val);
+    }
+    get radius() {
+        return this.memoizedRadius.val;
+    }
+    set radius(val) {
+        this.memoizedRadius.val = val < 0 ? 0 : val;
+    }
+    get target() {
+        return this.memoizedTarget.getVector();
+    }
+    set target(val) {
+        this.memoizedTarget.setVector(val);
+    }
+    clampAngle(angle) {
+        const isNegative = angle < 0 ? true : false;
+        const absAngle = Math.abs(angle);
+        const revolutions = Math.floor(absAngle / 360);
+        let angleWithoutRevolutions = absAngle - revolutions * 360;
+        if (angleWithoutRevolutions > 180) {
+            angleWithoutRevolutions = angleWithoutRevolutions - 360;
+        }
+        if (isNegative) {
+            angleWithoutRevolutions *= -1;
+        }
+        return angleWithoutRevolutions;
+    }
+}

package/lib/Entities/ParametricLine.d.ts

@@ -0,0 +1,29 @@
+import { Vector3 } from "./Vector3";
+export interface LineParameters {
+    x0: number;
+    y0: number;
+    z0: number;
+    a: number;
+    b: number;
+    c: number;
+}
+export declare class ParametricLine {
+    private x0;
+    private y0;
+    private z0;
+    private a;
+    private b;
+    private c;
+    static FromTwoPoint(p1: Vector3, p2: Vector3): ParametricLine;
+    static FromPointDirection(point: Vector3, direction: Vector3): ParametricLine;
+    static Forward(): ParametricLine;
+    static Backward(): ParametricLine;
+    static Up(): ParametricLine;
+    static Down(): ParametricLine;
+    static Left(): ParametricLine;
+    static Right(): ParametricLine;
+    getPointAtDistance(distance: number): Vector3;
+    getParameters(): LineParameters;
+    copy(): ParametricLine;
+    constructor(parameters: LineParameters);
+}

package/lib/Entities/ParametricLine.js

@@ -0,0 +1,79 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ParametricLine = void 0;
+const Vector3_1 = require("./Vector3");
+class ParametricLine {
+    constructor(parameters) {
+        this.x0 = parameters.x0;
+        this.y0 = parameters.y0;
+        this.z0 = parameters.z0;
+        this.a = parameters.a;
+        this.b = parameters.b;
+        this.c = parameters.c;
+    }
+    static FromTwoPoint(p1, p2) {
+        const dir = p2.subtract(p1).unit;
+        return this.FromPointDirection(p1, dir);
+    }
+    static FromPointDirection(point, direction) {
+        return new ParametricLine({
+            x0: point.x,
+            y0: point.y,
+            z0: point.z,
+            a: direction.x,
+            b: direction.y,
+            c: direction.z,
+        });
+    }
+    static Forward() {
+        const p = Vector3_1.Vector3.Zero();
+        const d = new Vector3_1.Vector3(0, 0, 1);
+        return this.FromPointDirection(p, d);
+    }
+    static Backward() {
+        const p = Vector3_1.Vector3.Zero();
+        const d = new Vector3_1.Vector3(0, 0, -1);
+        return this.FromPointDirection(p, d);
+    }
+    static Up() {
+        const p = Vector3_1.Vector3.Zero();
+        const d = new Vector3_1.Vector3(0, 1, 0);
+        return this.FromPointDirection(p, d);
+    }
+    static Down() {
+        const p = Vector3_1.Vector3.Zero();
+        const d = new Vector3_1.Vector3(0, -1, 0);
+        return this.FromPointDirection(p, d);
+    }
+    static Left() {
+        const p = Vector3_1.Vector3.Zero();
+        const d = new Vector3_1.Vector3(-1, 0, 0);
+        return this.FromPointDirection(p, d);
+    }
+    static Right() {
+        const p = Vector3_1.Vector3.Zero();
+        const d = new Vector3_1.Vector3(1, 0, 0);
+        return this.FromPointDirection(p, d);
+    }
+    getPointAtDistance(distance) {
+        const x = this.x0 + this.a * distance;
+        const y = this.y0 + this.b * distance;
+        const z = this.z0 + this.c * distance;
+        return new Vector3_1.Vector3(x, y, z);
+    }
+    getParameters() {
+        return {
+            x0: this.x0,
+            y0: this.y0,
+            z0: this.z0,
+            a: this.a,
+            b: this.b,
+            c: this.c,
+        };
+    }
+    copy() {
+        const parameters = this.getParameters();
+        return new ParametricLine(parameters);
+    }
+}
+exports.ParametricLine = ParametricLine;

package/lib/Entities/ParametricPlane.d.ts

@@ -0,0 +1,20 @@
+import { ParametricLine } from "./ParametricLine";
+import { Vector3 } from "./Vector3";
+export interface PlaneParameters {
+    a: number;
+    b: number;
+    c: number;
+    d: number;
+}
+export declare class ParametricPlane {
+    static FromPointNormal(point: Vector3, normal: Vector3): ParametricPlane;
+    static FromThreePoints(A: Vector3, B: Vector3, C: Vector3): ParametricPlane;
+    static XY(): ParametricPlane;
+    static ZX(): ParametricPlane;
+    static YZ(): ParametricPlane;
+    private point;
+    private normal;
+    getParameters(): PlaneParameters;
+    intersectLine(line: ParametricLine): Vector3 | undefined;
+    constructor(point: Vector3, normal: Vector3);
+}

package/lib/Entities/ParametricPlane.js

@@ -0,0 +1,63 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ParametricPlane = void 0;
+const Vector3_1 = require("./Vector3");
+class ParametricPlane {
+    constructor(point, normal) {
+        this.point = point.copy();
+        this.normal = normal.copy();
+    }
+    static FromPointNormal(point, normal) {
+        return new ParametricPlane(point, normal);
+    }
+    static FromThreePoints(A, B, C) {
+        const point = A;
+        const AB = B.subtract(A);
+        const AC = C.subtract(A);
+        const normal = AB.cross(AC);
+        return new ParametricPlane(point, normal);
+    }
+    static XY() {
+        const p = Vector3_1.Vector3.Zero();
+        const n = new Vector3_1.Vector3(0, 0, 1);
+        return new ParametricPlane(p, n);
+    }
+    static ZX() {
+        const p = Vector3_1.Vector3.Zero();
+        const n = new Vector3_1.Vector3(0, 1, 0);
+        return new ParametricPlane(p, n);
+    }
+    static YZ() {
+        const p = Vector3_1.Vector3.Zero();
+        const n = new Vector3_1.Vector3(1, 0, 0);
+        return new ParametricPlane(p, n);
+    }
+    getParameters() {
+        const a = this.normal.x;
+        const b = this.normal.y;
+        const c = this.normal.z;
+        let d = this.point.dot(this.normal);
+        if (d !== 0) {
+            d *= -1;
+        }
+        return {
+            a,
+            b,
+            c,
+            d,
+        };
+    }
+    intersectLine(line) {
+        const { x0, y0, z0, a, b, c } = line.getParameters();
+        const { a: A, b: B, c: C, d: D } = this.getParameters();
+        const tNumerator = -(A * x0 + B * y0 + C * z0 + D);
+        const tDenominator = A * a + B * b + C * c;
+        if (tDenominator === 0) {
+            return undefined;
+        }
+        const t = tNumerator / tDenominator;
+        const intersect = line.getPointAtDistance(t);
+        return intersect;
+    }
+}
+exports.ParametricPlane = ParametricPlane;

package/lib/Entities/StateMachine.d.ts

@@ -0,0 +1,25 @@
+export interface SerializedStates {
+    version: number;
+    systems: SystemState[];
+}
+export interface SystemState {
+    name: string;
+    seriliziationVersion: number;
+    state: object;
+}
+export interface SerializedSystem {
+    name: string;
+    seriliziationVersion: number;
+    getSystemState(): object;
+    applySystemState(state: object, version: number, transitionDuration: number): void;
+    applyDefaultState(transitionDuration: number): void;
+}
+export interface StateMachine {
+    transitionEaseFunction: (normalizedTime: number) => number;
+    getSerializedStates(): SerializedStates;
+    setSerializedStates(state: SerializedStates, transitionTime: number): void;
+    applySerializedStatesString: (state: string, duration?: number) => void;
+    setDefaultState(transitionTime: number): void;
+    registerSerializedSystem(serializedSystem: SerializedSystem): void;
+}
+export declare function makeStateMachine(): StateMachine;

package/lib/Entities/StateMachine.js

@@ -0,0 +1,81 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.makeStateMachine = void 0;
+function makeStateMachine() {
+    return new StateMachineImp();
+}
+exports.makeStateMachine = makeStateMachine;
+class StateMachineImp {
+    constructor() {
+        this.serializedSystems = new Map();
+        this.serilizationVersion = 2;
+        this.transitionEaseFunction = (normalizedTime) => {
+            return normalizedTime; // default to a linear function
+        };
+        this.applySerializedStatesString = (state, duration = 0) => {
+            if (state === "") {
+                this.setDefaultState(duration);
+            }
+            else {
+                try {
+                    const stateObj = JSON.parse(state);
+                    this.setSerializedStates(stateObj, duration);
+                }
+                catch (e) {
+                    this.setDefaultState(duration);
+                    console.warn("[StateMachine] Failed to deserialize state string: " + e);
+                }
+            }
+        };
+        this.registerSerializedSystem = (serializedSystem) => {
+            if (this.serializedSystems.has(serializedSystem.name)) {
+                throw new Error(`[StateMachine] Duplicate stateable systems encountered: ${serializedSystem.name}`);
+            }
+            this.serializedSystems.set(serializedSystem.name, serializedSystem);
+        };
+        this.getSerializedStates = () => {
+            const systems = Array.from(this.serializedSystems.values());
+            const serializedStates = systems.map((system) => {
+                const state = system.getSystemState();
+                return {
+                    seriliziationVersion: system.seriliziationVersion,
+                    name: system.name,
+                    state,
+                };
+            });
+            return {
+                version: this.serilizationVersion,
+                systems: serializedStates,
+            };
+        };
+        this.setSerializedStates = (state, duration) => {
+            if (state.version === 2) {
+                const appliedToSystems = [];
+                state.systems.forEach((systemState) => {
+                    const seriliazableSystem = this.serializedSystems.get(systemState.name);
+                    if (seriliazableSystem) {
+                        seriliazableSystem.applySystemState(systemState.state, systemState.seriliziationVersion, duration);
+                    }
+                    else {
+                        console.warn("Unable to find seriarializedSystem " + systemState.name);
+                    }
+                    appliedToSystems.push(systemState.name);
+                });
+                this.serializedSystems.forEach((system) => {
+                    if (!appliedToSystems.includes(system.name)) {
+                        system.applyDefaultState(duration);
+                    }
+                });
+            }
+            // Here is where we will add support for future versions
+            else {
+                throw new Error(`[StateMachine] Unsupported sereialized state encountered: ${state.version}`);
+            }
+        };
+        this.setDefaultState = (duration) => {
+            this.serializedSystems.forEach((system) => {
+                system.applyDefaultState(duration);
+            });
+        };
+    }
+}

package/lib/Entities/UndoRedo.d.ts

@@ -0,0 +1,22 @@
+export declare type OnUndoRedoChange = () => void;
+export interface UndoRedoer {
+    undoAction: (action: UndoRedoAction) => void;
+    redoAction: (action: UndoRedoAction) => void;
+}
+export declare type DoUndoRedoAction = (action: UndoRedoAction) => void;
+export interface UndoRedo {
+    hasUndo: boolean;
+    hasRedo: boolean;
+    submitAction: (action: UndoRedoAction) => void;
+    doUndo: () => void;
+    doRedo: () => void;
+    clearStack: () => void;
+    registerUndoRedoer: (undoRedoer: UndoRedoer) => void;
+    addObserver: (observer: OnUndoRedoChange) => void;
+    removeObserver: (observer: OnUndoRedoChange) => void;
+}
+export declare function makeUndoRedo(): UndoRedo;
+export declare type UndoRedoAction = {
+    type: string;
+    payload: object;
+};

package/lib/Entities/UndoRedo.js

@@ -0,0 +1,61 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.makeUndoRedo = void 0;
+const _1 = require(".");
+function makeUndoRedo() {
+    return new UndoRedoImp();
+}
+exports.makeUndoRedo = makeUndoRedo;
+class UndoRedoImp {
+    constructor() {
+        this.observers = new _1.ObserverList();
+        this.undoRedoers = [];
+        this.undoStack = [];
+        this.redoStack = [];
+        this.doUndo = () => {
+            const action = this.undoStack.pop();
+            if (!action) {
+                console.warn("[UndoRedo] nothing to undo");
+                return;
+            }
+            this.redoStack.push(action);
+            this.undoRedoers.forEach(undoers => undoers.undoAction(action));
+            this.observers.notify();
+        };
+        this.doRedo = () => {
+            const action = this.redoStack.pop();
+            if (!action) {
+                console.warn("[UndoRedo] nothing to redo");
+                return;
+            }
+            this.undoStack.push(action);
+            this.undoRedoers.forEach(redoers => redoers.redoAction(action));
+            this.observers.notify();
+        };
+        this.submitAction = (action) => {
+            this.undoStack.push(action);
+            this.redoStack = [];
+            this.observers.notify();
+        };
+        this.clearStack = () => {
+            this.redoStack = [];
+            this.undoStack = [];
+            this.observers.notify();
+        };
+        this.registerUndoRedoer = (undoredoer) => {
+            this.undoRedoers.push(undoredoer);
+        };
+        this.addObserver = (observer) => {
+            this.observers.add(observer);
+        };
+        this.removeObserver = (observer) => {
+            this.observers.remove(observer);
+        };
+    }
+    get hasUndo() {
+        return this.undoStack.length > 0;
+    }
+    get hasRedo() {
+        return this.redoStack.length > 0;
+    }
+}

package/lib/Entities/Vector2.d.ts

@@ -0,0 +1,21 @@
+export declare class Vector2 {
+    static Zero(): Vector2;
+    static One(): Vector2;
+    x: number;
+    y: number;
+    get magnitued(): number;
+    get unit(): Vector2;
+    get theta(): number;
+    setLength: (length: number) => void;
+    add: (vector2: Vector2) => Vector2;
+    subtract: (vector2: Vector2) => Vector2;
+    equal: (a: Vector2) => boolean;
+    close: (vec: Vector2) => boolean;
+    copy: () => Vector2;
+    asArray: () => [number, number];
+    rotate: (theta: number) => Vector2;
+    dot: (vec: Vector2) => number;
+    angleTo: (vec: Vector2) => number;
+    cross: (vec: Vector2) => number;
+    constructor(x: number, y: number);
+}

package/lib/Entities/Vector2.js

@@ -0,0 +1,83 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Vector2 = void 0;
+class Vector2 {
+    constructor(x, y) {
+        this.setLength = (length) => {
+            const unit = this.unit;
+            this.x = length * unit.x;
+            this.y = length * unit.y;
+        };
+        this.add = (vector2) => {
+            return new Vector2(this.x + vector2.x, this.y + vector2.y);
+        };
+        this.subtract = (vector2) => {
+            return new Vector2(this.x - vector2.x, this.y - vector2.y);
+        };
+        this.equal = (a) => {
+            if (a.x === this.x && a.y === this.y)
+                return true;
+            else
+                return false;
+        };
+        this.close = (vec) => {
+            const diff = this.subtract(vec);
+            const diffMag = diff.magnitued;
+            if (diffMag < 0.01)
+                return true;
+            else
+                return false;
+        };
+        this.copy = () => {
+            return new Vector2(this.x, this.y);
+        };
+        this.asArray = () => {
+            return [this.x, this.y];
+        };
+        this.rotate = (theta) => {
+            const thetaRadians = theta * Math.PI / 180;
+            const x = this.x * Math.cos(thetaRadians) - this.y * Math.sin(thetaRadians);
+            const y = this.x * Math.sin(thetaRadians) + this.y * Math.cos(thetaRadians);
+            return new Vector2(x, y);
+        };
+        this.dot = (vec) => {
+            return this.x * vec.x + this.y * vec.y;
+        };
+        this.angleTo = (vec) => {
+            const dot = this.dot(vec);
+            const magnitues = vec.magnitued * this.magnitued;
+            const angRadians = Math.acos(dot / magnitues);
+            return angRadians * 180 / Math.PI;
+        };
+        this.cross = (vec) => {
+            return (this.x * vec.y) - (this.y * vec.x);
+        };
+        this.x = x;
+        this.y = y;
+    }
+    static Zero() {
+        return new Vector2(0, 0);
+    }
+    static One() {
+        return new Vector2(1, 1);
+    }
+    get magnitued() {
+        const xSqr = this.x * this.x;
+        const ySqr = this.y * this.y;
+        const magnitude = Math.sqrt(xSqr + ySqr);
+        return magnitude;
+    }
+    get unit() {
+        const mag = this.magnitued;
+        if (mag === 0) {
+            return Vector2.Zero();
+        }
+        const unitX = this.x / mag;
+        const unitY = this.y / mag;
+        return new Vector2(unitX, unitY);
+    }
+    get theta() {
+        return (Math.atan2(this.y, this.x) * 180) / Math.PI;
+    }
+}
+exports.Vector2 = Vector2;

package/lib/Entities/Vector3.d.ts

@@ -0,0 +1,19 @@
+export declare class Vector3 {
+    static Zero(): Vector3;
+    static One(): Vector3;
+    x: number;
+    y: number;
+    z: number;
+    get magnitued(): number;
+    get unit(): Vector3;
+    setLength: (length: number) => void;
+    add: (a: Vector3) => Vector3;
+    subtract: (vector2: Vector3) => Vector3;
+    copy: () => Vector3;
+    equals: (vec: Vector3) => boolean;
+    close: (vec: Vector3) => boolean;
+    cross: (vec: Vector3) => Vector3;
+    dot: (vec: Vector3) => number;
+    asArray: () => [number, number, number];
+    constructor(x: number, y: number, z: number);
+}

package/lib/Entities/Vector3.js

@@ -0,0 +1,75 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Vector3 = void 0;
+class Vector3 {
+    constructor(x, y, z) {
+        this.setLength = (length) => {
+            const unit = this.unit;
+            this.x = length * unit.x;
+            this.y = length * unit.y;
+            this.z = length * unit.z;
+        };
+        this.add = (a) => {
+            return new Vector3(this.x + a.x, this.y + a.y, this.z + a.z);
+        };
+        this.subtract = (vector2) => {
+            return new Vector3(this.x - vector2.x, this.y - vector2.y, this.z - vector2.z);
+        };
+        this.copy = () => {
+            return new Vector3(this.x, this.y, this.z);
+        };
+        this.equals = (vec) => {
+            if (vec.x === this.x && vec.y === this.y && vec.z === this.z)
+                return true;
+            else
+                return false;
+        };
+        this.close = (vec) => {
+            const diff = this.subtract(vec);
+            const diffMag = diff.magnitued;
+            if (diffMag < 0.01)
+                return true;
+            else
+                return false;
+        };
+        this.cross = (vec) => {
+            const x = this.y * vec.z - this.z * vec.y;
+            const y = this.z * vec.x - this.x * vec.z;
+            const z = this.x * vec.y - this.y * vec.x;
+            return new Vector3(x, y, z);
+        };
+        this.dot = (vec) => {
+            return this.x * vec.x + this.y * vec.y + this.z * vec.z;
+        };
+        this.asArray = () => {
+            return [this.x, this.y, this.z];
+        };
+        this.x = x;
+        this.y = y;
+        this.z = z;
+    }
+    static Zero() {
+        return new Vector3(0, 0, 0);
+    }
+    static One() {
+        return new Vector3(1, 1, 1);
+    }
+    get magnitued() {
+        const xSqr = this.x * this.x;
+        const ySqr = this.y * this.y;
+        const zSqr = this.z * this.z;
+        const magnitude = Math.sqrt(xSqr + ySqr + zSqr);
+        return magnitude;
+    }
+    get unit() {
+        const mag = this.magnitued;
+        if (mag === 0) {
+            return Vector3.Zero();
+        }
+        const unitX = this.x / mag;
+        const unitY = this.y / mag;
+        const unitZ = this.z / mag;
+        return new Vector3(unitX, unitY, unitZ);
+    }
+}
+exports.Vector3 = Vector3;