@vived/app 4.1.0 → 4.3.0

package/lib/Components/Babylon/Mocks/MockSceneRayPickUC.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MockSceneRayPickUC = void 0;
+const SceneRayPickUC_1 = require("../UC/SceneRayPickUC");
+class MockSceneRayPickUC extends SceneRayPickUC_1.SceneRayPickUC {
+    constructor() {
+        super(...arguments);
+        this.sceneRayPick = jest.fn();
+    }
+}
+exports.MockSceneRayPickUC = MockSceneRayPickUC;

package/lib/Components/Dispatcher/UC/RestoreCurrentStateUC.d.ts

@@ -0,0 +1,10 @@
+import { AppObject } from "../../../AppObject/AppObject";
+import { AppObjectRepo } from "../../../AppObject/AppObjectRepo";
+import { AppObjectUC } from "../../../AppObject/AppObjectUC";
+export declare abstract class RestoreCurrentStateUC extends AppObjectUC {
+    static readonly type = "RestoreCurrentStateUC";
+    readonly requestType = "RESTORE_CURRENT_STATE";
+    abstract doDispatch(): void;
+    static get: (appObjects: AppObjectRepo) => RestoreCurrentStateUC | undefined;
+}
+export declare function makeRestoreCurrentStateUC(appObject: AppObject): RestoreCurrentStateUC;

package/lib/Components/Dispatcher/UC/RestoreCurrentStateUC.js

@@ -0,0 +1,35 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.makeRestoreCurrentStateUC = exports.RestoreCurrentStateUC = void 0;
+const AppObject_1 = require("../../../AppObject");
+const AppObjectUC_1 = require("../../../AppObject/AppObjectUC");
+const AppDispatcher_1 = require("../Entities/AppDispatcher");
+class RestoreCurrentStateUC extends AppObjectUC_1.AppObjectUC {
+    constructor() {
+        super(...arguments);
+        this.requestType = "RESTORE_CURRENT_STATE";
+    }
+}
+exports.RestoreCurrentStateUC = RestoreCurrentStateUC;
+RestoreCurrentStateUC.type = "RestoreCurrentStateUC";
+RestoreCurrentStateUC.get = (appObjects) => AppObject_1.getSingletonComponent(RestoreCurrentStateUC.type, appObjects);
+function makeRestoreCurrentStateUC(appObject) {
+    return new DispatchStateChangeUCImp(appObject);
+}
+exports.makeRestoreCurrentStateUC = makeRestoreCurrentStateUC;
+class DispatchStateChangeUCImp extends RestoreCurrentStateUC {
+    constructor(appObject) {
+        super(appObject, RestoreCurrentStateUC.type);
+        this.requestVersion = 1;
+        this.appDispatcher = appObject.getComponent(AppDispatcher_1.AppDispatcher.type);
+        if (!this.appDispatcher) {
+            this.warn("RestoreCurrentStateUC has been added to an App Object that does not have a AppDispatcher. Add a dispatcher first");
+            this.dispose();
+        }
+    }
+    doDispatch() {
+        if (!this.appDispatcher)
+            return;
+        this.appDispatcher.formRequestAndDispatch(this.requestType, this.requestVersion);
+    }
+}

package/lib/Components/Dispatcher/UC/index.d.ts

@@ -23,3 +23,4 @@ export * from "./ShowSpinnerUC";
 export * from "./StateHasChangedUC";
 export * from "./StateIsCompleteUC";
 export * from "./SubmitResultResultUC";
+export * from "./RestoreCurrentStateUC";

package/lib/Components/Dispatcher/UC/index.js

@@ -35,3 +35,4 @@ __exportStar(require("./ShowSpinnerUC"), exports);
 __exportStar(require("./StateHasChangedUC"), exports);
 __exportStar(require("./StateIsCompleteUC"), exports);
 __exportStar(require("./SubmitResultResultUC"), exports);
+__exportStar(require("./RestoreCurrentStateUC"), exports);

package/lib/Components/Selection/Controller/MouseHoverOnAppObject.d.ts

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

package/lib/Components/Selection/Controller/MouseHoverOnAppObject.js

