@vived/app 3.8.0 → 3.9.1

package/lib/AppObjectComponents/SceneRoot/UC/FocusOnPixel.js

@@ -0,0 +1,56 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.makeFocusOnPixelUC = exports.FocusOnPixelUC = void 0;
+const AppObjectUC_1 = require("../../../AppObject/AppObjectUC");
+const App_1 = require("../../App");
+const Babylon_1 = require("../../Babylon");
+const Dispatcher_1 = require("../../Dispatcher");
+const SceneRoot_1 = require("../Entities/SceneRoot");
+class FocusOnPixelUC extends AppObjectUC_1.AppObjectUC {
+    static get(appObjects) {
+        const components = appObjects.getAllComponents(FocusOnPixelUC.type);
+        if (components.length === 0) {
+            App_1.submitWarning(FocusOnPixelUC.type, `Unable to find component ${FocusOnPixelUC.type}. Add one on Mount`, appObjects);
+            return undefined;
+        }
+        else if (components.length > 1) {
+            App_1.submitWarning(FocusOnPixelUC.type, `Multiple ${FocusOnPixelUC.type} found. There should only be one. Using the first one`, appObjects);
+        }
+        return components[0];
+    }
+}
+exports.FocusOnPixelUC = FocusOnPixelUC;
+FocusOnPixelUC.type = "FocusOnPixelUC";
+function makeFocusOnPixelUC(appObject) {
+    return new FocusOnPixelImp(appObject);
+}
+exports.makeFocusOnPixelUC = makeFocusOnPixelUC;
+class FocusOnPixelImp extends FocusOnPixelUC {
+    constructor(appObject) {
+        super(appObject, FocusOnPixelUC.type);
+        this.durationMS = 500;
+        this.easeFn = (val) => {
+            return val;
+        };
+        this.centerOnPixel = (pixel) => {
+            if (!this.sceneRoot)
+                return;
+            const scenePick = Babylon_1.scenePixelPick(pixel, this.appObjects);
+            if (scenePick === null || scenePick === void 0 ? void 0 : scenePick.worldPickPoint) {
+                this.sceneRoot.centerOnPoint(scenePick.worldPickPoint, this.durationMS, this.easeFn, () => this.onCenterCompleted());
+            }
+            else {
+                this.sceneRoot.lerpToDefault(this.durationMS, this.easeFn, () => this.onCenterCompleted());
+            }
+        };
+        this.onCenterCompleted = () => {
+            Dispatcher_1.dispatchStateChange(this.appObjects);
+        };
+        this.appObjects = appObject.appObjectRepo;
+        this.sceneRoot = appObject.getComponent(SceneRoot_1.SceneRoot.type);
+        if (!this.sceneRoot) {
+            App_1.submitWarning("BumpSceneRootScaleAboutPixelPoint", "BumpSceneRootScaleAboutPixelPointImp UC has been added to an App Object that does not have a SceneRoot Entity", this.appObjects);
+            return;
+        }
+    }
+}

package/lib/AppObjectComponents/SceneRoot/UC/OrbitSceneRoot.d.ts

@@ -0,0 +1,14 @@
+import { AppObject } from "../../../AppObject/AppObject";
+import { AppObjectRepo } from "../../../AppObject/AppObjectRepo";
+import { AppObjectUC } from "../../../AppObject/AppObjectUC";
+import { Vector2 } from "../../../ValueObjects";
+export declare abstract class OrbitSceneRootUC extends AppObjectUC {
+    static readonly type = "OrbitSceneRootUC";
+    abstract readonly sensitivity: number;
+    abstract doOrbit: (pixel: Vector2) => void;
+    abstract initializeOrbit: (pixel: Vector2) => void;
+    abstract finishOrbit: () => void;
+    abstract cancelOrbit: () => void;
+    static get(appObjects: AppObjectRepo): OrbitSceneRootUC | undefined;
+}
+export declare function makeOrbitSceneRootUC(appObject: AppObject): OrbitSceneRootUC;

package/lib/AppObjectComponents/SceneRoot/UC/OrbitSceneRoot.js

