@vived/app 4.27.0 → 4.27.1

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/XR/Mocks/index.d.ts

@@ -0,0 +1,2 @@
+export * from "./MockRenderToXR";
+export * from "./MockXRSession";

package/lib/Components/{ObjectPick/Adapters → XR/Mocks}/index.js

@@ -10,4 +10,5 @@ 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("./objectPickAdapter"), exports);
+__exportStar(require("./MockRenderToXR"), exports);
+__exportStar(require("./MockXRSession"), exports);

package/lib/Components/zSpace/Controllers/EmulateStylus.d.ts

@@ -0,0 +1,9 @@
+import { AppObject, AppObjectController } from "../../../AppObject";
+import { MouseController, MouseInputEvent } from "../../MouseInput";
+export default abstract class EmulateZSpaceStylus extends AppObjectController implements MouseController {
+    static readonly type = "EmulateZSpaceStylus";
+    abstract onDown: (e: MouseInputEvent) => void;
+    abstract onMove: (e: MouseInputEvent) => void;
+    abstract onUp: (e: MouseInputEvent) => void;
+}
+export declare function makeEmulateZSpaceStylus(appObject: AppObject): EmulateZSpaceStylus;

package/lib/Components/zSpace/Controllers/EmulateStylus.js

@@ -0,0 +1,100 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.makeEmulateZSpaceStylus = void 0;
+const AppObject_1 = require("../../../AppObject");
+const ValueObjects_1 = require("../../../ValueObjects");
+const Babylon_1 = require("../../Babylon");
+const MouseInput_1 = require("../../MouseInput");
+const Entities_1 = require("../Entities/");
+const PM_1 = require("../PM");
+class EmulateZSpaceStylus extends AppObject_1.AppObjectController {
+}
+exports.default = EmulateZSpaceStylus;
+EmulateZSpaceStylus.type = "EmulateZSpaceStylus";
+function makeEmulateZSpaceStylus(appObject) {
+    return new EmulateZSpaceStylusImp(appObject);
+}
+exports.makeEmulateZSpaceStylus = makeEmulateZSpaceStylus;
+class EmulateZSpaceStylusImp extends EmulateZSpaceStylus {
+    constructor(appObject) {
+        super(appObject, EmulateZSpaceStylus.type);
+        this.emulationIsActive = false;
+        this.screenPlane = ValueObjects_1.ParametricPlane.FromPointNormal(ValueObjects_1.Vector3.Zero(), ValueObjects_1.Vector3.Backward());
+        this.onDown = (e) => {
+            if (!this.emulationIsActive)
+                return;
+            if (!this.stylus)
+                return;
+            this.stylus.updateButtonState(e.button, true);
+        };
+        this.onMove = (e) => {
+            if (!this.emulationIsActive)
+                return;
+            if (!this.stylusTransform)
+                return;
+            const ray = this.pixelToSceneRay(e.position);
+            const hit = this.screenPlane.intersectLine(ray);
+            if (!hit) {
+                return;
+            }
+            const direction = ValueObjects_1.Vector3.Subtract(hit, this.stylusTransform.localPosition);
+            this.stylusTransform.localRotation = ValueObjects_1.Quaternion.FromDirectionVector(direction);
+        };
+        this.onUp = (e) => {
+            if (!this.emulationIsActive)
+                return;
+            if (!this.stylus)
+                return;
+            this.stylus.updateButtonState(e.button, false);
+        };
+        this.onZpsaceEnabledChange = (enabled) => {
+            this.emulationIsActive = false;
+            if (!enabled)
+                return;
+            if (!this.zSpaceEntity)
+                return;
+            if (!this.zSpaceEntity.emulate)
+                return;
+            this.emulationIsActive = true;
+            if (this.stylusTransform) {
+                this.stylusTransform.localPosition = new ValueObjects_1.Vector3(0.05, -0.05, -0.5);
+            }
+        };
+        this.zSpaceEntity = Entities_1.ZSpaceEntity.get(this.appObjects);
+        if (!this.zSpaceEntity) {
+            this.warn("Unable to find ZSpaceEntity");
+            return;
+        }
+        const pm = this.zSpaceEntity.appObject.getComponent(PM_1.ZSpaceIsEnabledPM.type);
+        if (!pm) {
+            this.warn("Unable to find ZSpaceIsEnabledPM");
+            return;
+        }
+        this.stylus = appObject.getComponent(Entities_1.ZSpaceStylusEntity.type);
+        if (!this.stylus) {
+            this.warn("Controller has been added to an app object that does not have a ZSpaceStylusEntity");
+            return;
+        }
+        this.stylusTransform = this.stylus.transform;
+        const mouseInput = MouseInput_1.MouseInputEntity.get(appObject.appObjectRepo);
+        if (mouseInput) {
+            mouseInput.registerController(this);
+        }
+        else {
+            this.warn("Unable to find MouseInputEntity");
+            return;
+        }
+        mouseInput.registerController(this);
+        pm.addView(this.onZpsaceEnabledChange);
+    }
+    pixelToSceneRay(pixelPos) {
+        if (!this.pixelToSceneRayUC) {
+            this.pixelToSceneRayUC = Babylon_1.PixelToSceneRayUC.get(this.appObjects);
+            if (!this.pixelToSceneRayUC) {
+                this.warn("Unable to find PixelToSceneRayUC");
+                return ValueObjects_1.ParametricLine.Forward();
+            }
+        }
+        return this.pixelToSceneRayUC.pixelToSceneRay(pixelPos);
+    }
+}

