@vived/app 3.8.0 → 3.9.0

package/lib/AppObjectComponents/SceneRoot/Controllers/TouchScale.d.ts

@@ -0,0 +1,14 @@
+import { AppObject } from "../../../AppObject/AppObject";
+import { AppObjectController } from "../../../AppObject/AppObjectController";
+import { TouchController, TouchInputEvent } from "../../TouchController";
+import { DragScaleSceneRootUC } from "../UC/DragScaleSceneRoot";
+export declare class TouchScale extends AppObjectController implements TouchController {
+    static readonly type = "TouchScale";
+    private isScaling;
+    dragScaleRootUC?: DragScaleSceneRootUC;
+    allow: (e: TouchInputEvent) => boolean;
+    onTouchStart: (e: TouchInputEvent) => void;
+    onTouchMove: (e: TouchInputEvent) => void;
+    onTouchEnd: () => void;
+    constructor(appObject: AppObject);
+}

package/lib/AppObjectComponents/SceneRoot/Controllers/TouchScale.js

@@ -0,0 +1,57 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TouchScale = void 0;
+const AppObjectController_1 = require("../../../AppObject/AppObjectController");
+const App_1 = require("../../App");
+const TouchController_1 = require("../../TouchController");
+const DragScaleSceneRoot_1 = require("../UC/DragScaleSceneRoot");
+class TouchScale extends AppObjectController_1.AppObjectController {
+    constructor(appObject) {
+        super(appObject, TouchScale.type);
+        this.isScaling = false;
+        this.allow = (e) => {
+            return true;
+        };
+        this.onTouchStart = (e) => {
+            var _a;
+            this.isScaling = false;
+            if (e.touches.length !== 1) {
+                return;
+            }
+            if (!this.allow(e)) {
+                return;
+            }
+            const pixelPosition = e.touches[0].position;
+            (_a = this.dragScaleRootUC) === null || _a === void 0 ? void 0 : _a.initializeScale(pixelPosition);
+            this.isScaling = true;
+        };
+        this.onTouchMove = (e) => {
+            var _a;
+            if (!this.isScaling)
+                return;
+            if (e.touches.length !== 1)
+                return;
+            const pixelPosition = e.touches[0].position;
+            (_a = this.dragScaleRootUC) === null || _a === void 0 ? void 0 : _a.doScale(pixelPosition);
+        };
+        this.onTouchEnd = () => {
+            var _a;
+            this.isScaling = false;
+            (_a = this.dragScaleRootUC) === null || _a === void 0 ? void 0 : _a.finishScaling();
+        };
+        const appObjects = appObject.appObjectRepo;
+        this.dragScaleRootUC = DragScaleSceneRoot_1.DragScaleSceneRootUC.get(appObjects);
+        if (!this.dragScaleRootUC) {
+            App_1.submitWarning("TouchScale", "Unable to finde DragScaleSceneRootUC", appObjects);
+        }
+        const touchInput = TouchController_1.TouchInputEntity.get(appObjects);
+        if (touchInput) {
+            touchInput.registerController(this);
+        }
+        else {
+            App_1.submitWarning("TouchOrbit ", "Unable to find TouchInputEntity", appObjects);
+        }
+    }
+}
+exports.TouchScale = TouchScale;
+TouchScale.type = "TouchScale";

package/lib/AppObjectComponents/SceneRoot/Factory/setupSceneRoot.d.ts

@@ -0,0 +1,3 @@
+import { AppObjectRepo } from "../../../AppObject/AppObjectRepo";
+import { SceneRoot } from "../Entities/SceneRoot";
+export declare function setupSceneRoot(appObjects: AppObjectRepo): SceneRoot;

package/lib/AppObjectComponents/SceneRoot/Factory/setupSceneRoot.js