@@ -0,0 +1,92 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.makeOrbitSceneRootUC = exports.OrbitSceneRootUC = void 0;
+const AppObjectUC_1 = require("../../../AppObject/AppObjectUC");
+const ValueObjects_1 = require("../../../ValueObjects");
+const App_1 = require("../../App");
+const Babylon_1 = require("../../Babylon");
+const Dispatcher_1 = require("../../Dispatcher");
+const SceneRoot_1 = require("../Entities/SceneRoot");
+class OrbitSceneRootUC extends AppObjectUC_1.AppObjectUC {
+    static get(appObjects) {
+        const components = appObjects.getAllComponents(OrbitSceneRootUC.type);
+        if (components.length === 0) {
+            App_1.submitWarning(OrbitSceneRootUC.type, `Unable to find component ${OrbitSceneRootUC.type}. Add one on Mount`, appObjects);
+            return undefined;
+        }
+        else if (components.length > 1) {
+            App_1.submitWarning(OrbitSceneRootUC.type, `Multiple ${OrbitSceneRootUC.type} found. There should only be one. Using the first one`, appObjects);
+        }
+        return components[0];
+    }
+}
+exports.OrbitSceneRootUC = OrbitSceneRootUC;
+OrbitSceneRootUC.type = "OrbitSceneRootUC";
+function makeOrbitSceneRootUC(appObject) {
+    return new OrbitSceneRootImp(appObject);
+}
+exports.makeOrbitSceneRootUC = makeOrbitSceneRootUC;
+class OrbitSceneRootImp extends OrbitSceneRootUC {
+    constructor(appObject) {
+        var _a;
+        super(appObject, OrbitSceneRootUC.type);
+        this.sensitivity = 0.1;
+        this.lastPixelPos = ValueObjects_1.Vector2.Zero();
+        this.pickPoint = ValueObjects_1.Vector3.Zero();
+        this.localPickOffset = ValueObjects_1.Vector3.Zero();
+        this.initialQuat = ValueObjects_1.Quaternion.Identity();
+        this.hasBeenInitialized = false;
+        this.doOrbit = (pixelPosition) => {
+            if (!this.transformNode)
+                return;
+            if (!this.hasBeenInitialized)
+                return;
+            const pixelChange = ValueObjects_1.Vector2.Subtract(pixelPosition, this.lastPixelPos);
+            const pitchAngle = ValueObjects_1.Angle.FromDegrees(pixelChange.y * this.sensitivity);
+            const pitchQuaternion = ValueObjects_1.Quaternion.FromAngleAxis(ValueObjects_1.Vector3.Left(), pitchAngle);
+            this.transformNode.worldRotation = ValueObjects_1.Quaternion.Multiply(pitchQuaternion, this.transformNode.worldRotation);
+            const worldUp = this.transformNode.localDirectionToWorld(ValueObjects_1.Vector3.Up());
+            let xMovement = pixelChange.x;
+            if (worldUp.y < 0) {
+                xMovement = -pixelChange.x;
+            }
+            const headingAngle = ValueObjects_1.Angle.FromDegrees(xMovement * this.sensitivity);
+            const headingQuaternion = ValueObjects_1.Quaternion.FromAngleAxis(ValueObjects_1.Vector3.Down(), headingAngle);
+            this.transformNode.localRotation = ValueObjects_1.Quaternion.Multiply(this.transformNode.localRotation, headingQuaternion);
+            const worldPickOffset = this.transformNode.localPointToWorld(this.localPickOffset);
+            const bump = ValueObjects_1.Vector3.Subtract(this.pickPoint, worldPickOffset);
+            this.transformNode.worldPosition = ValueObjects_1.Vector3.Add(bump, this.transformNode.worldPosition);
+            this.lastPixelPos = pixelPosition;
+        };
+        this.initializeOrbit = (initialPixelPos) => {
+            var _a;
+            if (!this.transformNode)
+                return;
+            this.lastPixelPos = initialPixelPos;
+            const pick = Babylon_1.scenePixelPick(initialPixelPos, this.appObjects);
+            this.pickPoint = (_a = pick === null || pick === void 0 ? void 0 : pick.worldPickPoint) !== null && _a !== void 0 ? _a : ValueObjects_1.Vector3.Zero();
+            this.localPickOffset = this.transformNode.worldPointToLocal(this.pickPoint);
+            this.transformNode.cancelLerp();
+            this.hasBeenInitialized = true;
+            this.initialQuat = this.transformNode.localRotation;
+        };
+        this.finishOrbit = () => {
+            this.hasBeenInitialized = false;
+            if (!this.transformNode)
+                return;
+            if (ValueObjects_1.Quaternion.Equal(this.initialQuat, this.transformNode.localRotation))
+                return;
+            Dispatcher_1.dispatchStateChange(this.appObjects);
+        };
+        this.cancelOrbit = () => {
+            this.hasBeenInitialized = false;
+        };
+        this.appObjects = appObject.appObjectRepo;
+        this.sceneRoot = appObject.getComponent(SceneRoot_1.SceneRoot.type);
+        if (!this.sceneRoot) {
+            App_1.submitWarning("OrbitSceneRootImp", "OrbitSceneRootImp UC has been added to an App Object that does not have a SceneRoot Entity", this.appObjects);
+            return;
+        }
+        this.transformNode = (_a = this.sceneRoot) === null || _a === void 0 ? void 0 : _a.transform;
+    }
+}