package/lib/Components/zSpace/Controllers/ZSpaceScaleRoot.d.ts

@@ -0,0 +1,14 @@
+import { AppObject } from "../../../AppObject/AppObject";
+import { AppObjectController } from "../../../AppObject/AppObjectController";
+import { ZSpaceStylusButton, ZSpaceStylusController } from "../Entities/ZSpaceStylusEntity";
+export declare class ZSpaceScaleRoot extends AppObjectController implements ZSpaceStylusController {
+    static readonly type = "ZSpaceScaleRoot";
+    private stylus?;
+    private scaleSceneRootWithRay?;
+    private isScaling;
+    allow: (button: ZSpaceStylusButton) => boolean;
+    onButtonDown: (button: ZSpaceStylusButton) => void;
+    onStylusMove: () => void;
+    onButtonUp: () => void;
+    constructor(appObject: AppObject);
+}

package/lib/Components/zSpace/Controllers/ZSpaceScaleRoot.js

@@ -0,0 +1,57 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ZSpaceScaleRoot = void 0;
+const AppObjectController_1 = require("../../../AppObject/AppObjectController");
+const SceneRoot_1 = require("../../SceneRoot");
+const ScaleSceneRootWithRay_1 = require("../../SceneRoot/UC/ScaleSceneRootWithRay");
+const ZSpaceStylusEntity_1 = require("../Entities/ZSpaceStylusEntity");
+class ZSpaceScaleRoot extends AppObjectController_1.AppObjectController {
+    constructor(appObject) {
+        super(appObject, ZSpaceScaleRoot.type);
+        this.isScaling = false;
+        this.allow = (button) => {
+            if (button === ZSpaceStylusEntity_1.ZSpaceStylusButton.BACK_RIGHT)
+                return true;
+            return false;
+        };
+        this.onButtonDown = (button) => {
+            var _a;
+            this.isScaling = false;
+            if (!this.stylus)
+                return;
+            if (!this.allow(button))
+                return;
+            const pointerRay = this.stylus.pickRay;
+            const rayStart = this.stylus.transform.localPosition;
+            (_a = this.scaleSceneRootWithRay) === null || _a === void 0 ? void 0 : _a.initializeScale(pointerRay, rayStart);
+            this.isScaling = true;
+        };
+        this.onStylusMove = () => {
+            var _a;
+            if (!this.stylus)
+                return;
+            if (!this.isScaling)
+                return;
+            const pointerRay = this.stylus.pickRay;
+            const rayStart = this.stylus.transform.localPosition;
+            (_a = this.scaleSceneRootWithRay) === null || _a === void 0 ? void 0 : _a.doScale(pointerRay, rayStart);
+        };
+        this.onButtonUp = () => {
+            this.isScaling = false;
+        };
+        this.stylus = appObject.getComponent(ZSpaceStylusEntity_1.ZSpaceStylusEntity.type);
+        const sceneRoot = SceneRoot_1.SceneRootEntity.get(appObject.appObjectRepo);
+        this.scaleSceneRootWithRay = sceneRoot === null || sceneRoot === void 0 ? void 0 : sceneRoot.appObject.getComponent(ScaleSceneRootWithRay_1.ScaleSceneRootWithRay.type);
+        if (!this.stylus) {
+            this.warn("StylusInputPointer Controller has been added to an app object that does not have a ZSpaceStylusEntity");
+        }
+        else if (!this.scaleSceneRootWithRay) {
+            this.warn("StylusRootScaleSceneRootWithRay was not found on the Scene Root App Object");
+        }
+        else {
+            this.stylus.registerController(this);
+        }
+    }
+}
+exports.ZSpaceScaleRoot = ZSpaceScaleRoot;
+ZSpaceScaleRoot.type = "ZSpaceScaleRoot";