@@ -0,0 +1,28 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.setupSceneRoot = void 0;
+const Transform3D_1 = require("../../Transform3D");
+const SceneRoot_1 = require("../Entities/SceneRoot");
+const BumpSceneRootScaleAboutPixelPoint_1 = require("../UC/BumpSceneRootScaleAboutPixelPoint");
+const CenterSceneRootOnPixelPick_1 = require("../UC/CenterSceneRootOnPixelPick");
+const DragScaleSceneRoot_1 = require("../UC/DragScaleSceneRoot");
+const FocusOnPixel_1 = require("../UC/FocusOnPixel");
+const OrbitSceneRoot_1 = require("../UC/OrbitSceneRoot");
+const PanSceneRoot_1 = require("../UC/PanSceneRoot");
+const PinchSceneRoot_1 = require("../UC/PinchSceneRoot");
+const ScaleSceneRootWithRay_1 = require("../UC/ScaleSceneRootWithRay");
+function setupSceneRoot(appObjects) {
+    const sceneRootAO = appObjects.getOrCreate(SceneRoot_1.SceneRoot.type);
+    const sceneRoot = SceneRoot_1.makeSceneRoot(sceneRootAO);
+    BumpSceneRootScaleAboutPixelPoint_1.makeBumpSceneRootScaleAboutPixelPointUC(sceneRootAO);
+    CenterSceneRootOnPixelPick_1.makeCenterSceneRootOnPixelPickUC(sceneRootAO);
+    DragScaleSceneRoot_1.makeDragScaleSceneRootUC(sceneRootAO);
+    FocusOnPixel_1.makeFocusOnPixelUC(sceneRootAO);
+    OrbitSceneRoot_1.makeOrbitSceneRootUC(sceneRootAO);
+    PanSceneRoot_1.makePanSceneRootUC(sceneRootAO);
+    PinchSceneRoot_1.makePinchSceneRootUC(sceneRootAO);
+    new Transform3D_1.Transform3DPM(sceneRootAO);
+    new ScaleSceneRootWithRay_1.ScaleSceneRootWithRay(sceneRootAO);
+    return sceneRoot;
+}
+exports.setupSceneRoot = setupSceneRoot;

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

@@ -0,0 +1,11 @@
+import { AppObject } from "../../../AppObject/AppObject";
+import { AppObjectRepo } from "../../../AppObject/AppObjectRepo";
+import { AppObjectUC } from "../../../AppObject/AppObjectUC";
+import { Vector2 } from "../../../ValueObjects";
+export declare abstract class BumpSceneRootScaleAboutPixelPointUC extends AppObjectUC {
+    static readonly type = "BumpSceneRootScaleAboutPixelPoint";
+    abstract allow(): boolean;
+    abstract bump(direction: "IN" | "OUT", pixelPosition: Vector2): void;
+    static get(appObjects: AppObjectRepo): BumpSceneRootScaleAboutPixelPointUC | undefined;
+}
+export declare function makeBumpSceneRootScaleAboutPixelPointUC(appObject: AppObject): BumpSceneRootScaleAboutPixelPointUC;

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

