@vived/app 2.6.0 → 2.6.4

package/lib/Entities/MemoizedVector3.js

@@ -0,0 +1,46 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MemoizedVector3 = void 0;
+class MemoizedVector3 {
+    constructor(initialValue, onChangeCallback) {
+        this._val = initialValue.copy();
+        this.onChangeCallback = onChangeCallback;
+    }
+    get x() {
+        return this._val.x;
+    }
+    set x(x) {
+        if (this._val.x === x)
+            return;
+        this._val.x = x;
+        this.onChangeCallback();
+    }
+    get y() {
+        return this._val.y;
+    }
+    set y(y) {
+        if (this._val.y === y)
+            return;
+        this._val.y = y;
+        this.onChangeCallback();
+    }
+    get z() {
+        return this._val.z;
+    }
+    set z(z) {
+        if (this._val.z === z)
+            return;
+        this._val.z = z;
+        this.onChangeCallback();
+    }
+    getVector() {
+        return this._val.copy();
+    }
+    setVector(vec) {
+        if (vec.x === this._val.x && vec.y === this._val.y && vec.z === this._val.z)
+            return;
+        this._val = vec.copy();
+        this.onChangeCallback();
+    }
+}
+exports.MemoizedVector3 = MemoizedVector3;

package/lib/Entities/MouseInput.d.ts

@@ -0,0 +1,15 @@
+export interface MouseController {
+    onClick?: (e: MouseEvent) => void;
+    onDown?: (e: MouseEvent) => void;
+    onUp?: (e: MouseEvent) => void;
+    onMove?: (e: MouseEvent) => void;
+    onWheel?: (e: WheelEvent) => void;
+}
+export interface MouseInput {
+    eventElement: HTMLElement | undefined;
+    setEventElement: (eventElement: HTMLElement) => void;
+    clearInputElement: () => void;
+    registerController: (controller: MouseController) => void;
+    removeController: (controller: MouseController) => void;
+}
+export declare function makeMouseInput(): MouseInput;

package/lib/Entities/MouseInput.js

@@ -0,0 +1,112 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.makeMouseInput = void 0;
+const _1 = require(".");
+function makeMouseInput() {
+    return new MouseInputImp();
+}
+exports.makeMouseInput = makeMouseInput;
+class MouseInputImp {
+    constructor() {
+        this.controllers = [];
+        this.maxClickMovement = 5; // pixels
+        this._eventElement = undefined;
+        this.setEventElement = (eventElement) => {
+            if (this._eventElement)
+                this.clearInputElement();
+            eventElement.addEventListener("mousedown", this.onMouseDown, false);
+            eventElement.addEventListener("mouseup", this.onMouseUp, false);
+            eventElement.addEventListener("mousemove", this.onMouseMove, false);
+            eventElement.addEventListener("mouseout", this.onMouseOut, false);
+            eventElement.addEventListener("wheel", this.onWheel, false);
+            this._eventElement = eventElement;
+        };
+        this.clearInputElement = () => {
+            if (!this._eventElement)
+                return;
+            this._eventElement.removeEventListener("mousedown", this.onMouseDown);
+            this._eventElement.removeEventListener("mouseup", this.onMouseUp);
+            this._eventElement.removeEventListener("mousemove", this.onMouseMove);
+            this._eventElement.removeEventListener("mouseout", this.onMouseOut);
+            this._eventElement.removeEventListener("wheel", this.onWheel);
+            this._eventElement = undefined;
+        };
+        this.registerController = (controller) => {
+            this.controllers.push(controller);
+        };
+        this.removeController = (controller) => {
+            const index = this.controllers.indexOf(controller);
+            if (index >= 0) {
+                this.controllers.splice(index, 1);
+            }
+        };
+        this.onMouseDown = (e) => {
+            e.preventDefault();
+            this.controllers.forEach((c) => {
+                if (c.onDown) {
+                    c.onDown(e);
+                }
+            });
+            this.pressEvent = e;
+        };
+        this.onMouseUp = (e) => {
+            e.preventDefault();
+            this.controllers.forEach((c) => {
+                if (c.onUp) {
+                    c.onUp(e);
+                }
+            });
+            if (!this.pressEvent)
+                return;
+            const deltaX = this.pressEvent.screenX - e.screenX;
+            const deltaY = this.pressEvent.screenY - e.screenY;
+            const delta = new _1.Vector2(deltaX, deltaY);
+            if (delta.magnitued < this.maxClickMovement) {
+                this.controllers.forEach((c) => {
+                    if (c.onClick) {
+                        c.onClick(e);
+                    }
+                });
+            }
+            this.pressEvent = undefined;
+        };
+        this.onMouseMove = (e) => {
+            e.preventDefault();
+            this.controllers.forEach((c) => {
+                if (c.onMove) {
+                    c.onMove(e);
+                }
+            });
+            if (!this.pressEvent)
+                return;
+            const deltaX = this.pressEvent.screenX - e.screenX;
+            const deltaY = this.pressEvent.screenY - e.screenY;
+            const delta = new _1.Vector2(deltaX, deltaY);
+            if (delta.magnitued > this.maxClickMovement) {
+                this.pressEvent = undefined;
+            }
+        };
+        this.onMouseOut = (e) => {
+            e.preventDefault();
+            if (!this.pressEvent)
+                return;
+            this.controllers.forEach((c) => {
+                if (c.onUp) {
+                    c.onUp(e);
+                }
+            });
+            this.pressEvent = undefined;
+        };
+        this.onWheel = (e) => {
+            e.preventDefault();
+            this.controllers.forEach((c) => {
+                if (c.onWheel) {
+                    c.onWheel(e);
+                }
+            });
+        };
+    }
+    get eventElement() {
+        return this._eventElement;
+    }
+}