package/lib/Components/zSpace/Controllers/index.d.ts

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

package/lib/Components/{ObjectPick/PM → zSpace/Controllers}/index.js

@@ -10,4 +10,4 @@ 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("./ObjectPickPM"), exports);
+__exportStar(require("./EmulateStylus"), exports);

package/lib/Components/zSpace/Entities/ZSpaceStylusEntity.d.ts

@@ -0,0 +1,27 @@
+import { AppObject } from "../../../AppObject/AppObject";
+import { AppObjectEntity } from "../../../AppObject/AppObjectEntity";
+import { ParametricLine } from "../../../ValueObjects";
+import { Transform3D } from "../../Transform3D";
+export declare enum ZSpaceStylusButton {
+    PRIMARY = 0,
+    BACK_RIGHT = 1,
+    BACK_LEFT = 2
+}
+export interface ZSpaceStylusController {
+    onButtonDown?: (button: ZSpaceStylusButton) => void;
+    onButtonUp?: (button: ZSpaceStylusButton) => void;
+    onButtonClick?: (button: ZSpaceStylusButton) => void;
+    onStylusMove?: (transform: Transform3D) => void;
+}
+export declare abstract class ZSpaceStylusEntity extends AppObjectEntity {
+    static readonly type = "ZSpaceStylusEntity";
+    static clickMovementThreshold: number;
+    static clickTimeThresholdMS: number;
+    abstract registerController: (controller: ZSpaceStylusController) => void;
+    abstract updateButtonState: (button: ZSpaceStylusButton, isPressed: boolean) => void;
+    abstract readonly transform: Transform3D;
+    abstract readonly helperTransform: Transform3D;
+    abstract get pickRay(): ParametricLine;
+    abstract get isInUse(): boolean;
+}
+export declare function makeZSpaceStylus(appObj: AppObject): ZSpaceStylusEntity;

package/lib/Components/zSpace/Entities/ZSpaceStylusEntity.js