@@ -0,0 +1,60 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.makeBumpSceneRootScaleAboutPixelPointUC = exports.BumpSceneRootScaleAboutPixelPointUC = 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 BumpSceneRootScaleAboutPixelPointUC extends AppObjectUC_1.AppObjectUC {
+    static get(appObjects) {
+        const selectionEntities = appObjects.getAllComponents(BumpSceneRootScaleAboutPixelPointUC.type);
+        if (selectionEntities.length === 0) {
+            App_1.submitWarning(BumpSceneRootScaleAboutPixelPointUC.type, `Unable to find component ${BumpSceneRootScaleAboutPixelPointUC.type}. Add one on Mount`, appObjects);
+            return undefined;
+        }
+        else if (selectionEntities.length > 1) {
+            App_1.submitWarning(BumpSceneRootScaleAboutPixelPointUC.type, `Multiple ${BumpSceneRootScaleAboutPixelPointUC.type} found. There should only be one. Using the first one`, appObjects);
+        }
+        return selectionEntities[0];
+    }
+}
+exports.BumpSceneRootScaleAboutPixelPointUC = BumpSceneRootScaleAboutPixelPointUC;
+BumpSceneRootScaleAboutPixelPointUC.type = "BumpSceneRootScaleAboutPixelPoint";
+function makeBumpSceneRootScaleAboutPixelPointUC(appObject) {
+    return new BumpSceneRootScaleAboutPixelPointImp(appObject);
+}
+exports.makeBumpSceneRootScaleAboutPixelPointUC = makeBumpSceneRootScaleAboutPixelPointUC;
+class BumpSceneRootScaleAboutPixelPointImp extends BumpSceneRootScaleAboutPixelPointUC {
+    constructor(appObject) {
+        super(appObject, BumpSceneRootScaleAboutPixelPointUC.type);
+        this.sensitivity = 0.1;
+        this.allow = () => {
+            return true;
+        };
+        this.bump = (direction, pixelPosition) => {
+            var _a;
+            if (!this.sceneRoot)
+                return;
+            if (!this.allow())
+                return;
+            let bumpDirection = -1;
+            if (direction === "IN") {
+                bumpDirection = 1;
+            }
+            const currentScale = this.sceneRoot.scale;
+            const scaleDelta = bumpDirection * this.sensitivity * currentScale;
+            const pick = Babylon_1.scenePixelPick(pixelPosition, this.appObjects);
+            const pickPoint = (_a = pick === null || pick === void 0 ? void 0 : pick.worldPickPoint) !== null && _a !== void 0 ? _a : ValueObjects_1.Vector3.Zero();
+            this.sceneRoot.bumpScaleAboutPoint(scaleDelta, pickPoint);
+            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/CenterSceneRootOnPixelPick.d.ts

@@ -0,0 +1,14 @@
+import { AppObject } from "../../../AppObject/AppObject";
+import { AppObjectRepo } from "../../../AppObject/AppObjectRepo";
+import { AppObjectUC } from "../../../AppObject/AppObjectUC";
+import { EaseFn } from "../../../Types";
+import { Vector2 } from "../../../ValueObjects";
+export declare abstract class CenterSceneRootOnPixelPickUC extends AppObjectUC {
+    static readonly type = "CenterSceneRootOnPixelPickUC";
+    abstract durationMS: number;
+    abstract easeFn: EaseFn;
+    abstract centerOnPixel: (pixel: Vector2) => void;
+    static get(appObjects: AppObjectRepo): CenterSceneRootOnPixelPickUC | undefined;
+}
+export declare function makeCenterSceneRootOnPixelPickUC(appObject: AppObject): CenterSceneRootOnPixelPickUC;
+export declare function centerOnPixel(pixel: Vector2, appObjects: AppObjectRepo): void;

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

@@ -0,0 +1,62 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.centerOnPixel = exports.makeCenterSceneRootOnPixelPickUC = exports.CenterSceneRootOnPixelPickUC = 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 CenterSceneRootOnPixelPickUC extends AppObjectUC_1.AppObjectUC {
+    static get(appObjects) {
+        const components = appObjects.getAllComponents(CenterSceneRootOnPixelPickUC.type);
+        if (components.length === 0) {
+            App_1.submitWarning(CenterSceneRootOnPixelPickUC.type, `Unable to find component ${CenterSceneRootOnPixelPickUC.type}. Add one on Mount`, appObjects);
+            return undefined;
+        }
+        else if (components.length > 1) {
+            App_1.submitWarning(CenterSceneRootOnPixelPickUC.type, `Multiple ${CenterSceneRootOnPixelPickUC.type} found. There should only be one. Using the first one`, appObjects);
+        }
+        return components[0];
+    }
+}
+exports.CenterSceneRootOnPixelPickUC = CenterSceneRootOnPixelPickUC;
+CenterSceneRootOnPixelPickUC.type = "CenterSceneRootOnPixelPickUC";
+function makeCenterSceneRootOnPixelPickUC(appObject) {
+    return new CenterSceneRootOnPixelPickImp(appObject);
+}
+exports.makeCenterSceneRootOnPixelPickUC = makeCenterSceneRootOnPixelPickUC;
+class CenterSceneRootOnPixelPickImp extends CenterSceneRootOnPixelPickUC {
+    constructor(appObject) {
+        super(appObject, CenterSceneRootOnPixelPickUC.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))
+                return;
+            this.sceneRoot.centerOnPoint(scenePick.worldPickPoint, 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;
+        }
+    }
+}
+function centerOnPixel(pixel, appObjects) {
+    const uc = CenterSceneRootOnPixelPickUC.get(appObjects);
+    if (!uc) {
+        App_1.submitWarning("centerOnPixel", "Unable to find CenterSceneRootOnPixelPickUC", appObjects);
+        return;
+    }
+    return uc.centerOnPixel(pixel);
+}
+exports.centerOnPixel = centerOnPixel;

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

@@ -0,0 +1,12 @@
+import { AppObject } from "../../../AppObject/AppObject";
+import { AppObjectRepo } from "../../../AppObject/AppObjectRepo";
+import { AppObjectUC } from "../../../AppObject/AppObjectUC";
+import { Vector2 } from "../../../ValueObjects";
+export declare abstract class DragScaleSceneRootUC extends AppObjectUC {
+    static readonly type = "DragScaleSceneRootUC";
+    abstract doScale: (pixel: Vector2) => void;
+    abstract initializeScale: (pixel: Vector2) => void;
+    abstract finishScaling: () => void;
+    static get(appObjects: AppObjectRepo): DragScaleSceneRootUC | undefined;
+}
+export declare function makeDragScaleSceneRootUC(appObject: AppObject): DragScaleSceneRootUC;

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

@@ -0,0 +1,74 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.makeDragScaleSceneRootUC = exports.DragScaleSceneRootUC = 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 DragScaleSceneRootUC extends AppObjectUC_1.AppObjectUC {
+    static get(appObjects) {
+        const components = appObjects.getAllComponents(DragScaleSceneRootUC.type);
+        if (components.length === 0) {
+            App_1.submitWarning(DragScaleSceneRootUC.type, `Unable to find component ${DragScaleSceneRootUC.type}. Add one on Mount`, appObjects);
+            return undefined;
+        }
+        else if (components.length > 1) {
+            App_1.submitWarning(DragScaleSceneRootUC.type, `Multiple ${DragScaleSceneRootUC.type} found. There should only be one. Using the first one`, appObjects);
+        }
+        return components[0];
+    }
+}
+exports.DragScaleSceneRootUC = DragScaleSceneRootUC;
+DragScaleSceneRootUC.type = "DragScaleSceneRootUC";
+function makeDragScaleSceneRootUC(appObject) {
+    return new DragScaleSceneRootImp(appObject);
+}
+exports.makeDragScaleSceneRootUC = makeDragScaleSceneRootUC;
+class DragScaleSceneRootImp extends DragScaleSceneRootUC {
+    constructor(appObject) {
+        super(appObject, DragScaleSceneRootUC.type);
+        this.sensitivity = 0.01;
+        this.lastPixelPos = ValueObjects_1.Vector2.Zero();
+        this.pickPoint = ValueObjects_1.Vector3.Zero();
+        this.initialScale = 1;
+        this.isScaling = false;
+        this.doScale = (pixelPosition) => {
+            if (!this.sceneRoot)
+                return;
+            if (!this.isScaling)
+                return;
+            const pixelChange = ValueObjects_1.Vector2.Subtract(pixelPosition, this.lastPixelPos);
+            const currentScale = this.sceneRoot.scale;
+            const scaleDelta = pixelChange.y * this.sensitivity * currentScale;
+            this.sceneRoot.bumpScaleAboutPoint(scaleDelta, this.pickPoint);
+            this.lastPixelPos = pixelPosition;
+        };
+        this.initializeScale = (initialPixelPos) => {
+            var _a;
+            if (!this.sceneRoot)
+                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.initialScale = this.sceneRoot.scale;
+            this.isScaling = true;
+        };
+        this.finishScaling = () => {
+            if (!this.sceneRoot)
+                return;
+            if (!this.isScaling)
+                return;
+            if (this.initialScale !== this.sceneRoot.scale) {
+                Dispatcher_1.dispatchStateChange(this.appObjects);
+            }
+            this.isScaling = false;
+        };
+        this.appObjects = appObject.appObjectRepo;
+        this.sceneRoot = appObject.getComponent(SceneRoot_1.SceneRoot.type);
+        if (!this.sceneRoot) {
+            App_1.submitWarning("DragScaleSceneRootImp", "DragScaleSceneRootImp UC has been added to an App Object that does not have a SceneRoot Entity", this.appObjects);
+        }
+    }
+}

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

@@ -0,0 +1,13 @@
+import { AppObject } from "../../../AppObject/AppObject";
+import { AppObjectRepo } from "../../../AppObject/AppObjectRepo";
+import { AppObjectUC } from "../../../AppObject/AppObjectUC";
+import { EaseFn } from "../../../Types";
+import { Vector2 } from "../../../ValueObjects";
+export declare abstract class FocusOnPixelUC extends AppObjectUC {
+    static readonly type = "FocusOnPixelUC";
+    abstract durationMS: number;
+    abstract easeFn: EaseFn;
+    abstract centerOnPixel: (pixel: Vector2) => void;
+    static get(appObjects: AppObjectRepo): FocusOnPixelUC | undefined;
+}
+export declare function makeFocusOnPixelUC(appObject: AppObject): FocusOnPixelUC;

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;