@vived/app 3.8.0 → 3.9.0

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

@@ -0,0 +1,89 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DoubleTapToFocus = void 0;
+const AppObjectController_1 = require("../../../AppObject/AppObjectController");
+const ValueObjects_1 = require("../../../ValueObjects");
+const App_1 = require("../../App");
+const TouchController_1 = require("../../TouchController");
+const FocusOnPixel_1 = require("../UC/FocusOnPixel");
+class DoubleTapToFocus extends AppObjectController_1.AppObjectController {
+    constructor(appObject) {
+        super(appObject, DoubleTapToFocus.type);
+        this.focusDurationMS = 500;
+        this.tapTimeMS = 300;
+        this.maxTapDistancePx = 30;
+        this.initialTouchPos = ValueObjects_1.Vector2.Zero();
+        this.initialTouchTime = 0;
+        this.tapCount = 0;
+        this.allow = (e) => {
+            return true;
+        };
+        this.onTouchStart = (e) => {
+            if (!this.allow(e)) {
+                this.cancelDoubleTap();
+                return;
+            }
+            if (e.touchCount !== 1) {
+                this.cancelDoubleTap();
+                return;
+            }
+            this.tapCount = this.tapCount + 1;
+            if (this.tapCount === 1) {
+                this.initialTouchPos = e.touchCenter;
+                this.initialTouchTime = Date.now();
+            }
+            else if (this.tapCount === 2) {
+                this.checkForMovement(e.touchCenter);
+            }
+        };
+        this.onTouchMove = (e) => {
+            if (this.tapCount !== 1)
+                return;
+            if (e.touchCount !== 1) {
+                this.cancelDoubleTap();
+                return;
+            }
+            this.checkForMovement(e.touchCenter);
+        };
+        this.onTouchEnd = () => {
+            var _a;
+            if (this.tapCount === 2) {
+                const passedTime = Date.now() - this.initialTouchTime;
+                if (passedTime > this.tapTimeMS) {
+                    this.cancelDoubleTap();
+                    return;
+                }
+                (_a = this.focusOnPixelUC) === null || _a === void 0 ? void 0 : _a.centerOnPixel(this.initialTouchPos);
+                this.tapCount = 0;
+                this.initialTouchTime = 0;
+            }
+        };
+        this.cancelDoubleTap = () => {
+            this.initialTouchTime = 0;
+            this.tapCount = 0;
+        };
+        const appObjects = appObject.appObjectRepo;
+        this.focusOnPixelUC = appObject.getComponent(FocusOnPixel_1.FocusOnPixelUC.type);
+        if (!this.focusOnPixelUC) {
+            App_1.submitWarning("DoubleTapToFocus", "Controller has been added to an App Object that does not have FocusOnPixelUC. Add one first.", appObjects);
+            return;
+        }
+        const touchInput = TouchController_1.TouchInputEntity.get(appObjects);
+        if (touchInput) {
+            touchInput.registerController(this);
+        }
+        else {
+            App_1.submitWarning("DoubleTapToFocus", "Unable to find TouchInputEntity", appObjects);
+        }
+    }
+    checkForMovement(currentPixelPos) {
+        const movement = ValueObjects_1.Vector2.Subtract(this.initialTouchPos, currentPixelPos)
+            .magnitued;
+        if (movement > this.maxTapDistancePx) {
+            this.cancelDoubleTap();
+            return;
+        }
+    }
+}
+exports.DoubleTapToFocus = DoubleTapToFocus;
+DoubleTapToFocus.type = "DoubleTapToFocus";

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

@@ -0,0 +1,11 @@
+import { AppObject } from "../../../AppObject/AppObject";
+import { AppObjectController } from "../../../AppObject/AppObjectController";
+import { MouseController, MouseInputEvent } from "../../MouseInput";
+export declare class MouseClickToFocus extends AppObjectController implements MouseController {
+    static readonly type = "MouseClickToFocus";
+    private appObjects;
+    private centerOnPixelUI?;
+    allow: (e: MouseInputEvent) => boolean;
+    onClick: (e: MouseInputEvent) => void;
+    constructor(appObject: AppObject);
+}

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