package/lib/Entities/MouseSceneInput.d.ts

@@ -0,0 +1,15 @@
+export interface MouseController {
+    onClick?: (e: MouseEvent) => void;
+    onDown?: (e: MouseEvent) => void;
+    onUp?: (e: MouseEvent) => void;
+    onMove?: (e: MouseEvent) => void;
+    onWheel?: (e: WheelEvent) => void;
+}
+export interface MouseSceneInput {
+    eventElement: HTMLElement | undefined;
+    setEventElement: (eventElement: HTMLElement) => void;
+    clearInputElement: () => void;
+    registerController: (controller: MouseController) => void;
+    removeController: (controller: MouseController) => void;
+}
+export declare function makeMouseSceneInput(): MouseSceneInput;

package/lib/Entities/MouseSceneInput.js

@@ -0,0 +1,109 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.makeMouseSceneInput = void 0;
+const _1 = require(".");
+function makeMouseSceneInput() {
+    return new MouseSceneInputImp();
+}
+exports.makeMouseSceneInput = makeMouseSceneInput;
+class MouseSceneInputImp {
+    constructor() {
+        this.controllers = [];
+        this.maxClickMovement = 5; // pixels
+        this._eventElement = undefined;
+        this.setEventElement = (eventElement) => {
+            if (this._eventElement)
+                this.clearInputElement();
+            eventElement.addEventListener("mousedown", this.onMouseDown);
+            eventElement.addEventListener("mouseup", this.onMouseUp);
+            eventElement.addEventListener("mousemove", this.onMouseMove);
+            eventElement.addEventListener("mouseout", this.onMouseOut);
+            eventElement.addEventListener("wheel", this.onWheel);
+            this._eventElement = eventElement;
+        };
+        this.clearInputElement = () => {
+            if (!this._eventElement)
+                return;
+            this._eventElement.removeEventListener("mousedown", this.onMouseDown);
+            this._eventElement.removeEventListener("mouseup", this.onMouseUp);
+            this._eventElement.removeEventListener("mousemove", this.onMouseMove);
+            this._eventElement.removeEventListener("mouseout", this.onMouseOut);
+            this._eventElement.removeEventListener("wheel", this.onWheel);
+            this._eventElement = undefined;
+        };
+        this.registerController = (controller) => {
+            this.controllers.push(controller);
+        };
+        this.removeController = (controller) => {
+            const index = this.controllers.indexOf(controller);
+            if (index >= 0) {
+                this.controllers.splice(index, 1);
+            }
+        };
+        this.onMouseDown = (e) => {
+            const mousePos = new _1.Vector2(e.offsetX, e.offsetY);
+            this.controllers.forEach((c) => {
+                if (c.onDown) {
+                    c.onDown(e);
+                }
+            });
+            this.pressEvent = e;
+        };
+        this.onMouseUp = (e) => {
+            this.controllers.forEach((c) => {
+                if (c.onUp) {
+                    c.onUp(e);
+                }
+            });
+            if (!this.pressEvent)
+                return;
+            const deltaX = this.pressEvent.screenX - e.screenX;
+            const deltaY = this.pressEvent.screenY - e.screenY;
+            const delta = new _1.Vector2(deltaX, deltaY);
+            if (delta.magnitued < this.maxClickMovement) {
+                this.controllers.forEach((c) => {
+                    if (c.onClick) {
+                        c.onClick(e);
+                    }
+                });
+            }
+            this.pressEvent = undefined;
+        };
+        this.onMouseMove = (e) => {
+            this.controllers.forEach((c) => {
+                if (c.onMove) {
+                    c.onMove(e);
+                }
+            });
+            if (!this.pressEvent)
+                return;
+            const deltaX = this.pressEvent.screenX - e.screenX;
+            const deltaY = this.pressEvent.screenY - e.screenY;
+            const delta = new _1.Vector2(deltaX, deltaY);
+            if (delta.magnitued > this.maxClickMovement) {
+                this.pressEvent = undefined;
+            }
+        };
+        this.onMouseOut = (e) => {
+            if (!this.pressEvent)
+                return;
+            const mousePos = new _1.Vector2(e.offsetX, e.offsetY);
+            this.controllers.forEach((c) => {
+                if (c.onUp) {
+                    c.onUp(e);
+                }
+            });
+            this.pressEvent = undefined;
+        };
+        this.onWheel = (e) => {
+            this.controllers.forEach((c) => {
+                if (c.onWheel) {
+                    c.onWheel(e);
+                }
+            });
+        };
+    }
+    get eventElement() {
+        return this._eventElement;
+    }
+}

package/lib/Entities/ObserverList.d.ts

@@ -0,0 +1,6 @@
+export declare class ObserverList<T> {
+    private observers;
+    notify: (msg: T) => void;
+    add: (obs: (msg: T) => void) => void;
+    remove: (obs: (msg: T) => void) => void;
+}

package/lib/Entities/ObserverList.js

@@ -0,0 +1,23 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ObserverList = void 0;
+class ObserverList {
+    constructor() {
+        this.observers = [];
+        this.notify = (msg) => {
+            this.observers.forEach((obs) => {
+                obs(msg);
+            });
+        };
+        this.add = (obs) => {
+            this.observers.push(obs);
+        };
+        this.remove = (obs) => {
+            const index = this.observers.indexOf(obs);
+            if (index >= 0) {
+                this.observers.splice(index, 1);
+            }
+        };
+    }
+}
+exports.ObserverList = ObserverList;

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;