@vived/app 3.9.1 → 4.0.0

package/lib/Components/SceneRoot/Entities/SceneRootEntity.js

@@ -0,0 +1,104 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.makeSceneRootEntity = exports.SceneRootEntity = void 0;
+const AppObject_1 = require("../../../AppObject");
+const AppObjectEntity_1 = require("../../../AppObject/AppObjectEntity");
+const ValueObjects_1 = require("../../../ValueObjects");
+const Transform3D_1 = require("../../Transform3D");
+class SceneRootEntity extends AppObjectEntity_1.AppObjectEntity {
+}
+exports.SceneRootEntity = SceneRootEntity;
+SceneRootEntity.type = "SCENE_ROOT_ENTITY";
+SceneRootEntity.get = (appObjects) => AppObject_1.getSingletonComponent(SceneRootEntity.type, appObjects);
+function makeSceneRootEntity(appObj) {
+    return new SceneRootImp(appObj);
+}
+exports.makeSceneRootEntity = makeSceneRootEntity;
+class SceneRootImp extends SceneRootEntity {
+    constructor(appObject) {
+        super(appObject, SceneRootEntity.type);
+        this._defaultPosition = ValueObjects_1.Vector3.Zero();
+        this._defaultRotation = ValueObjects_1.Quaternion.Identity();
+        this._defaultScale = 1;
+        this._minScale = 0.01;
+        this._maxScale = 10;
+        this.applyDefaultData = (data) => {
+            this._defaultPosition = ValueObjects_1.Vector3.FromArray(data.position);
+            this._defaultRotation = ValueObjects_1.Quaternion.FromArray(data.rotation);
+            this._defaultScale = data.scale;
+            this._maxScale = data.maxScale;
+            this._minScale = data.minScale;
+        };
+        this.centerOnPoint = (point, durationMS, easeFn, onCompleted) => {
+            const finalPosition = ValueObjects_1.Vector3.Subtract(this.transform.worldPosition, point);
+            const lerpDTO = {
+                durationMS,
+                ease: easeFn,
+                desiredPosition: finalPosition,
+                onCompletedCallback: onCompleted,
+            };
+            this.transform.lerp(lerpDTO);
+        };
+        this.bumpScaleAboutPoint = (amount, worldPoint) => {
+            const localPickOffset = this.transform.worldPointToLocal(worldPoint);
+            const currentScale = this.transform.worldScale.x;
+            let newScale = currentScale + amount;
+            if (newScale < this.minScale) {
+                newScale = this.minScale;
+            }
+            else if (newScale > this.maxScale) {
+                newScale = this.maxScale;
+            }
+            this.transform.worldScale = new ValueObjects_1.Vector3(newScale, newScale, newScale);
+            const worldPickOffset = this.transform.localPointToWorld(localPickOffset);
+            const bump = ValueObjects_1.Vector3.Subtract(worldPoint, worldPickOffset);
+            this.transform.worldPosition = ValueObjects_1.Vector3.Add(bump, this.transform.worldPosition);
+        };
+        this.lerpToDefault = (durationMS, easeFn, onCompleted) => {
+            const lerpDTO = {
+                durationMS,
+                ease: easeFn,
+                desiredPosition: this.defaultPosition,
+                desiredRotation: this.defaultRotation,
+                desiredScale: new ValueObjects_1.Vector3(this.defaultScale, this.defaultScale, this.defaultScale),
+                onCompletedCallback: onCompleted,
+            };
+            this.transform.lerp(lerpDTO);
+        };
+        this.transform = Transform3D_1.Transform3D.addIfMissing(appObject);
+        this.transform.addChangeObserver(this.notifyOnChange);
+    }
+    get position() {
+        return this.transform.localPosition;
+    }
+    set position(p) {
+        this.transform.localPosition = p;
+    }
+    get rotation() {
+        return this.transform.localRotation;
+    }
+    set rotation(r) {
+        this.transform.localRotation = r;
+    }
+    get scale() {
+        return this.transform.localScale.x;
+    }
+    set scale(s) {
+        this.transform.localScale = new ValueObjects_1.Vector3(s, s, s);
+    }
+    get defaultPosition() {
+        return this._defaultPosition;
+    }
+    get defaultRotation() {
+        return this._defaultRotation;
+    }
+    get defaultScale() {
+        return this._defaultScale;
+    }
+    get minScale() {
+        return this._minScale;
+    }
+    get maxScale() {
+        return this._maxScale;
+    }
+}

package/lib/Components/SceneRoot/Entities/index.d.ts

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

package/lib/Components/SceneRoot/Entities/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("./SceneRootEntity"), exports);