@@ -0,0 +1,111 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.makeZSpaceStylus = exports.ZSpaceStylusEntity = exports.ZSpaceStylusButton = void 0;
+const AppObjectEntity_1 = require("../../../AppObject/AppObjectEntity");
+const Entities_1 = require("../../../Entities");
+const ValueObjects_1 = require("../../../ValueObjects");
+const Transform3D_1 = require("../../Transform3D");
+var ZSpaceStylusButton;
+(function (ZSpaceStylusButton) {
+    ZSpaceStylusButton[ZSpaceStylusButton["PRIMARY"] = 0] = "PRIMARY";
+    ZSpaceStylusButton[ZSpaceStylusButton["BACK_RIGHT"] = 1] = "BACK_RIGHT";
+    ZSpaceStylusButton[ZSpaceStylusButton["BACK_LEFT"] = 2] = "BACK_LEFT";
+})(ZSpaceStylusButton = exports.ZSpaceStylusButton || (exports.ZSpaceStylusButton = {}));
+class ZSpaceStylusEntity extends AppObjectEntity_1.AppObjectEntity {
+}
+exports.ZSpaceStylusEntity = ZSpaceStylusEntity;
+ZSpaceStylusEntity.type = "ZSpaceStylusEntity";
+ZSpaceStylusEntity.clickMovementThreshold = 0.32;
+ZSpaceStylusEntity.clickTimeThresholdMS = 350;
+function makeZSpaceStylus(appObj) {
+    const transform = Transform3D_1.Transform3D.addIfMissing(appObj);
+    return new StylusImp(appObj, transform);
+}
+exports.makeZSpaceStylus = makeZSpaceStylus;
+class StylusImp extends ZSpaceStylusEntity {
+    constructor(appObject, transform) {
+        super(appObject, ZSpaceStylusEntity.type);
+        this.controllers = [];
+        this.buttonStates = [false, false, false];
+        this.pressPosition = ValueObjects_1.Vector3.Zero();
+        this.pressTime = 0;
+        this.registerController = (controller) => {
+            this.controllers.push(controller);
+        };
+        this.updateButtonState = (button, isPressed) => {
+            if (this.buttonStates[button] === isPressed)
+                return;
+            this.controllers.forEach((controller) => {
+                if (isPressed) {
+                    if (controller.onButtonDown) {
+                        controller.onButtonDown(button);
+                    }
+                    this.lassPressedButton = button;
+                    this.pressPosition = this.transform.localPosition;
+                    this.pressTime = Date.now();
+                }
+                else {
+                    if (controller.onButtonUp) {
+                        controller.onButtonUp(button);
+                    }
+                    if (this.isClick(button) && controller.onButtonClick) {
+                        controller.onButtonClick(button);
+                    }
+                }
+            });
+            this.buttonStates[button] = isPressed;
+            this.notifyOnChange();
+        };
+        this.isClick = (button) => {
+            const buttonIsCorrect = button === this.lassPressedButton;
+            const movement = ValueObjects_1.Vector3.Subtract(this.transform.localPosition, this.pressPosition).magnitude;
+            const movementIsSmallEnough = movement < ZSpaceStylusEntity.clickMovementThreshold;
+            const passedTime = Date.now() - this.pressTime;
+            const pressTimeIsShortEnough = passedTime < ZSpaceStylusEntity.clickTimeThresholdMS;
+            if (buttonIsCorrect && movementIsSmallEnough && pressTimeIsShortEnough) {
+                return true;
+            }
+            else {
+                return false;
+            }
+        };
+        this.onTransformUpdate = () => {
+            this.checkIfStylusIsInUse(this.transform.worldMatrix);
+            this.controllers.forEach((controller) => {
+                if (controller.onStylusMove) {
+                    controller.onStylusMove(this.transform);
+                }
+            });
+            this.notifyOnChange();
+        };
+        this.memoizedIsInUse = new Entities_1.MemoizedBoolean(false, this.notifyOnChange);
+        this.transform = transform;
+        this.transform.addChangeObserver(this.onTransformUpdate);
+        const helperTransformAO = appObject.appObjectRepo.getOrCreate("StylusHelper");
+        this.helperTransform = Transform3D_1.Transform3D.addIfMissing(helperTransformAO);
+        this.helperTransform.parent = this.transform;
+    }
+    get pickRay() {
+        return ValueObjects_1.ParametricLine.FromPointDirection(this.transform.worldPosition, this.transform.localDirectionToWorld(ValueObjects_1.Vector3.Forward()));
+    }
+    get isInUse() {
+        return this.memoizedIsInUse.val;
+    }
+    checkIfStylusIsInUse(worldMatrix) {
+        const m = worldMatrix.m;
+        if (m[1] === 0 &&
+            m[2] === 0 &&
+            m[3] === 0 &&
+            m[4] === 0 &&
+            m[7] === 0 &&
+            m[8] === 0 &&
+            m[11] === 0 &&
+            m[12] === 0 &&
+            m[15] === 1) {
+            this.memoizedIsInUse.val = false;
+        }
+        else {
+            this.memoizedIsInUse.val = true;
+        }
+    }
+}

package/lib/Components/zSpace/PM/StylusColorLengthPM.d.ts