@@ -0,0 +1,42 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MouseHoverOnAppObject = void 0;
+const AppObjectController_1 = require("../../../AppObject/AppObjectController");
+const Babylon_1 = require("../../Babylon");
+const MouseInput_1 = require("../../MouseInput");
+const ZSpaceEntity_1 = require("../../zSpace/Entities/ZSpaceEntity");
+const HoverAppObjectUC_1 = require("../UC/HoverAppObjectUC");
+class MouseHoverOnAppObject extends AppObjectController_1.AppObjectController {
+    constructor(appObject) {
+        super(appObject, MouseHoverOnAppObject.type);
+        this.zSpaceEntity = undefined;
+        this.allow = (e) => {
+            return true;
+        };
+        this.onMove = (e) => {
+            if (!this.hoverUC)
+                return;
+            if (this.zSpaceEntity && this.zSpaceEntity.emulate)
+                return;
+            if (!this.allow(e))
+                return;
+            const ray = Babylon_1.pixelToSceneRay(e.position, this.appObjects);
+            this.hoverUC.tryHoverSceneObject(ray);
+        };
+        this.zSpaceEntity = ZSpaceEntity_1.ZSpaceEntity.get(this.appObjects);
+        this.hoverUC = appObject.getComponent(HoverAppObjectUC_1.HoverAppObjectUC.type);
+        if (!this.hoverUC) {
+            console.warn("MouseHover has been added to an App Object that does not have a HoverAppObjectUC. Add an HoverAppObjectUC before adding the Controller");
+            return;
+        }
+        const mouseInput = MouseInput_1.MouseInputEntity.get(this.appObjects);
+        if (mouseInput) {
+            mouseInput.registerController(this);
+        }
+        else {
+            this.warn("Unable to find MouseInputEntity");
+        }
+    }
+}
+exports.MouseHoverOnAppObject = MouseHoverOnAppObject;
+MouseHoverOnAppObject.type = "MouseHoverOnAppObject";

package/lib/Components/Selection/Controller/MousePressOnAppObject.d.ts

@@ -0,0 +1,18 @@
+import { AppObject } from "../../../AppObject/AppObject";
+import { AppObjectController } from "../../../AppObject/AppObjectController";
+import { MouseController, MouseInputEvent } from "../../MouseInput";
+export declare class MousePressOnAppObject extends AppObjectController implements MouseController {
+    static readonly type = "MousePressOnAppObject";
+    static readonly maxTapDistancePx = 5;
+    private pressUC?;
+    private zSpaceEntity;
+    private startPosition;
+    private endPosition;
+    private pressedID;
+    private isPressed;
+    allow: (e: MouseInputEvent) => boolean;
+    onDown: (e: MouseInputEvent) => void;
+    onUp: (e: MouseInputEvent) => void;
+    onMove: (e: MouseInputEvent) => void;
+    constructor(appObject: AppObject);
+}

package/lib/Components/Selection/Controller/MousePressOnAppObject.js

@@ -0,0 +1,81 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MousePressOnAppObject = void 0;
+const AppObjectController_1 = require("../../../AppObject/AppObjectController");
+const Vector2_1 = require("../../../ValueObjects/Vector2");
+const Babylon_1 = require("../../Babylon");
+const MouseInput_1 = require("../../MouseInput");
+const ZSpaceEntity_1 = require("../../zSpace/Entities/ZSpaceEntity");
+const PressAppObjectUC_1 = require("../UC/PressAppObjectUC");
+class MousePressOnAppObject extends AppObjectController_1.AppObjectController {
+    constructor(appObject) {
+        super(appObject, MousePressOnAppObject.type);
+        this.zSpaceEntity = undefined;
+        this.startPosition = Vector2_1.Vector2.Zero();
+        this.endPosition = Vector2_1.Vector2.Zero();
+        this.pressedID = null;
+        this.isPressed = false;
+        this.allow = (e) => {
+            return true;
+        };
+        this.onDown = (e) => {
+            var _a;
+            if (e.button !== 0) {
+                return;
+            }
+            if (!this.pressUC) {
+                return;
+            }
+            if (this.zSpaceEntity && this.zSpaceEntity.emulate)
+                return;
+            if (!this.allow(e))
+                return;
+            this.startPosition = e.position;
+            this.endPosition = this.startPosition;
+            this.isPressed = true;
+            const ray = Babylon_1.pixelToSceneRay(e.position, this.appObjects);
+            this.pressedID = (_a = this.pressUC) === null || _a === void 0 ? void 0 : _a.tryPressSceneObject(ray);
+        };
+        this.onUp = (e) => {
+            this.isPressed = false;
+            if (e.button !== 0) {
+                return;
+            }
+            if (!this.pressUC) {
+                return;
+            }
+            // Set pressedID to null
+            this.pressUC.pressSceneObject(this.pressedID, this.isPressed);
+        };
+        this.onMove = (e) => {
+            if (!this.pressUC) {
+                return;
+            }
+            if (this.isPressed) {
+                this.endPosition = e.position;
+                const movement = Vector2_1.Vector2.Subtract(this.startPosition, this.endPosition)
+                    .magnitued;
+                if (movement > MousePressOnAppObject.maxTapDistancePx) {
+                    // Set pressedID to null
+                    this.pressUC.pressSceneObject(null, this.isPressed);
+                }
+            }
+        };
+        this.zSpaceEntity = ZSpaceEntity_1.ZSpaceEntity.get(this.appObjects);
+        this.pressUC = appObject.getComponent(PressAppObjectUC_1.PressAppObjectUC.type);
+        if (!this.pressUC) {
+            console.warn("MousePress has been added to an App Object that does not have a PressAppObjectUC. Add a PressAppObjectUC before adding the Controller.");
+            return;
+        }
+        const mouseInput = MouseInput_1.MouseInputEntity.get(this.appObjects);
+        if (mouseInput) {
+            mouseInput.registerController(this);
+        }
+        else {
+            this.warn("Unable to find MouseInputEntity");
+        }
+    }
+}
+exports.MousePressOnAppObject = MousePressOnAppObject;
+MousePressOnAppObject.type = "MousePressOnAppObject";
+MousePressOnAppObject.maxTapDistancePx = 5;