package/lib/Components/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/Components/SceneRoot/UC/BumpSceneRootScaleAboutPixelPoint.js

@@ -0,0 +1,49 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.makeBumpSceneRootScaleAboutPixelPointUC = exports.BumpSceneRootScaleAboutPixelPointUC = void 0;
+const AppObject_1 = require("../../../AppObject");
+const AppObjectUC_1 = require("../../../AppObject/AppObjectUC");
+const ValueObjects_1 = require("../../../ValueObjects");
+const Babylon_1 = require("../../Babylon");
+const Dispatcher_1 = require("../../Dispatcher");
+const SceneRootEntity_1 = require("../Entities/SceneRootEntity");
+class BumpSceneRootScaleAboutPixelPointUC extends AppObjectUC_1.AppObjectUC {
+}
+exports.BumpSceneRootScaleAboutPixelPointUC = BumpSceneRootScaleAboutPixelPointUC;
+BumpSceneRootScaleAboutPixelPointUC.type = "BumpSceneRootScaleAboutPixelPoint";
+BumpSceneRootScaleAboutPixelPointUC.get = (appObjects) => AppObject_1.getSingletonComponent(BumpSceneRootScaleAboutPixelPointUC.type, appObjects);
+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.sceneRoot = appObject.getComponent(SceneRootEntity_1.SceneRootEntity.type);
+        if (!this.sceneRoot) {
+            this.warn("BumpSceneRootScaleAboutPixelPointImp UC has been added to an App Object that does not have a SceneRoot Entity");
+            return;
+        }
+    }
+}

package/lib/Components/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/Components/SceneRoot/UC/CenterSceneRootOnPixelPick.js

@@ -0,0 +1,51 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.centerOnPixel = exports.makeCenterSceneRootOnPixelPickUC = exports.CenterSceneRootOnPixelPickUC = void 0;
+const AppObject_1 = require("../../../AppObject");
+const AppObjectUC_1 = require("../../../AppObject/AppObjectUC");
+const Babylon_1 = require("../../Babylon");
+const Dispatcher_1 = require("../../Dispatcher");
+const SceneRootEntity_1 = require("../Entities/SceneRootEntity");
+class CenterSceneRootOnPixelPickUC extends AppObjectUC_1.AppObjectUC {
+}
+exports.CenterSceneRootOnPixelPickUC = CenterSceneRootOnPixelPickUC;
+CenterSceneRootOnPixelPickUC.type = "CenterSceneRootOnPixelPickUC";
+CenterSceneRootOnPixelPickUC.get = (appObjects) => AppObject_1.getSingletonComponent(CenterSceneRootOnPixelPickUC.type, appObjects);
+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.sceneRoot = appObject.getComponent(SceneRootEntity_1.SceneRootEntity.type);
+        if (!this.sceneRoot) {
+            this.warn("BumpSceneRootScaleAboutPixelPointImp UC has been added to an App Object that does not have a SceneRoot Entity");
+            return;
+        }
+    }
+}
+function centerOnPixel(pixel, appObjects) {
+    const uc = CenterSceneRootOnPixelPickUC.get(appObjects);
+    if (!uc) {
+        appObjects.submitWarning("centerOnPixel", "Unable to find CenterSceneRootOnPixelPickUC");
+        return;
+    }
+    return uc.centerOnPixel(pixel);
+}
+exports.centerOnPixel = centerOnPixel;

package/lib/Components/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/Components/SceneRoot/UC/DragScaleSceneRoot.js

@@ -0,0 +1,63 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.makeDragScaleSceneRootUC = exports.DragScaleSceneRootUC = void 0;
+const AppObject_1 = require("../../../AppObject");
+const AppObjectUC_1 = require("../../../AppObject/AppObjectUC");
+const ValueObjects_1 = require("../../../ValueObjects");
+const Babylon_1 = require("../../Babylon");
+const Dispatcher_1 = require("../../Dispatcher");
+const SceneRootEntity_1 = require("../Entities/SceneRootEntity");
+class DragScaleSceneRootUC extends AppObjectUC_1.AppObjectUC {
+}
+exports.DragScaleSceneRootUC = DragScaleSceneRootUC;
+DragScaleSceneRootUC.type = "DragScaleSceneRootUC";
+DragScaleSceneRootUC.get = (appObjects) => AppObject_1.getSingletonComponent(DragScaleSceneRootUC.type, appObjects);
+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.sceneRoot = appObject.getComponent(SceneRootEntity_1.SceneRootEntity.type);
+        if (!this.sceneRoot) {
+            this.warn("DragScaleSceneRootImp UC has been added to an App Object that does not have a SceneRoot Entity");
+        }
+    }
+}