@@ -0,0 +1,13 @@
+import { AppObject, AppObjectPM } from "../../../AppObject";
+import { Color } from "../../../ValueObjects";
+export interface StylusColorLengthVM {
+    color: Color;
+    length: number;
+}
+export declare abstract class StylusColorLengthPM extends AppObjectPM<StylusColorLengthVM> {
+    static readonly type = "StylusColorLengthPM";
+    abstract rayColorNoPick: Color;
+    abstract rayColorPick: Color;
+    abstract defaultLength: number;
+}
+export declare function makeStylusColorLengthPM(appObject: AppObject): StylusColorLengthPM;

package/lib/Components/zSpace/PM/StylusColorLengthPM.js

@@ -0,0 +1,77 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.makeStylusColorLengthPM = exports.StylusColorLengthPM = void 0;
+const AppObject_1 = require("../../../AppObject");
+const ValueObjects_1 = require("../../../ValueObjects");
+const Babylon_1 = require("../../Babylon");
+const ZSpaceStylusEntity_1 = require("../Entities/ZSpaceStylusEntity");
+class StylusColorLengthPM extends AppObject_1.AppObjectPM {
+}
+exports.StylusColorLengthPM = StylusColorLengthPM;
+StylusColorLengthPM.type = "StylusColorLengthPM";
+function makeStylusColorLengthPM(appObject) {
+    return new StylusColorLengthPMImp(appObject);
+}
+exports.makeStylusColorLengthPM = makeStylusColorLengthPM;
+class StylusColorLengthPMImp extends StylusColorLengthPM {
+    constructor(appObject) {
+        super(appObject, StylusColorLengthPM.type);
+        this.defaultLength = 1;
+        this.rayColorNoPick = ValueObjects_1.Color.RGB(128, 128, 128);
+        this.rayColorPick = ValueObjects_1.Color.RGB(0, 255, 0);
+        this.onEntityChange = () => {
+            if (!this.stylus || !this.stylus.isInUse) {
+                this.setDefaultVM();
+                return;
+            }
+            const pickRay = this.stylus.pickRay;
+            const scenePickUC = Babylon_1.SceneRayPickUC.get(this.appObject.appObjectRepo);
+            if (!scenePickUC) {
+                this.setDefaultVM();
+                return;
+            }
+            const scenePick = scenePickUC.sceneRayPick(pickRay);
+            let color = this.rayColorNoPick;
+            let length = this.defaultLength;
+            if (scenePick && (scenePick === null || scenePick === void 0 ? void 0 : scenePick.hit) && scenePick.worldPickPoint) {
+                color = this.rayColorPick;
+                length = Math.abs(ValueObjects_1.Vector3.Subtract(this.stylus.transform.worldPosition, scenePick.worldPickPoint).magnitude);
+            }
+            const vm = {
+                color,
+                length,
+            };
+            this.doUpdateView(vm);
+        };
+        this.dispose = () => {
+            var _a, _b;
+            super.dispose();
+            (_a = this.stylus) === null || _a === void 0 ? void 0 : _a.removeChangeObserver(this.onEntityChange);
+            (_b = this.stylus) === null || _b === void 0 ? void 0 : _b.removeOnDisposeObserver(this.dispose);
+        };
+        this.stylus = appObject.getComponent(ZSpaceStylusEntity_1.ZSpaceStylusEntity.type);
+        if (this.stylus) {
+            this.stylus.addChangeObserver(this.onEntityChange);
+            this.stylus.addOnDisposeObserver(() => {
+                this.dispose();
+            });
+            this.onEntityChange();
+        }
+        else {
+            this.warn("App Object does not have a Stylus Entity");
+        }
+    }
+    vmsAreEqual(a, b) {
+        if (ValueObjects_1.Color.Equal(a.color, b.color) && a.length === b.length) {
+            return true;
+        }
+        return false;
+    }
+    setDefaultVM() {
+        const vm = {
+            color: this.rayColorNoPick,
+            length: 0,
+        };
+        this.doUpdateView(vm);
+    }
+}

package/lib/Components/zSpace/PM/StylusIsInUsePM.d.ts