package/lib/Components/Selection/Controller/MouseSelectAppObject.d.ts

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

package/lib/Components/Selection/Controller/MouseSelectAppObject.js

@@ -0,0 +1,46 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MouseSelectAppObject = void 0;
+const AppObjectController_1 = require("../../../AppObject/AppObjectController");
+const Babylon_1 = require("../../Babylon");
+const MouseInput_1 = require("../../MouseInput");
+const ZSpaceEntity_1 = require("../../zSpace/Entities/ZSpaceEntity");
+const SelectAppObjectUC_1 = require("../UC/SelectAppObjectUC");
+class MouseSelectAppObject extends AppObjectController_1.AppObjectController {
+    constructor(appObject) {
+        super(appObject, MouseSelectAppObject.type);
+        this.zSpaceEntity = undefined;
+        this.allow = (e) => {
+            return true;
+        };
+        this.onClick = (e) => {
+            if (!this.selectUC) {
+                return;
+            }
+            if (e.button !== 0) {
+                return;
+            }
+            if (this.zSpaceEntity && this.zSpaceEntity.emulate)
+                return;
+            if (!this.allow(e))
+                return;
+            const ray = Babylon_1.pixelToSceneRay(e.position, this.appObjects);
+            this.selectUC.trySelectSceneObject(ray);
+        };
+        this.zSpaceEntity = ZSpaceEntity_1.ZSpaceEntity.get(this.appObjects);
+        this.selectUC = appObject.getComponent(SelectAppObjectUC_1.SelectAppObjectUC.type);
+        if (!this.selectUC) {
+            console.warn("MouseSelect has been added to an App Object that does not have a SelectAppObjectUC. Add a SelectAppObjectUC before adding the Controller.");
+            return;
+        }
+        const mouseInput = MouseInput_1.MouseInputEntity.get(this.appObjects);
+        if (mouseInput) {
+            mouseInput.registerController(this);
+        }
+        else {
+            this.warn("Unable to find MouseInputEntity");
+        }
+    }
+}
+exports.MouseSelectAppObject = MouseSelectAppObject;
+MouseSelectAppObject.type = "MouseSelectAppObject";

package/lib/Components/Selection/Controller/StylusHoverOnAppObject.d.ts

@@ -0,0 +1,11 @@
+import { AppObject } from "../../../AppObject/AppObject";
+import { AppObjectController } from "../../../AppObject/AppObjectController";
+import { ZSpaceStylusController } from "../../zSpace/Entities/ZSpaceStylusEntity";
+export declare class StylusHoverOnAppObject extends AppObjectController implements ZSpaceStylusController {
+    static readonly type = "StylusHoverOnAppObject";
+    private stylus?;
+    private hoverUC?;
+    allow: () => boolean;
+    onStylusMove: () => void;
+    constructor(appObject: AppObject);
+}

package/lib/Components/Selection/Controller/StylusHoverOnAppObject.js