package/lib/AppObjectComponents/SceneRoot/UC/PanSceneRoot.d.ts

@@ -0,0 +1,13 @@
+import { AppObject } from "../../../AppObject/AppObject";
+import { AppObjectRepo } from "../../../AppObject/AppObjectRepo";
+import { AppObjectUC } from "../../../AppObject/AppObjectUC";
+import { Vector2 } from "../../../ValueObjects";
+export declare abstract class PanSceneRootUC extends AppObjectUC {
+    static readonly type = "PanSceneRootUC";
+    abstract doPan: (pixel: Vector2) => void;
+    abstract initializePan: (pixel: Vector2) => void;
+    abstract finishPan: () => void;
+    abstract cancelPan: () => void;
+    static get(appObjects: AppObjectRepo): PanSceneRootUC | undefined;
+}
+export declare function makePanSceneRootUC(appObject: AppObject): PanSceneRootUC;

package/lib/AppObjectComponents/SceneRoot/UC/PanSceneRoot.js

@@ -0,0 +1,86 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.makePanSceneRootUC = exports.PanSceneRootUC = void 0;
+const AppObjectUC_1 = require("../../../AppObject/AppObjectUC");
+const ValueObjects_1 = require("../../../ValueObjects");
+const App_1 = require("../../App");
+const Babylon_1 = require("../../Babylon");
+const Dispatcher_1 = require("../../Dispatcher");
+const SceneRoot_1 = require("../Entities/SceneRoot");
+class PanSceneRootUC extends AppObjectUC_1.AppObjectUC {
+    static get(appObjects) {
+        const components = appObjects.getAllComponents(PanSceneRootUC.type);
+        if (components.length === 0) {
+            App_1.submitWarning(PanSceneRootUC.type, `Unable to find component ${PanSceneRootUC.type}. Add one on Mount`, appObjects);
+            return undefined;
+        }
+        else if (components.length > 1) {
+            App_1.submitWarning(PanSceneRootUC.type, `Multiple ${PanSceneRootUC.type} found. There should only be one. Using the first one`, appObjects);
+        }
+        return components[0];
+    }
+}
+exports.PanSceneRootUC = PanSceneRootUC;
+PanSceneRootUC.type = "PanSceneRootUC";
+function makePanSceneRootUC(appObject) {
+    return new PanSceneRootImp(appObject);
+}
+exports.makePanSceneRootUC = makePanSceneRootUC;
+class PanSceneRootImp extends PanSceneRootUC {
+    constructor(appObject) {
+        var _a;
+        super(appObject, PanSceneRootUC.type);
+        this.pickOffset = ValueObjects_1.Vector3.Zero();
+        this.intialPosition = ValueObjects_1.Vector3.Zero();
+        this.hasBeenInitialized = false;
+        this.panPlane = ValueObjects_1.ParametricPlane.XY();
+        this.doPan = (pixelPosition) => {
+            var _a;
+            if (!this.transformNode)
+                return;
+            if (!this.hasBeenInitialized)
+                return;
+            const pickRay = Babylon_1.pixelToSceneRay(pixelPosition, this.appObjects);
+            const pick = (_a = this.panPlane.intersectLine(pickRay)) !== null && _a !== void 0 ? _a : ValueObjects_1.Vector3.Zero();
+            this.transformNode.worldPosition = ValueObjects_1.Vector3.Add(pick, this.pickOffset);
+        };
+        this.initializePan = (initialPixelPos) => {
+            var _a, _b;
+            if (!this.transformNode)
+                return;
+            if (!this.sceneRoot)
+                return;
+            const scenePick = Babylon_1.scenePixelPick(initialPixelPos, this.appObjects);
+            if (!scenePick)
+                return;
+            const pickPlaneDirection = ValueObjects_1.Vector3.Backward();
+            const planePickPos = (_a = scenePick === null || scenePick === void 0 ? void 0 : scenePick.worldPickPoint) !== null && _a !== void 0 ? _a : ValueObjects_1.Vector3.Zero();
+            this.panPlane = ValueObjects_1.ParametricPlane.FromPointNormal(planePickPos, pickPlaneDirection);
+            const pick = (_b = this.panPlane.intersectLine(scenePick.sceneRay)) !== null && _b !== void 0 ? _b : ValueObjects_1.Vector3.Zero();
+            const rootPos = this.transformNode.worldPosition;
+            this.pickOffset = ValueObjects_1.Vector3.Subtract(rootPos, pick);
+            this.hasBeenInitialized = true;
+            this.intialPosition = this.sceneRoot.position;
+        };
+        this.finishPan = () => {
+            if (!this.hasBeenInitialized)
+                return;
+            if (!this.sceneRoot)
+                return;
+            this.hasBeenInitialized = false;
+            if (ValueObjects_1.Vector3.Equal(this.intialPosition, this.sceneRoot.position))
+                return;
+            Dispatcher_1.dispatchStateChange(this.appObjects);
+        };
+        this.cancelPan = () => {
+            this.hasBeenInitialized = false;
+        };
+        this.appObjects = appObject.appObjectRepo;
+        this.sceneRoot = appObject.getComponent(SceneRoot_1.SceneRoot.type);
+        if (!this.sceneRoot) {
+            App_1.submitWarning("OrbitSceneRootImp", "OrbitSceneRootImp UC has been added to an App Object that does not have a SceneRoot Entity", this.appObjects);
+            return;
+        }
+        this.transformNode = (_a = this.sceneRoot) === null || _a === void 0 ? void 0 : _a.transform;
+    }
+}

