@vived/app 3.8.0 → 3.9.1

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

@@ -0,0 +1,14 @@
+import { AppObject } from "../../../AppObject/AppObject";
+import { AppObjectController } from "../../../AppObject/AppObjectController";
+import { MouseController, MouseInputEvent } from "../../MouseInput";
+export declare class MouseScale extends AppObjectController implements MouseController {
+    static readonly type = "MouseScale";
+    private isDollying;
+    private appObjects;
+    private dragScaleRootUC?;
+    allow: (e: MouseInputEvent) => boolean;
+    onDown: (e: MouseInputEvent) => void;
+    onMove: (e: MouseInputEvent) => void;
+    onUp: () => void;
+    constructor(appObject: AppObject);
+}

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

@@ -0,0 +1,51 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MouseScale = void 0;
+const AppObjectController_1 = require("../../../AppObject/AppObjectController");
+const App_1 = require("../../App");
+const MouseInput_1 = require("../../MouseInput");
+const DragScaleSceneRoot_1 = require("../UC/DragScaleSceneRoot");
+class MouseScale extends AppObjectController_1.AppObjectController {
+    constructor(appObject) {
+        super(appObject, MouseScale.type);
+        this.isDollying = false;
+        this.allow = (e) => {
+            return true;
+        };
+        this.onDown = (e) => {
+            var _a;
+            this.isDollying = false;
+            if (!this.allow(e))
+                return;
+            const pixelPosition = e.position;
+            (_a = this.dragScaleRootUC) === null || _a === void 0 ? void 0 : _a.initializeScale(pixelPosition);
+            this.isDollying = true;
+        };
+        this.onMove = (e) => {
+            var _a;
+            if (!this.isDollying)
+                return;
+            (_a = this.dragScaleRootUC) === null || _a === void 0 ? void 0 : _a.doScale(e.position);
+        };
+        this.onUp = () => {
+            var _a;
+            this.isDollying = false;
+            (_a = this.dragScaleRootUC) === null || _a === void 0 ? void 0 : _a.finishScaling();
+        };
+        this.appObjects = appObject.appObjectRepo;
+        this.dragScaleRootUC = appObject.getComponent(DragScaleSceneRoot_1.DragScaleSceneRootUC.type);
+        if (!this.dragScaleRootUC) {
+            App_1.submitWarning("MouseScale", "Controller has been added to an App Object that does not have DragScaleSceneRootUC. Add one first.", this.appObjects);
+            return;
+        }
+        const mouseInput = MouseInput_1.MouseInputEntity.get(this.appObjects);
+        if (mouseInput) {
+            mouseInput.registerController(this);
+        }
+        else {
+            App_1.submitWarning("MouseScale ", "Unable to find MouseInputEntity", this.appObjects);
+        }
+    }
+}
+exports.MouseScale = MouseScale;
+MouseScale.type = "MouseScale";

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

@@ -0,0 +1,13 @@
+import { AppObject } from "../../../AppObject/AppObject";
+import { AppObjectController } from "../../../AppObject/AppObjectController";
+import { TouchController, TouchInputEvent } from "../../TouchController";
+export declare class TouchOrbit extends AppObjectController implements TouchController {
+    static readonly type = "TouchOrbit";
+    private isOrbiting;
+    private orbitSceneRoot?;
+    allow: (e: TouchInputEvent) => boolean;
+    onTouchStart: (e: TouchInputEvent) => void;
+    onTouchMove: (e: TouchInputEvent) => void;
+    onTouchEnd: () => void;
+    constructor(appObject: AppObject);
+}

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

@@ -0,0 +1,52 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TouchOrbit = void 0;
+const AppObjectController_1 = require("../../../AppObject/AppObjectController");
+const App_1 = require("../../App");
+const TouchController_1 = require("../../TouchController");
+const OrbitSceneRoot_1 = require("../UC/OrbitSceneRoot");
+class TouchOrbit extends AppObjectController_1.AppObjectController {
+    constructor(appObject) {
+        super(appObject, TouchOrbit.type);
+        this.isOrbiting = false;
+        this.allow = (e) => {
+            return true;
+        };
+        this.onTouchStart = (e) => {
+            var _a, _b;
+            if (!this.allow(e)) {
+                this.isOrbiting = false;
+                (_a = this.orbitSceneRoot) === null || _a === void 0 ? void 0 : _a.cancelOrbit();
+                return;
+            }
+            (_b = this.orbitSceneRoot) === null || _b === void 0 ? void 0 : _b.initializeOrbit(e.touchCenter);
+            this.isOrbiting = true;
+        };
+        this.onTouchMove = (e) => {
+            var _a;
+            if (!this.isOrbiting)
+                return;
+            (_a = this.orbitSceneRoot) === null || _a === void 0 ? void 0 : _a.doOrbit(e.touchCenter);
+        };
+        this.onTouchEnd = () => {
+            var _a;
+            this.isOrbiting = false;
+            (_a = this.orbitSceneRoot) === null || _a === void 0 ? void 0 : _a.finishOrbit();
+        };
+        const appObjects = appObject.appObjectRepo;
+        this.orbitSceneRoot = appObject.getComponent(OrbitSceneRoot_1.OrbitSceneRootUC.type);
+        if (!this.orbitSceneRoot) {
+            App_1.submitWarning("TouchOrbit", "Controller has been added to an App Object that does not have OrbitSceneRootUC. Add one first.", appObjects);
+            return;
+        }
+        const touchInput = TouchController_1.TouchInputEntity.get(appObjects);
+        if (touchInput) {
+            touchInput.registerController(this);
+        }
+        else {
+            App_1.submitWarning("TouchOrbit ", "Unable to find TouchInputEntity", appObjects);
+        }
+    }
+}
+exports.TouchOrbit = TouchOrbit;
+TouchOrbit.type = "TouchOrbit";

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