@@ -0,0 +1,36 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MouseClickToFocus = void 0;
+const AppObjectController_1 = require("../../../AppObject/AppObjectController");
+const App_1 = require("../../App");
+const MouseInput_1 = require("../../MouseInput");
+const CenterSceneRootOnPixelPick_1 = require("../UC/CenterSceneRootOnPixelPick");
+class MouseClickToFocus extends AppObjectController_1.AppObjectController {
+    constructor(appObject) {
+        super(appObject, MouseClickToFocus.type);
+        this.allow = (e) => {
+            return true;
+        };
+        this.onClick = (e) => {
+            var _a;
+            if (this.allow(e)) {
+                (_a = this.centerOnPixelUI) === null || _a === void 0 ? void 0 : _a.centerOnPixel(e.position);
+            }
+        };
+        this.appObjects = appObject.appObjectRepo;
+        this.centerOnPixelUI = appObject.getComponent(CenterSceneRootOnPixelPick_1.CenterSceneRootOnPixelPickUC.type);
+        if (!this.centerOnPixelUI) {
+            App_1.submitWarning("MouseClickToFocus", "Controller has been added to an App Object that does not have CenterSceneRootOnPixelPickUC. Add one first.", this.appObjects);
+            return;
+        }
+        const mouseInput = MouseInput_1.MouseInputEntity.get(this.appObjects);
+        if (mouseInput) {
+            mouseInput.registerController(this);
+        }
+        else {
+            App_1.submitWarning("MouseClickToFocus", "Unable to find MouseInputEntity", this.appObjects);
+        }
+    }
+}
+exports.MouseClickToFocus = MouseClickToFocus;
+MouseClickToFocus.type = "MouseClickToFocus";

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

@@ -0,0 +1,12 @@
+import { AppObject } from "../../../AppObject/AppObject";
+import { AppObjectController } from "../../../AppObject/AppObjectController";
+import { MouseController, MouseInputEvent } from "../../MouseInput";
+export declare class MouseDoubleClickToRecenter extends AppObjectController implements MouseController {
+    static readonly type = "MouseDoubleClickToRecenter";
+    protected focusDurationMS: number;
+    private appObjects;
+    private focusUC?;
+    allow: (e: MouseInputEvent) => boolean;
+    onDoubleClick: (e: MouseInputEvent) => void;
+    constructor(appObject: AppObject);
+}

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

@@ -0,0 +1,37 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MouseDoubleClickToRecenter = void 0;
+const AppObjectController_1 = require("../../../AppObject/AppObjectController");
+const App_1 = require("../../App");
+const MouseInput_1 = require("../../MouseInput");
+const FocusOnPixel_1 = require("../UC/FocusOnPixel");
+class MouseDoubleClickToRecenter extends AppObjectController_1.AppObjectController {
+    constructor(appObject) {
+        super(appObject, MouseDoubleClickToRecenter.type);
+        this.focusDurationMS = 500;
+        this.allow = (e) => {
+            return true;
+        };
+        this.onDoubleClick = (e) => {
+            var _a;
+            if (this.allow(e)) {
+                (_a = this.focusUC) === null || _a === void 0 ? void 0 : _a.centerOnPixel(e.position);
+            }
+        };
+        this.appObjects = appObject.appObjectRepo;
+        this.focusUC = appObject.getComponent(FocusOnPixel_1.FocusOnPixelUC.type);
+        if (!this.focusUC) {
+            App_1.submitWarning("MouseDoubleClickToRecenter", "Controller has been added to an App Object that does not have FocusOnPixelUC. Add one first.", this.appObjects);
+            return;
+        }
+        const mouseInput = MouseInput_1.MouseInputEntity.get(this.appObjects);
+        if (mouseInput) {
+            mouseInput.registerController(this);
+        }
+        else {
+            App_1.submitWarning("MouseDoubleClickToRecenter", "Unable to find MouseInputEntity", this.appObjects);
+        }
+    }
+}
+exports.MouseDoubleClickToRecenter = MouseDoubleClickToRecenter;
+MouseDoubleClickToRecenter.type = "MouseDoubleClickToRecenter";

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

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

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