package/lib/AppObjectComponents/SceneRoot/UC/PinchSceneRoot.d.ts

@@ -0,0 +1,13 @@
+import { AppObject } from "../../../AppObject/AppObject";
+import { AppObjectRepo } from "../../../AppObject/AppObjectRepo";
+import { AppObjectUC } from "../../../AppObject/AppObjectUC";
+import { Vector2 } from "../../../ValueObjects";
+export declare abstract class PinchSceneRootUC extends AppObjectUC {
+    static readonly type = "PinchSceneRootUC";
+    abstract readonly sensitivity: number;
+    abstract doPinch: (touchPos1: Vector2, touchPos2: Vector2) => void;
+    abstract initializePinch: (touchPos1: Vector2, touchPos2: Vector2) => void;
+    abstract finishPinch: () => void;
+    static get(appObjects: AppObjectRepo): PinchSceneRootUC | undefined;
+}
+export declare function makePinchSceneRootUC(appObject: AppObject): PinchSceneRootUC;

package/lib/AppObjectComponents/SceneRoot/UC/PinchSceneRoot.js

@@ -0,0 +1,102 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.makePinchSceneRootUC = exports.PinchSceneRootUC = void 0;
+const AppObjectUC_1 = require("../../../AppObject/AppObjectUC");
+const ValueObjects_1 = require("../../../ValueObjects");
+const App_1 = require("../../App");
+const Babylon_1 = require("../../Babylon");
+const Dispatcher_1 = require("../../Dispatcher");
+const SceneRoot_1 = require("../Entities/SceneRoot");
+class PinchSceneRootUC extends AppObjectUC_1.AppObjectUC {
+    static get(appObjects) {
+        const components = appObjects.getAllComponents(PinchSceneRootUC.type);
+        if (components.length === 0) {
+            App_1.submitWarning(PinchSceneRootUC.type, `Unable to find component ${PinchSceneRootUC.type}. Add one on Mount`, appObjects);
+            return undefined;
+        }
+        else if (components.length > 1) {
+            App_1.submitWarning(PinchSceneRootUC.type, `Multiple ${PinchSceneRootUC.type} found. There should only be one. Using the first one`, appObjects);
+        }
+        return components[0];
+    }
+}
+exports.PinchSceneRootUC = PinchSceneRootUC;
+PinchSceneRootUC.type = "PinchSceneRootUC";
+function makePinchSceneRootUC(appObject) {
+    return new PinchSceneRootImp(appObject);
+}
+exports.makePinchSceneRootUC = makePinchSceneRootUC;
+class PinchSceneRootImp extends PinchSceneRootUC {
+    constructor(appObject) {
+        super(appObject, PinchSceneRootUC.type);
+        this.sensitivity = 0.01;
+        this.previousDistanceBetweenTouches = 0;
+        this.panPlane = ValueObjects_1.ParametricPlane.XY();
+        this.pickOffset = ValueObjects_1.Vector3.Zero();
+        this.initialScale = 0;
+        this.initializePinch = (touchPos1, touchPos2) => {
+            var _a, _b;
+            if (!this.sceneRoot)
+                return;
+            const transformNode = this.sceneRoot.transform;
+            this.previousDistanceBetweenTouches = this.getTouchDistance(touchPos1, touchPos2);
+            const touchCenter = this.getTouchCenter(touchPos1, touchPos2);
+            const scenePick = Babylon_1.scenePixelPick(touchCenter, this.appObjects);
+            const pickPoint = (_a = scenePick === null || scenePick === void 0 ? void 0 : scenePick.worldPickPoint) !== null && _a !== void 0 ? _a : ValueObjects_1.Vector3.Zero();
+            const pickPlaneDirection = ValueObjects_1.Vector3.Backward();
+            this.panPlane = ValueObjects_1.ParametricPlane.FromPointNormal(pickPoint, pickPlaneDirection);
+            const pickRay = Babylon_1.pixelToSceneRay(touchCenter, this.appObjects);
+            const planePick = (_b = this.panPlane.intersectLine(pickRay)) !== null && _b !== void 0 ? _b : ValueObjects_1.Vector3.Zero();
+            this.pickOffset = transformNode.worldPointToLocal(planePick);
+            this.initialScale = this.sceneRoot.scale;
+        };
+        this.doPinch = (touchPos1, touchPos2) => {
+            var _a;
+            if (!this.sceneRoot)
+                return;
+            const transformNode = this.sceneRoot.transform;
+            const currentTouchDist = this.getTouchDistance(touchPos1, touchPos2);
+            const touchDelta = currentTouchDist - this.previousDistanceBetweenTouches;
+            const currentScale = this.sceneRoot.scale;
+            const scaleDelta = touchDelta * this.sensitivity * currentScale;
+            let newScale = currentScale + scaleDelta;
+            if (newScale < this.sceneRoot.minScale) {
+                newScale = this.sceneRoot.minScale;
+            }
+            else if (newScale > this.sceneRoot.maxScale) {
+                newScale = this.sceneRoot.maxScale;
+            }
+            transformNode.worldScale = new ValueObjects_1.Vector3(newScale, newScale, newScale);
+            const touchCenter = this.getTouchCenter(touchPos1, touchPos2);
+            const pickRay = Babylon_1.pixelToSceneRay(touchCenter, this.appObjects);
+            const planePick = (_a = this.panPlane.intersectLine(pickRay)) !== null && _a !== void 0 ? _a : ValueObjects_1.Vector3.Zero();
+            const globalOffset = transformNode.localPointToWorld(this.pickOffset);
+            const delta = ValueObjects_1.Vector3.Subtract(planePick, globalOffset);
+            const currentWorldPos = transformNode.worldPosition;
+            const newWorldPos = ValueObjects_1.Vector3.Add(currentWorldPos, delta);
+            transformNode.worldPosition = newWorldPos;
+            this.previousDistanceBetweenTouches = currentTouchDist;
+        };
+        this.finishPinch = () => {
+            var _a;
+            if (this.initialScale === ((_a = this.sceneRoot) === null || _a === void 0 ? void 0 : _a.scale))
+                return;
+            Dispatcher_1.dispatchStateChange(this.appObjects);
+        };
+        this.appObjects = appObject.appObjectRepo;
+        this.sceneRoot = appObject.getComponent(SceneRoot_1.SceneRoot.type);
+        if (!this.sceneRoot) {
+            App_1.submitWarning("PinchSceneRootUC", "PinchSceneRootUC UC has been added to an App Object that does not have a SceneRoot Entity", this.appObjects);
+            return;
+        }
+    }
+    getTouchCenter(t1, t2) {
+        const delta = ValueObjects_1.Vector2.Subtract(t2, t1);
+        const halfDelta = ValueObjects_1.Vector2.NewVectorOfLength(delta.unit, 0.5 * delta.magnitued);
+        return ValueObjects_1.Vector2.Add(t1, halfDelta);
+    }
+    getTouchDistance(t1, t2) {
+        const delta = ValueObjects_1.Vector2.Subtract(t2, t1);
+        return delta.magnitued;
+    }
+}