@@ -0,0 +1,13 @@
+import { AppObject } from "../../../AppObject/AppObject";
+import { AppObjectController } from "../../../AppObject/AppObjectController";
+import { TouchController, TouchInputEvent } from "../../TouchController";
+export declare class TouchPan extends AppObjectController implements TouchController {
+    static readonly type = "TouchPan";
+    private isPanning;
+    private panRootUC?;
+    allow: (e: TouchInputEvent) => boolean;
+    onTouchStart: (e: TouchInputEvent) => void;
+    onTouchMove: (e: TouchInputEvent) => void;
+    onTouchEnd: (e: TouchInputEvent) => void;
+    constructor(appObject: AppObject);
+}

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

@@ -0,0 +1,53 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TouchPan = void 0;
+const AppObjectController_1 = require("../../../AppObject/AppObjectController");
+const App_1 = require("../../App");
+const TouchController_1 = require("../../TouchController");
+const PanSceneRoot_1 = require("../UC/PanSceneRoot");
+class TouchPan extends AppObjectController_1.AppObjectController {
+    constructor(appObject) {
+        super(appObject, TouchPan.type);
+        this.isPanning = false;
+        this.allow = (e) => {
+            return true;
+        };
+        this.onTouchStart = (e) => {
+            var _a, _b;
+            if (!this.allow(e)) {
+                this.isPanning = false;
+                (_a = this.panRootUC) === null || _a === void 0 ? void 0 : _a.cancelPan();
+                return;
+            }
+            (_b = this.panRootUC) === null || _b === void 0 ? void 0 : _b.initializePan(e.touchCenter);
+            this.isPanning = true;
+        };
+        this.onTouchMove = (e) => {
+            var _a;
+            if (!this.isPanning)
+                return;
+            const pixelPosition = e.touches[0].position;
+            (_a = this.panRootUC) === null || _a === void 0 ? void 0 : _a.doPan(pixelPosition);
+        };
+        this.onTouchEnd = (e) => {
+            var _a;
+            this.isPanning = false;
+            (_a = this.panRootUC) === null || _a === void 0 ? void 0 : _a.finishPan();
+        };
+        const appObjects = appObject.appObjectRepo;
+        this.panRootUC = appObject.getComponent(PanSceneRoot_1.PanSceneRootUC.type);
+        if (!this.panRootUC) {
+            App_1.submitWarning("TouchPan", "Controller has been added to an App Object that does not have PanSceneRootUC. Add one first.", appObjects);
+            return;
+        }
+        const touchInput = TouchController_1.TouchInputEntity.get(appObjects);
+        if (touchInput) {
+            touchInput.registerController(this);
+        }
+        else {
+            App_1.submitWarning("TouchPan ", "Unable to find TouchInputEntity", appObjects);
+        }
+    }
+}
+exports.TouchPan = TouchPan;
+TouchPan.type = "TouchPan";

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

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

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

@@ -0,0 +1,56 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TouchPinch = void 0;
+const AppObjectController_1 = require("../../../AppObject/AppObjectController");
+const App_1 = require("../../App");
+const TouchController_1 = require("../../TouchController");
+const PinchSceneRoot_1 = require("../UC/PinchSceneRoot");
+class TouchPinch extends AppObjectController_1.AppObjectController {
+    constructor(appObject) {
+        super(appObject, TouchPinch.type);
+        this.isPinching = false;
+        this.allow = (e) => {
+            return true;
+        };
+        this.onTouchStart = (e) => {
+            var _a;
+            this.isPinching = false;
+            if (e.touches.length !== 2) {
+                return;
+            }
+            if (!this.allow(e)) {
+                return;
+            }
+            (_a = this.pinchRootUC) === null || _a === void 0 ? void 0 : _a.initializePinch(e.touches[0].position, e.touches[1].position);
+            this.isPinching = true;
+        };
+        this.onTouchMove = (e) => {
+            var _a;
+            if (!this.isPinching)
+                return;
+            if (e.touches.length !== 2)
+                return;
+            (_a = this.pinchRootUC) === null || _a === void 0 ? void 0 : _a.doPinch(e.touches[0].position, e.touches[1].position);
+        };
+        this.onTouchEnd = () => {
+            var _a;
+            this.isPinching = false;
+            (_a = this.pinchRootUC) === null || _a === void 0 ? void 0 : _a.finishPinch();
+        };
+        const appObjects = appObject.appObjectRepo;
+        this.pinchRootUC = appObject.getComponent(PinchSceneRoot_1.PinchSceneRootUC.type);
+        if (!this.pinchRootUC) {
+            App_1.submitWarning("TouchPinch", "Controller has been added to an App Object that does not have PinchSceneRootUC. Add one first.", appObjects);
+            return;
+        }
+        const touchInput = TouchController_1.TouchInputEntity.get(appObjects);
+        if (touchInput) {
+            touchInput.registerController(this);
+        }
+        else {
+            App_1.submitWarning("TouchPinch ", "Unable to find TouchInputEntity", appObjects);
+        }
+    }
+}
+exports.TouchPinch = TouchPinch;
+TouchPinch.type = "TouchPinch";

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;