@@ -0,0 +1,42 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.StylusHoverOnAppObject = void 0;
+const AppObjectController_1 = require("../../../AppObject/AppObjectController");
+const ZSpaceEntity_1 = require("../../zSpace/Entities/ZSpaceEntity");
+const HoverAppObjectUC_1 = require("../UC/HoverAppObjectUC");
+class StylusHoverOnAppObject extends AppObjectController_1.AppObjectController {
+    constructor(appObject) {
+        super(appObject, StylusHoverOnAppObject.type);
+        this.allow = () => {
+            return true;
+        };
+        this.onStylusMove = () => {
+            if (!this.stylus)
+                return;
+            if (!this.hoverUC)
+                return;
+            if (!this.allow())
+                return;
+            const pointerRay = this.stylus.pickRay;
+            this.hoverUC.tryHoverSceneObject(pointerRay);
+        };
+        const zSpaceEntity = ZSpaceEntity_1.ZSpaceEntity.get(this.appObjects);
+        if (!zSpaceEntity) {
+            this.warn("Unable to find ZSpaceEntity");
+            return;
+        }
+        this.stylus = zSpaceEntity.stylus;
+        this.hoverUC = appObject.getComponent(HoverAppObjectUC_1.HoverAppObjectUC.type);
+        if (!this.stylus) {
+            console.warn("StylusInputPointer Controller has been added to an app object that does not have a ZSpaceStylusEntity");
+        }
+        else if (!this.hoverUC) {
+            console.warn("HoverAppObjectUC has not been found on any objects in the app object repo");
+        }
+        else {
+            this.stylus.registerController(this);
+        }
+    }
+}
+exports.StylusHoverOnAppObject = StylusHoverOnAppObject;
+StylusHoverOnAppObject.type = "StylusHoverOnAppObject";

package/lib/Components/Selection/Controller/StylusPressOnAppObject.d.ts

@@ -0,0 +1,18 @@
+import { AppObject } from "../../../AppObject/AppObject";
+import { AppObjectController } from "../../../AppObject/AppObjectController";
+import { ZSpaceStylusButton, ZSpaceStylusController } from "../../zSpace/Entities/ZSpaceStylusEntity";
+export declare class StylusPressOnAppObject extends AppObjectController implements ZSpaceStylusController {
+    static readonly type = "StylusPressOnAppObject";
+    static readonly maxTapDistancePx = 5;
+    private stylus?;
+    private pressUC?;
+    private startPosition;
+    private endPosition;
+    private pressedID;
+    private isPressed;
+    allow: (button: ZSpaceStylusButton) => boolean;
+    onButtonDown: (button: ZSpaceStylusButton) => void;
+    onButtonUp: (button: ZSpaceStylusButton) => void;
+    onStylusMove: () => void;
+    constructor(appObject: AppObject);
+}

package/lib/Components/Selection/Controller/StylusPressOnAppObject.js