package/lib/AppObjectComponents/SceneRoot/UC/ScaleSceneRootWithRay.d.ts

@@ -0,0 +1,14 @@
+import { AppObject } from "../../../AppObject/AppObject";
+import { AppObjectUC } from "../../../AppObject/AppObjectUC";
+import { ParametricLine, Vector3 } from "../../../ValueObjects";
+export declare class ScaleSceneRootWithRay extends AppObjectUC {
+    static readonly type = "ScaleSceneRootWithRay";
+    readonly sensitivity = 10;
+    private appObjects;
+    private sceneRoot?;
+    private pickPoint;
+    private lastDistance;
+    doScale: (pickRay: ParametricLine, rayStart: Vector3) => void;
+    initializeScale: (pickRay: ParametricLine, rayStart: Vector3) => void;
+    constructor(appObject: AppObject);
+}

package/lib/AppObjectComponents/SceneRoot/UC/ScaleSceneRootWithRay.js

@@ -0,0 +1,38 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ScaleSceneRootWithRay = void 0;
+const AppObjectUC_1 = require("../../../AppObject/AppObjectUC");
+const ValueObjects_1 = require("../../../ValueObjects");
+const Babylon_1 = require("../../Babylon");
+const SceneRoot_1 = require("../Entities/SceneRoot");
+class ScaleSceneRootWithRay extends AppObjectUC_1.AppObjectUC {
+    constructor(appObject) {
+        super(appObject, ScaleSceneRootWithRay.type);
+        this.sensitivity = 10;
+        this.pickPoint = ValueObjects_1.Vector3.Zero();
+        this.lastDistance = 0;
+        this.doScale = (pickRay, rayStart) => {
+            if (!this.sceneRoot)
+                return;
+            const newDistance = ValueObjects_1.Vector3.Subtract(rayStart, this.pickPoint).magnitued;
+            const distanceChange = newDistance - this.lastDistance;
+            const currentScale = this.sceneRoot.scale;
+            const scaleDelta = distanceChange * this.sensitivity * currentScale;
+            this.sceneRoot.bumpScaleAboutPoint(scaleDelta, this.pickPoint);
+            this.lastDistance = newDistance;
+        };
+        this.initializeScale = (pickRay, rayStart) => {
+            var _a;
+            const pick = Babylon_1.sceneRayPick(pickRay, this.appObjects);
+            this.pickPoint = (_a = pick === null || pick === void 0 ? void 0 : pick.worldPickPoint) !== null && _a !== void 0 ? _a : ValueObjects_1.Vector3.Zero();
+            this.lastDistance = ValueObjects_1.Vector3.Subtract(rayStart, this.pickPoint).magnitued;
+        };
+        this.appObjects = appObject.appObjectRepo;
+        this.sceneRoot = appObject.getComponent(SceneRoot_1.SceneRoot.type);
+        if (!this.sceneRoot) {
+            console.warn("ScaleSceneRootWithRay added to an app object that does not have a SceneRootEntity");
+        }
+    }
+}
+exports.ScaleSceneRootWithRay = ScaleSceneRootWithRay;
+ScaleSceneRootWithRay.type = "ScaleSceneRootWithRay";