@@ -0,0 +1,55 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MouseOrbit = void 0;
+const AppObjectController_1 = require("../../../AppObject/AppObjectController");
+const App_1 = require("../../App");
+const MouseInput_1 = require("../../MouseInput");
+const OrbitSceneRoot_1 = require("../UC/OrbitSceneRoot");
+class MouseOrbit extends AppObjectController_1.AppObjectController {
+    constructor(appObject) {
+        super(appObject, MouseOrbit.type);
+        this.isOrbiting = false;
+        this.allow = (e) => {
+            return true;
+        };
+        this.onDown = (e) => {
+            this.isOrbiting = false;
+            if (!this.orbitSceneRoot)
+                return;
+            if (!this.allow(e))
+                return;
+            const pixelPosition = e.position;
+            this.orbitSceneRoot.initializeOrbit(pixelPosition);
+            this.isOrbiting = true;
+        };
+        this.onMove = (e) => {
+            if (!this.orbitSceneRoot)
+                return;
+            if (!this.isOrbiting)
+                return;
+            const currentPixelPos = e.position;
+            this.orbitSceneRoot.doOrbit(currentPixelPos);
+        };
+        this.onUp = () => {
+            if (!this.orbitSceneRoot)
+                return;
+            this.orbitSceneRoot.finishOrbit();
+            this.isOrbiting = false;
+        };
+        this.appObjects = appObject.appObjectRepo;
+        this.orbitSceneRoot = appObject.getComponent(OrbitSceneRoot_1.OrbitSceneRootUC.type);
+        if (!this.orbitSceneRoot) {
+            App_1.submitWarning("MouseOrbit", "Controller has been added to an App Object that does not have OrbitSceneRootUC. Add one first.", this.appObjects);
+            return;
+        }
+        const mouseInput = MouseInput_1.MouseInputEntity.get(this.appObjects);
+        if (mouseInput) {
+            mouseInput.registerController(this);
+        }
+        else {
+            App_1.submitWarning("MouseOrbit ", "Unable to find MouseInputEntity", this.appObjects);
+        }
+    }
+}
+exports.MouseOrbit = MouseOrbit;
+MouseOrbit.type = "MouseOrbit";

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

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

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

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

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

@@ -0,0 +1,11 @@
+import { AppObject } from "../../../AppObject/AppObject";
+import { AppObjectController } from "../../../AppObject/AppObjectController";
+import { MouseController, MouseWheelEvent } from "../../MouseInput";
+export declare class MouseRoll extends AppObjectController implements MouseController {
+    static readonly type = "MouseRoll";
+    private appObjects;
+    private bumpRootScaleUC?;
+    allow: (e: MouseWheelEvent) => boolean;
+    onWheel: (e: MouseWheelEvent) => void;
+    constructor(appObject: AppObject);
+}

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

@@ -0,0 +1,38 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MouseRoll = void 0;
+const AppObjectController_1 = require("../../../AppObject/AppObjectController");
+const App_1 = require("../../App");
+const MouseInput_1 = require("../../MouseInput");
+const BumpSceneRootScaleAboutPixelPoint_1 = require("../UC/BumpSceneRootScaleAboutPixelPoint");
+class MouseRoll extends AppObjectController_1.AppObjectController {
+    constructor(appObject) {
+        super(appObject, MouseRoll.type);
+        this.allow = (e) => {
+            return true;
+        };
+        this.onWheel = (e) => {
+            if (!this.allow(e))
+                return;
+            if (!this.bumpRootScaleUC) {
+                return;
+            }
+            this.bumpRootScaleUC.bump(e.event.deltaY > 0 ? "OUT" : "IN", e.position);
+        };
+        this.appObjects = appObject.appObjectRepo;
+        this.bumpRootScaleUC = appObject.getComponent(BumpSceneRootScaleAboutPixelPoint_1.BumpSceneRootScaleAboutPixelPointUC.type);
+        if (!this.bumpRootScaleUC) {
+            App_1.submitWarning("MouseRoll", "Controller has been added to an App Object that does not have BumpSceneRootScaleAboutPixelPointUC. Add one first.", this.appObjects);
+            return;
+        }
+        const mouseInput = MouseInput_1.MouseInputEntity.get(this.appObjects);
+        if (mouseInput) {
+            mouseInput.registerController(this);
+        }
+        else {
+            App_1.submitWarning("MouseRoll ", "Unable to find MouseInputEntity", this.appObjects);
+        }
+    }
+}
+exports.MouseRoll = MouseRoll;
+MouseRoll.type = "MouseRoll";

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";