@@ -0,0 +1,77 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.StylusPressOnAppObject = void 0;
+const AppObjectController_1 = require("../../../AppObject/AppObjectController");
+const Vector3_1 = require("../../../ValueObjects/Vector3");
+const ZSpaceEntity_1 = require("../../zSpace/Entities/ZSpaceEntity");
+const PressAppObjectUC_1 = require("../UC/PressAppObjectUC");
+class StylusPressOnAppObject extends AppObjectController_1.AppObjectController {
+    constructor(appObject) {
+        super(appObject, StylusPressOnAppObject.type);
+        this.startPosition = Vector3_1.Vector3.Zero();
+        this.endPosition = Vector3_1.Vector3.Zero();
+        this.pressedID = null;
+        this.isPressed = false;
+        this.allow = (button) => {
+            return true;
+        };
+        this.onButtonDown = (button) => {
+            var _a;
+            if (button !== 0)
+                return;
+            if (!this.stylus)
+                return;
+            if (!this.pressUC)
+                return;
+            if (!this.allow(button))
+                return;
+            this.startPosition = this.stylus.transform.localPosition;
+            this.endPosition = this.startPosition;
+            this.isPressed = true;
+            this.pressedID = (_a = this.pressUC) === null || _a === void 0 ? void 0 : _a.tryPressSceneObject(this.stylus.pickRay);
+        };
+        this.onButtonUp = (button) => {
+            this.isPressed = false;
+            if (button !== 0)
+                return;
+            if (!this.pressUC)
+                return;
+            // Set pressedID to null
+            this.pressUC.pressSceneObject(this.pressedID, this.isPressed);
+        };
+        this.onStylusMove = () => {
+            var _a;
+            if (!this.pressUC) {
+                return;
+            }
+            if (this.isPressed) {
+                this.endPosition = (_a = this.stylus) === null || _a === void 0 ? void 0 : _a.transform.localPosition;
+                const movement = Vector3_1.Vector3.Subtract(this.startPosition, this.endPosition)
+                    .magnitude;
+                if (movement > StylusPressOnAppObject.maxTapDistancePx) {
+                    // Set pressedID to null
+                    this.pressUC.pressSceneObject(null, this.isPressed);
+                }
+            }
+        };
+        const zSpaceEntity = ZSpaceEntity_1.ZSpaceEntity.get(this.appObjects);
+        if (!zSpaceEntity) {
+            this.warn("Unable to find ZSpaceEntity");
+            return;
+        }
+        this.stylus = zSpaceEntity.stylus;
+        this.pressUC = appObject.getComponent(PressAppObjectUC_1.PressAppObjectUC.type);
+        if (!this.stylus) {
+            console.warn("StylusInputPointer Controller has been added to an app object that does not have a ZSpaceStylusEntity");
+        }
+        else if (!this.pressUC) {
+            console.warn("PressAppObjectUC has not been found on any objects in the app object repo");
+        }
+        else {
+            this.stylus.registerController(this);
+        }
+    }
+}
+exports.StylusPressOnAppObject = StylusPressOnAppObject;
+StylusPressOnAppObject.type = "StylusPressOnAppObject";
+StylusPressOnAppObject.maxTapDistancePx = 5;

package/lib/Components/Selection/Controller/StylusSelectAppObject.d.ts

@@ -0,0 +1,11 @@
+import { AppObject } from "../../../AppObject/AppObject";
+import { AppObjectController } from "../../../AppObject/AppObjectController";
+import { ZSpaceStylusButton, ZSpaceStylusController } from "../../zSpace/Entities/ZSpaceStylusEntity";
+export declare class StylusSelectAppObject extends AppObjectController implements ZSpaceStylusController {
+    static readonly type = "StylusSelectAppObject";
+    private stylus?;
+    private selectUC?;
+    allow: () => boolean;
+    onButtonClick: (button: ZSpaceStylusButton) => void;
+    constructor(appObject: AppObject);
+}

package/lib/Components/Selection/Controller/StylusSelectAppObject.js

@@ -0,0 +1,44 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.StylusSelectAppObject = void 0;
+const AppObjectController_1 = require("../../../AppObject/AppObjectController");
+const ZSpaceEntity_1 = require("../../zSpace/Entities/ZSpaceEntity");
+const UC_1 = require("../UC");
+class StylusSelectAppObject extends AppObjectController_1.AppObjectController {
+    constructor(appObject) {
+        super(appObject, StylusSelectAppObject.type);
+        this.allow = () => {
+            return true;
+        };
+        this.onButtonClick = (button) => {
+            if (button !== 0)
+                return;
+            if (!this.stylus)
+                return;
+            if (!this.selectUC)
+                return;
+            if (!this.allow())
+                return;
+            const pointerRay = this.stylus.pickRay;
+            this.selectUC.trySelectSceneObject(pointerRay);
+        };
+        const zSpaceEntity = ZSpaceEntity_1.ZSpaceEntity.get(this.appObjects);
+        if (!zSpaceEntity) {
+            this.warn("Unable to find ZSpaceEntity");
+            return;
+        }
+        this.stylus = zSpaceEntity.stylus;
+        this.selectUC = appObject.getComponent(UC_1.SelectAppObjectUC.type);
+        if (!this.stylus) {
+            console.warn("StylusInputPointer Controller has been added to an app object that does not have a ZSpaceStylusEntity");
+        }
+        else if (!this.selectUC) {
+            console.warn("SelectAppObjectUC has not been found on any objects in the app object repo");
+        }
+        else {
+            this.stylus.registerController(this);
+        }
+    }
+}
+exports.StylusSelectAppObject = StylusSelectAppObject;
+StylusSelectAppObject.type = "StylusSelectAppObject";

package/lib/Components/Selection/Controller/TapToSelectAppObject.d.ts