package/lib/AppObjectComponents/StateMachine/Entities/StateMachineEntity.d.ts

@@ -0,0 +1,30 @@
+import { AppObject } from "../../../AppObject/AppObject";
+import { AppObjectEntity } from "../../../AppObject/AppObjectEntity";
+import { AppObjectRepo } from "../../../AppObject/AppObjectRepo";
+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 declare abstract class StateMachineEntity extends AppObjectEntity {
+    static readonly type = "StateMachineEntity";
+    abstract transitionEaseFunction: (normalizedTime: number) => number;
+    abstract getSerializedStates(): SerializedStates;
+    abstract setSerializedStates(state: SerializedStates, transitionTime: number): void;
+    abstract applySerializedStatesString: (state: string, duration?: number) => void;
+    abstract setDefaultState(transitionTime: number): void;
+    abstract registerSerializedSystem(serializedSystem: SerializedSystem): void;
+    static get(appObjects: AppObjectRepo): StateMachineEntity | undefined;
+}
+export declare function makeStateMachineEntity(appObject: AppObject): StateMachineEntity;

package/lib/AppObjectComponents/StateMachine/Entities/StateMachineEntity.js

@@ -0,0 +1,105 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.makeStateMachineEntity = exports.StateMachineEntity = void 0;
+const AppObjectEntity_1 = require("../../../AppObject/AppObjectEntity");
+const App_1 = require("../../App");
+class StateMachineEntity extends AppObjectEntity_1.AppObjectEntity {
+    static get(appObjects) {
+        const components = appObjects.getAllComponents(StateMachineEntity.type);
+        if (components.length === 0) {
+            App_1.submitWarning("StateMachineEntity", `Unable to find component ${StateMachineEntity.type}. Add one on Mount`, appObjects);
+            return undefined;
+        }
+        else if (components.length > 1) {
+            App_1.submitWarning("StateMachineEntity", `Multiple ${StateMachineEntity.type} found. There should only be one. Using the first one`, appObjects);
+        }
+        return components[0];
+    }
+}
+exports.StateMachineEntity = StateMachineEntity;
+StateMachineEntity.type = "StateMachineEntity";
+function makeStateMachineEntity(appObject) {
+    return new StateMachineImp(appObject);
+}
+exports.makeStateMachineEntity = makeStateMachineEntity;
+class StateMachineImp extends StateMachineEntity {
+    constructor(appObject) {
+        super(appObject, StateMachineEntity.type);
+        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);
+                    App_1.submitWarning("StateMachineEntity", `Failed to deserialize state string ${state} with Error ${e.message}`, this.appObject.appObjectRepo);
+                }
+            }
+        };
+        this.registerSerializedSystem = (serializedSystem) => {
+            if (this.serializedSystems.has(serializedSystem.name)) {
+                App_1.submitError("StateMachineEntity", `Duplicate stateable systems encountered: ${serializedSystem.name}`, this.appObject.appObjectRepo);
+                return;
+            }
+            this.serializedSystems.set(serializedSystem.name, serializedSystem);
+            return;
+        };
+        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 = (states, duration) => {
+            if (states.version === 2) {
+                const appliedToSystems = [];
+                states.systems.forEach((systemState) => {
+                    const seriliazableSystem = this.serializedSystems.get(systemState.name);
+                    if (seriliazableSystem) {
+                        seriliazableSystem.applySystemState(systemState.state, systemState.seriliziationVersion, duration);
+                    }
+                    else {
+                        App_1.submitWarning("StateMachineEntity", `Unable to find seriarializedSystem ${systemState.name}`, this.appObject.appObjectRepo);
+                    }
+                    appliedToSystems.push(systemState.name);
+                });
+                this.serializedSystems.forEach((system) => {
+                    if (!appliedToSystems.includes(system.name)) {
+                        system.applyDefaultState(duration);
+                    }
+                });
+                this.notifyOnChange();
+                return;
+            }
+            // Here is where we will add support for future versions
+            else {
+                App_1.submitError("StateMachineEntity", `Unsupported sereialized state encountered: ${states.version}`, this.appObject.appObjectRepo);
+                return;
+            }
+        };
+        this.setDefaultState = (duration) => {
+            this.serializedSystems.forEach((system) => {
+                system.applyDefaultState(duration);
+            });
+            this.notifyOnChange();
+        };
+    }
+}