@@ -0,0 +1,6 @@
+import { AppObject, AppObjectPM, AppObjectRepo } from "../../../AppObject";
+export declare abstract class StylusIsInUsePM extends AppObjectPM<boolean> {
+    static readonly type = "StylusIsInUsePM";
+    static get: (appObjects: AppObjectRepo) => StylusIsInUsePM | undefined;
+}
+export declare function makeStylusIsInUsePM(appObject: AppObject): StylusIsInUsePM;

package/lib/Components/zSpace/PM/StylusIsInUsePM.js

@@ -0,0 +1,42 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.makeStylusIsInUsePM = exports.StylusIsInUsePM = void 0;
+const AppObject_1 = require("../../../AppObject");
+const Entities_1 = require("../Entities");
+class StylusIsInUsePM extends AppObject_1.AppObjectPM {
+}
+exports.StylusIsInUsePM = StylusIsInUsePM;
+StylusIsInUsePM.type = "StylusIsInUsePM";
+StylusIsInUsePM.get = (appObjects) => AppObject_1.getSingletonComponent(StylusIsInUsePM.type, appObjects);
+function makeStylusIsInUsePM(appObject) {
+    return new StylusIsInUsePMImp(appObject);
+}
+exports.makeStylusIsInUsePM = makeStylusIsInUsePM;
+class StylusIsInUsePMImp extends StylusIsInUsePM {
+    constructor(appObject) {
+        super(appObject, StylusIsInUsePM.type);
+        this.onRepoChange = () => {
+            if (!this.stylus)
+                return;
+            this.doUpdateView(this.stylus.isInUse);
+        };
+        this.dispose = () => {
+            var _a, _b;
+            super.dispose();
+            (_a = this.stylus) === null || _a === void 0 ? void 0 : _a.removeChangeObserver(this.onRepoChange);
+            (_b = this.stylus) === null || _b === void 0 ? void 0 : _b.removeOnDisposeObserver(this.dispose);
+        };
+        this.stylus = appObject.getComponent(Entities_1.ZSpaceStylusEntity.type);
+        if (this.stylus) {
+            this.stylus.addChangeObserver(this.onRepoChange);
+            this.stylus.addOnDisposeObserver(() => this.dispose());
+            this.onRepoChange();
+        }
+        else {
+            this.warn("App Object does not have a ZSpace Stylus Entity");
+        }
+    }
+    vmsAreEqual(a, b) {
+        return a === b;
+    }
+}

package/lib/Controllers/HoverLabelMouse.d.ts

@@ -0,0 +1,10 @@
+import { Babylon, HoverLabels, MouseController, MouseInput, MouseInputEvent } from "../Entities";
+import { Vector2 } from "../ValueObjects";
+export declare class HoverLabelMouse implements MouseController {
+    private hoverLabels;
+    private currentTimeout;
+    tryHoverLabelUC: (position: Vector2) => void;
+    readonly hoverLabelDelay = 500;
+    onMove: (e: MouseInputEvent) => void;
+    constructor(hoverLabels: HoverLabels, mouseInput: MouseInput, babylon: Babylon);
+}

package/lib/Controllers/HoverLabelMouse.js

@@ -0,0 +1,23 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.HoverLabelMouse = void 0;
+const trySetHoverLabel_1 = require("../UseCases/HoverLabels/trySetHoverLabel");
+class HoverLabelMouse {
+    constructor(hoverLabels, mouseInput, babylon) {
+        this.hoverLabels = hoverLabels;
+        this.hoverLabelDelay = 500;
+        this.onMove = (e) => {
+            this.hoverLabels.hideHoverLabel();
+            if (this.currentTimeout) {
+                clearTimeout(this.currentTimeout);
+            }
+            this.currentTimeout = setTimeout(() => {
+                this.tryHoverLabelUC(e.position);
+                this.currentTimeout = undefined;
+            }, this.hoverLabelDelay);
+        };
+        mouseInput.registerController(this);
+        this.tryHoverLabelUC = trySetHoverLabel_1.makeTrySetHoverLabel(hoverLabels, babylon);
+    }
+}
+exports.HoverLabelMouse = HoverLabelMouse;