@@ -0,0 +1,16 @@
+import { AppObject } from "../../../AppObject/AppObject";
+import { AppObjectController } from "../../../AppObject/AppObjectController";
+import { TouchController, TouchInputEvent } from "../../TouchController";
+export declare class TapToSelectAppObject extends AppObjectController implements TouchController {
+    static readonly type = "TapToSelectAppObject";
+    static readonly maxTapDistancePx = 5;
+    private selectUC?;
+    private startPosition;
+    private endPosition;
+    private doTouchEnd;
+    allow: (e: TouchInputEvent) => boolean;
+    onTouchStart: (e: TouchInputEvent) => void;
+    onTouchMove: (e: TouchInputEvent) => void;
+    onTouchEnd: () => void;
+    constructor(appObject: AppObject);
+}

package/lib/Components/Selection/Controller/TapToSelectAppObject.js

@@ -0,0 +1,69 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TapToSelectAppObject = void 0;
+const AppObjectController_1 = require("../../../AppObject/AppObjectController");
+const Vector2_1 = require("../../../ValueObjects/Vector2");
+const Babylon_1 = require("../../Babylon");
+const TouchController_1 = require("../../TouchController");
+const SelectAppObjectUC_1 = require("../UC/SelectAppObjectUC");
+class TapToSelectAppObject extends AppObjectController_1.AppObjectController {
+    constructor(appObject) {
+        super(appObject, TapToSelectAppObject.type);
+        this.startPosition = Vector2_1.Vector2.Zero();
+        this.endPosition = Vector2_1.Vector2.Zero();
+        this.doTouchEnd = false;
+        this.allow = (e) => {
+            return true;
+        };
+        this.onTouchStart = (e) => {
+            this.doTouchEnd = false;
+            if (e.touches.length !== 1) {
+                return;
+            }
+            if (!this.allow(e)) {
+                return;
+            }
+            this.startPosition = e.touches[0].position;
+            this.endPosition = this.startPosition;
+            this.doTouchEnd = true;
+        };
+        this.onTouchMove = (e) => {
+            if (e.touches.length === 1) {
+                this.endPosition = e.touches[0].position;
+            }
+            else {
+                this.doTouchEnd = false;
+            }
+        };
+        this.onTouchEnd = () => {
+            var _a;
+            if (!this.doTouchEnd) {
+                return;
+            }
+            if (!this.selectUC) {
+                return;
+            }
+            const movement = Vector2_1.Vector2.Subtract(this.startPosition, this.endPosition)
+                .magnitued;
+            if (movement <= TapToSelectAppObject.maxTapDistancePx) {
+                const ray = Babylon_1.pixelToSceneRay(this.endPosition, this.appObjects);
+                (_a = this.selectUC) === null || _a === void 0 ? void 0 : _a.trySelectSceneObject(ray);
+            }
+        };
+        this.selectUC = appObject.getComponent(SelectAppObjectUC_1.SelectAppObjectUC.type);
+        if (!this.selectUC) {
+            console.warn("MouseSelect has been added to an App Object that does not have a SelectAppObjectUC. Add a SelectAppObjectUC before adding the Controller.");
+            return;
+        }
+        const touchInput = TouchController_1.TouchInputEntity.get(this.appObjects);
+        if (touchInput) {
+            touchInput.registerController(this);
+        }
+        else {
+            this.warn("Unable to find TouchInputEntity");
+        }
+    }
+}
+exports.TapToSelectAppObject = TapToSelectAppObject;
+TapToSelectAppObject.type = "TapToSelectAppObject";
+TapToSelectAppObject.maxTapDistancePx = 5;

package/lib/Components/Selection/Controller/TouchPressOnAppObject.d.ts

@@ -0,0 +1,18 @@
+import { AppObject } from "../../../AppObject/AppObject";
+import { AppObjectController } from "../../../AppObject/AppObjectController";
+import { TouchController, TouchInputEvent } from "../../TouchController";
+export declare class TouchPressOnAppObject extends AppObjectController implements TouchController {
+    static readonly type = "TouchPressOnAppObject";
+    static readonly maxTapDistancePx = 5;
+    private pressUC?;
+    private startPosition;
+    private endPosition;
+    private doTouchEnd;
+    private pressedID;
+    private isPressed;
+    allow: (e: TouchInputEvent) => boolean;
+    onTouchStart: (e: TouchInputEvent) => void;
+    onTouchMove: (e: TouchInputEvent) => void;
+    onTouchEnd: () => void;
+    constructor(appObject: AppObject);
+}