package/lib/AppObjectComponents/StateMachine/index.d.ts

@@ -0,0 +1 @@
+export * from "./Entities/StateMachineEntity";

package/lib/AppObjectComponents/StateMachine/index.js

@@ -0,0 +1,13 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    Object.defineProperty(o, k2, { enumerable: true, get: function() { return m[k]; } });
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./Entities/StateMachineEntity"), exports);

package/lib/AppObjectComponents/Tools/Controller/ToolHotkeys.d.ts

@@ -0,0 +1,9 @@
+import { AppObject } from "../../../AppObject/AppObject";
+import { AppObjectController } from "../../../AppObject/AppObjectController";
+import { KeyboardController } from "../../KeyboardInput";
+export declare class ToolHotkeys<ToolTypes> extends AppObjectController implements KeyboardController {
+    static readonly type = "ToolHotkeys";
+    private toolRepo?;
+    onKeyDown: (e: KeyboardEvent) => void;
+    constructor(appObject: AppObject);
+}

package/lib/AppObjectComponents/Tools/Controller/ToolHotkeys.js

@@ -0,0 +1,43 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ToolHotkeys = void 0;
+const __1 = require("../..");
+const AppObjectController_1 = require("../../../AppObject/AppObjectController");
+const KeyboardInput_1 = require("../../KeyboardInput");
+const ToolRepository_1 = require("../Entities/ToolRepository");
+class ToolHotkeys extends AppObjectController_1.AppObjectController {
+    constructor(appObject) {
+        super(appObject, ToolHotkeys.type);
+        this.onKeyDown = (e) => {
+            if (!this.toolRepo)
+                return;
+            if (e.repeat)
+                return;
+            const currentKey = {
+                keyCode: e.code,
+                alt: e.altKey,
+                control: e.ctrlKey,
+                meta: e.metaKey,
+                shift: e.shiftKey,
+            };
+            const tool = this.toolRepo.getToolForHotkey(currentKey);
+            if (!tool)
+                return;
+            this.toolRepo.triggerTool(tool.toolType);
+        };
+        this.toolRepo = appObject.getComponent(ToolRepository_1.ToolRepository.type);
+        if (!this.toolRepo) {
+            __1.submitWarning("ToolHotkeys", "Controller has been added to an App Object that does not have ToolRepository. Add one first.", appObject.appObjectRepo);
+            return;
+        }
+        const keyboardInput = KeyboardInput_1.KeyboardInputEntity.get(appObject.appObjectRepo);
+        if (keyboardInput) {
+            keyboardInput.registerController(this);
+        }
+        else {
+            __1.submitWarning("ToolHotkeys", "Unable to find KeyboardInputEntity", appObject.appObjectRepo);
+        }
+    }
+}
+exports.ToolHotkeys = ToolHotkeys;
+ToolHotkeys.type = "ToolHotkeys";

package/lib/AppObjectComponents/Tools/Controller/triggerTool.d.ts

@@ -0,0 +1,2 @@
+import { AppObjectRepo } from "../../../AppObject/AppObjectRepo";
+export declare function triggerTool<ToolTypes>(toolType: ToolTypes, appObjects: AppObjectRepo): void;