package/lib/Components/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/Components/SceneRoot/UC/FocusOnPixel.js

@@ -0,0 +1,45 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.makeFocusOnPixelUC = exports.FocusOnPixelUC = void 0;
+const AppObject_1 = require("../../../AppObject");
+const AppObjectUC_1 = require("../../../AppObject/AppObjectUC");
+const Babylon_1 = require("../../Babylon");
+const Dispatcher_1 = require("../../Dispatcher");
+const SceneRootEntity_1 = require("../Entities/SceneRootEntity");
+class FocusOnPixelUC extends AppObjectUC_1.AppObjectUC {
+}
+exports.FocusOnPixelUC = FocusOnPixelUC;
+FocusOnPixelUC.type = "FocusOnPixelUC";
+FocusOnPixelUC.get = (appObjects) => AppObject_1.getSingletonComponent(FocusOnPixelUC.type, appObjects);
+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.sceneRoot = appObject.getComponent(SceneRootEntity_1.SceneRootEntity.type);
+        if (!this.sceneRoot) {
+            this.warn("BumpSceneRootScaleAboutPixelPointImp UC has been added to an App Object that does not have a SceneRoot Entity");
+            return;
+        }
+    }
+}

package/lib/Components/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/Components/SceneRoot/UC/OrbitSceneRoot.js

@@ -0,0 +1,81 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.makeOrbitSceneRootUC = exports.OrbitSceneRootUC = void 0;
+const AppObject_1 = require("../../../AppObject");
+const AppObjectUC_1 = require("../../../AppObject/AppObjectUC");
+const ValueObjects_1 = require("../../../ValueObjects");
+const Babylon_1 = require("../../Babylon");
+const Dispatcher_1 = require("../../Dispatcher");
+const SceneRootEntity_1 = require("../Entities/SceneRootEntity");
+class OrbitSceneRootUC extends AppObjectUC_1.AppObjectUC {
+}
+exports.OrbitSceneRootUC = OrbitSceneRootUC;
+OrbitSceneRootUC.type = "OrbitSceneRootUC";
+OrbitSceneRootUC.get = (appObjects) => AppObject_1.getSingletonComponent(OrbitSceneRootUC.type, appObjects);
+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.sceneRoot = appObject.getComponent(SceneRootEntity_1.SceneRootEntity.type);
+        if (!this.sceneRoot) {
+            this.warn("OrbitSceneRootImp UC has been added to an App Object that does not have a SceneRoot Entity");
+            return;
+        }
+        this.transformNode = (_a = this.sceneRoot) === null || _a === void 0 ? void 0 : _a.transform;
+    }
+}

package/lib/Components/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/Components/SceneRoot/UC/PanSceneRoot.js

@@ -0,0 +1,75 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.makePanSceneRootUC = exports.PanSceneRootUC = void 0;
+const AppObject_1 = require("../../../AppObject");
+const AppObjectUC_1 = require("../../../AppObject/AppObjectUC");
+const ValueObjects_1 = require("../../../ValueObjects");
+const Babylon_1 = require("../../Babylon");
+const Dispatcher_1 = require("../../Dispatcher");
+const SceneRootEntity_1 = require("../Entities/SceneRootEntity");
+class PanSceneRootUC extends AppObjectUC_1.AppObjectUC {
+}
+exports.PanSceneRootUC = PanSceneRootUC;
+PanSceneRootUC.type = "PanSceneRootUC";
+PanSceneRootUC.get = (appObjects) => AppObject_1.getSingletonComponent(PanSceneRootUC.type, appObjects);
+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.initialPosition = 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.initialPosition = this.sceneRoot.position;
+        };
+        this.finishPan = () => {
+            if (!this.hasBeenInitialized)
+                return;
+            if (!this.sceneRoot)
+                return;
+            this.hasBeenInitialized = false;
+            if (ValueObjects_1.Vector3.Equal(this.initialPosition, this.sceneRoot.position))
+                return;
+            Dispatcher_1.dispatchStateChange(this.appObjects);
+        };
+        this.cancelPan = () => {
+            this.hasBeenInitialized = false;
+        };
+        this.sceneRoot = appObject.getComponent(SceneRootEntity_1.SceneRootEntity.type);
+        if (!this.sceneRoot) {
+            this.warn("OrbitSceneRootImp UC has been added to an App Object that does not have a SceneRoot Entity");
+            return;
+        }
+        this.transformNode = (_a = this.sceneRoot) === null || _a === void 0 ? void 0 : _a.transform;
+    }
+}

package/lib/Components/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;