package/lib/Controllers/HoverLabelTouch.d.ts

@@ -0,0 +1,14 @@
+import { Babylon, HoverLabels, TouchController, TouchInput, TouchInputEvent } from "../Entities";
+import { Vector2 } from "../ValueObjects";
+export declare const touchLabelDragThreshold = 15;
+export declare class HoverLabelTouch implements TouchController {
+    private hoverLabels;
+    private lastPosition;
+    private startPosition;
+    private touchStarted;
+    tryHoverLabelUC: (position: Vector2) => void;
+    onTouchStart: (e: TouchInputEvent) => void;
+    onTouchMove: (e: TouchInputEvent) => void;
+    onTouchEnd: () => void;
+    constructor(hoverLabels: HoverLabels, touchInput: TouchInput, babylon: Babylon);
+}

package/lib/Controllers/HoverLabelTouch.js

@@ -0,0 +1,41 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.HoverLabelTouch = exports.touchLabelDragThreshold = void 0;
+const UseCases_1 = require("../UseCases");
+const ValueObjects_1 = require("../ValueObjects");
+exports.touchLabelDragThreshold = 15;
+class HoverLabelTouch {
+    constructor(hoverLabels, touchInput, babylon) {
+        this.hoverLabels = hoverLabels;
+        this.lastPosition = ValueObjects_1.Vector2.Zero();
+        this.startPosition = ValueObjects_1.Vector2.Zero();
+        this.touchStarted = false;
+        this.onTouchStart = (e) => {
+            this.hoverLabels.hideHoverLabel();
+            this.touchStarted = false;
+            if (e.touchCount !== 1)
+                return;
+            this.startPosition = e.touches[0].position;
+            this.lastPosition = e.touches[0].position;
+            this.touchStarted = true;
+        };
+        this.onTouchMove = (e) => {
+            if (!this.touchStarted)
+                return;
+            this.lastPosition = e.touches[0].position;
+        };
+        this.onTouchEnd = () => {
+            if (!this.touchStarted)
+                return;
+            const xDiff = this.lastPosition.x - this.startPosition.x;
+            const yDiff = this.lastPosition.y - this.startPosition.y;
+            const dist = Math.sqrt(xDiff * xDiff + yDiff * yDiff);
+            if (dist < exports.touchLabelDragThreshold) {
+                this.tryHoverLabelUC(this.lastPosition);
+            }
+        };
+        touchInput.registerController(this);
+        this.tryHoverLabelUC = UseCases_1.makeTrySetHoverLabel(hoverLabels, babylon);
+    }
+}
+exports.HoverLabelTouch = HoverLabelTouch;

package/lib/Controllers/ToolHotkeys.d.ts

@@ -0,0 +1,6 @@
+import { KeyboardController, KeyboardInput, ToolRepository } from "../Entities";
+export declare class ToolHotkeys<ToolTypes> implements KeyboardController {
+    private toolRepo;
+    onKeyDown: (e: KeyboardEvent) => void;
+    constructor(toolRepo: ToolRepository<ToolTypes>, keyboardInput: KeyboardInput);
+}

package/lib/Controllers/ToolHotkeys.js

@@ -0,0 +1,25 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ToolHotkeys = void 0;
+class ToolHotkeys {
+    constructor(toolRepo, keyboardInput) {
+        this.toolRepo = toolRepo;
+        this.onKeyDown = (e) => {
+            if (e.repeat)
+                return;
+            const currentKey = {
+                keyCode: e.code,
+                alt: e.altKey,
+                control: e.ctrlKey,
+                meta: e.metaKey,
+                shift: e.shiftKey,
+            };
+            const tool = this.toolRepo.getToolForHotkey(currentKey);
+            if (!tool)
+                return;
+            this.toolRepo.triggerTool(tool.type);
+        };
+        keyboardInput.registerController(this);
+    }
+}
+exports.ToolHotkeys = ToolHotkeys;

package/lib/Controllers/index.d.ts

@@ -0,0 +1,3 @@
+export * from "./ToolHotkeys";
+export * from "./HoverLabelTouch";
+export * from "./HoverLabelMouse";