@vived/app 3.8.0 → 3.9.0

package/lib/AppObjectComponents/Tools/Factories/setupTool.d.ts

@@ -0,0 +1,3 @@
+import { AppObjectRepo } from "../../../AppObject/AppObjectRepo";
+import { ToolData, ToolEntity } from "../Entities/ToolEntity";
+export declare function setupTool<ToolTypes>(toolData: ToolData<ToolTypes>, appObjects: AppObjectRepo): ToolEntity<ToolTypes>;

package/lib/AppObjectComponents/Tools/Factories/setupTool.js

@@ -0,0 +1,12 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.setupTool = void 0;
+const ToolEntity_1 = require("../Entities/ToolEntity");
+const ToolPM_1 = require("../PresentationManagers/ToolPM");
+function setupTool(toolData, appObjects) {
+    const tool = appObjects.getOrCreate(toolData.label);
+    const toolEntity = ToolEntity_1.makeToolEntity(toolData, tool);
+    const pm = new ToolPM_1.ToolPM(tool);
+    return toolEntity;
+}
+exports.setupTool = setupTool;

package/lib/AppObjectComponents/Tools/Factories/setupToolRepo.d.ts

@@ -0,0 +1,4 @@
+import { AppObjectRepo } from "../../../AppObject/AppObjectRepo";
+import { ToolData } from "../Entities/ToolEntity";
+import { ToolRepository } from "../Entities/ToolRepository";
+export declare function setupToolRepo<ToolTypes>(data: ToolData<ToolTypes>[], appObjects: AppObjectRepo): ToolRepository<ToolTypes>;

package/lib/AppObjectComponents/Tools/Factories/setupToolRepo.js

@@ -0,0 +1,13 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.setupToolRepo = void 0;
+const ToolHotkeys_1 = require("../Controller/ToolHotkeys");
+const ToolRepository_1 = require("../Entities/ToolRepository");
+function setupToolRepo(data, appObjects) {
+    const toolRepo = appObjects.getOrCreate("ToolRepo");
+    const entity = ToolRepository_1.makeToolRepo(toolRepo);
+    entity.setupToolsFromData(data);
+    new ToolHotkeys_1.ToolHotkeys(toolRepo);
+    return entity;
+}
+exports.setupToolRepo = setupToolRepo;

package/lib/AppObjectComponents/Tools/PresentationManagers/ToolPM.d.ts

@@ -0,0 +1,19 @@
+import { AppObject } from "../../../AppObject/AppObject";
+import { AppObjectPM } from "../../../AppObject/AppObjectPM";
+export interface ToolVM<ToolType> {
+    toolType: ToolType;
+    label: string;
+    enabled: boolean;
+    selected: boolean;
+    show: boolean;
+    shortcutLabel: string;
+    tooltipLabel: string;
+}
+export declare class ToolPM<ToolType> extends AppObjectPM<ToolVM<ToolType>> {
+    static readonly type = "ToolPM";
+    private tool?;
+    vmsAreEqual(a: ToolVM<ToolType>, b: ToolVM<ToolType>): boolean;
+    onToolChange: () => void;
+    dispose: () => void;
+    constructor(appObject: AppObject);
+}

package/lib/AppObjectComponents/Tools/PresentationManagers/ToolPM.js

@@ -0,0 +1,66 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ToolPM = void 0;
+const AppObjectPM_1 = require("../../../AppObject/AppObjectPM");
+const App_1 = require("../../App");
+const ToolEntity_1 = require("../Entities/ToolEntity");
+class ToolPM extends AppObjectPM_1.AppObjectPM {
+    constructor(appObject) {
+        super(appObject, ToolPM.type);
+        this.onToolChange = () => {
+            if (!this.tool)
+                return;
+            const { toolType, state, label, shortcutLabel } = this.tool;
+            let enabled = false;
+            if (state === ToolEntity_1.ToolState.ACTIVE || state === ToolEntity_1.ToolState.ENABLED) {
+                enabled = true;
+            }
+            const selected = state === ToolEntity_1.ToolState.ACTIVE ? true : false;
+            const show = state === ToolEntity_1.ToolState.HIDDEN ? false : true;
+            const tooltipLabel = `${label} [${shortcutLabel}]`;
+            const vm = {
+                toolType: toolType,
+                enabled,
+                label,
+                selected,
+                show,
+                shortcutLabel,
+                tooltipLabel,
+            };
+            this.doUpdateView(vm);
+        };
+        this.dispose = () => {
+            var _a;
+            super.dispose();
+            (_a = this.tool) === null || _a === void 0 ? void 0 : _a.removeChangeObserver(this.onToolChange);
+        };
+        this.tool = appObject.getComponent(ToolEntity_1.ToolEntity.type);
+        if (!this.tool) {
+            App_1.submitWarning("ToolPM", "ToolPM is being added to an object that does not have a Tool Entity", appObject.appObjectRepo);
+            return;
+        }
+        else {
+            this.tool.addChangeObserver(this.onToolChange);
+            this.onToolChange();
+        }
+    }
+    vmsAreEqual(a, b) {
+        if (a.toolType !== b.toolType)
+            return false;
+        if (a.enabled !== b.enabled)
+            return false;
+        if (a.label !== b.label)
+            return false;
+        if (a.selected !== b.selected)
+            return false;
+        if (a.show !== b.show)
+            return false;
+        if (a.shortcutLabel !== b.shortcutLabel)
+            return false;
+        if (a.tooltipLabel !== b.tooltipLabel)
+            return false;
+        return true;
+    }
+}
+exports.ToolPM = ToolPM;
+ToolPM.type = "ToolPM";

package/lib/AppObjectComponents/Tools/index.d.ts

@@ -0,0 +1,6 @@
+export * from "./Entities/ToolEntity";
+export * from "./Entities/ToolRepository";
+export * from "./PresentationManagers/ToolPM";
+export * from "./Controller/triggerTool";
+export * from "./Controller/ToolHotkeys";
+export * from "./Factories/setupToolRepo";

package/lib/AppObjectComponents/Tools/index.js

@@ -0,0 +1,18 @@
+"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("./Entities/ToolEntity"), exports);
+__exportStar(require("./Entities/ToolRepository"), exports);
+__exportStar(require("./PresentationManagers/ToolPM"), exports);
+__exportStar(require("./Controller/triggerTool"), exports);
+__exportStar(require("./Controller/ToolHotkeys"), exports);
+__exportStar(require("./Factories/setupToolRepo"), exports);

package/lib/AppObjectComponents/TouchController/Entities/TouchInput.d.ts

@@ -0,0 +1,33 @@
+import { AppObject } from "../../../AppObject/AppObject";
+import { AppObjectEntity } from "../../../AppObject/AppObjectEntity";
+import { AppObjectRepo } from "../../../AppObject/AppObjectRepo";
+import { Vector2 } from "../../../ValueObjects";
+export interface TouchInputEvent {
+    touchCount: number;
+    touchCenter: Vector2;
+    touches: TouchData[];
+    event: TouchEvent;
+}
+export interface TouchData {
+    id: number;
+    position: Vector2;
+    touch?: Touch;
+}
+export interface TouchController {
+    onTouchStart?: (e: TouchInputEvent) => void;
+    onTouchMove?: (e: TouchInputEvent) => void;
+    onTouchEnd?: (e: TouchInputEvent) => void;
+    onTouchCancel?: (e: TouchInputEvent) => void;
+}
+export declare abstract class TouchInputEntity extends AppObjectEntity {
+    static readonly type = "TouchInputEntity";
+    abstract get eventElement(): HTMLElement | undefined;
+    abstract eventElementBounds?: DOMRect;
+    abstract setEventElement: (eventElement: HTMLElement) => void;
+    abstract clearInputElement: () => void;
+    abstract updateInputElementBounds: () => void;
+    abstract registerController: (controller: TouchController) => void;
+    abstract removeController: (controller: TouchController) => void;
+    static get(appObjects: AppObjectRepo): TouchInputEntity | undefined;
+}
+export declare function makeTouchInput(appObject: AppObject): TouchInputEntity;

package/lib/AppObjectComponents/TouchController/Entities/TouchInput.js

@@ -0,0 +1,161 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.makeTouchInput = exports.TouchInputEntity = void 0;
+const AppObjectEntity_1 = require("../../../AppObject/AppObjectEntity");
+const ValueObjects_1 = require("../../../ValueObjects");
+class TouchInputEntity extends AppObjectEntity_1.AppObjectEntity {
+    static get(appObjects) {
+        const components = appObjects.getAllComponents(TouchInputEntity.type);
+        if (components.length === 0) {
+            console.warn(`Unable to find component ${TouchInputEntity.type}. Add one on Mount`);
+            return undefined;
+        }
+        else if (components.length > 1) {
+            console.warn(`Multiple ${TouchInputEntity.type} found. There should only be one. Using the first one`);
+        }
+        return components[0];
+    }
+}
+exports.TouchInputEntity = TouchInputEntity;
+TouchInputEntity.type = "TouchInputEntity";
+function makeTouchInput(appObject) {
+    return new TouchInputImp(appObject);
+}
+exports.makeTouchInput = makeTouchInput;
+class TouchInputImp extends TouchInputEntity {
+    constructor(appObject) {
+        super(appObject, TouchInputEntity.type);
+        this.controllers = [];
+        this._eventElement = undefined;
+        this.updateInputElementBounds = () => {
+            if (!this._eventElement)
+                return;
+            this.eventElementBounds = this._eventElement.getBoundingClientRect(); // Expensive so we cache
+        };
+        this.getTouchOffsetPosition = (touch) => {
+            if (!this.eventElementBounds) {
+                console.warn("No target bounds");
+                return ValueObjects_1.Vector2.Zero();
+            }
+            const x = touch.clientX - this.eventElementBounds.x;
+            const y = touch.clientY - this.eventElementBounds.y;
+            return new ValueObjects_1.Vector2(x, y);
+        };
+        this.setEventElement = (eventElement) => {
+            if (this._eventElement)
+                this.clearInputElement();
+            eventElement.addEventListener("touchstart", this.onTouchStart, false);
+            eventElement.addEventListener("touchmove", this.onTouchMove, false);
+            eventElement.addEventListener("touchend", this.onTouchEnd, false);
+            eventElement.addEventListener("touchcancel", this.onTouchCancel, false);
+            this.eventElementBounds = eventElement.getBoundingClientRect();
+            this._eventElement = eventElement;
+        };
+        this.onTouchStart = (e) => {
+            if (e.cancelable)
+                e.preventDefault();
+            const touchInput = this.createTouchInputEvent(e);
+            this.controllers.forEach((c) => {
+                if (c.onTouchStart) {
+                    c.onTouchStart(touchInput);
+                }
+            });
+        };
+        this.onTouchMove = (e) => {
+            if (e.cancelable)
+                e.preventDefault();
+            const touchInput = this.createTouchInputEvent(e);
+            this.controllers.forEach((c) => {
+                if (c.onTouchMove) {
+                    c.onTouchMove(touchInput);
+                }
+            });
+        };
+        this.onTouchEnd = (e) => {
+            if (e.cancelable)
+                e.preventDefault();
+            const touchInput = this.createTouchInputEvent(e);
+            this.controllers.forEach((c) => {
+                if (c.onTouchEnd) {
+                    c.onTouchEnd(touchInput);
+                }
+            });
+        };
+        this.onTouchCancel = (e) => {
+            if (e.cancelable)
+                e.preventDefault();
+            const touchInput = this.createTouchInputEvent(e);
+            this.controllers.forEach((c) => {
+                if (c.onTouchCancel) {
+                    c.onTouchCancel(touchInput);
+                }
+            });
+        };
+        this.clearInputElement = () => {
+            if (!this._eventElement)
+                return;
+            this._eventElement.removeEventListener("touchstart", this.onTouchStart);
+            this._eventElement.removeEventListener("touchmove", this.onTouchMove);
+            this._eventElement.removeEventListener("touchend", this.onTouchEnd);
+            this._eventElement.removeEventListener("touchcancel", this.onTouchCancel);
+            this._eventElement = undefined;
+        };
+        this.registerController = (controller) => {
+            this.controllers.push(controller);
+        };
+        this.removeController = (controller) => {
+            const index = this.controllers.indexOf(controller);
+            if (index >= 0) {
+                this.controllers.splice(index, 1);
+            }
+        };
+    }
+    get eventElement() {
+        return this._eventElement;
+    }
+    createTouchInputEvent(event) {
+        const touches = [];
+        const touchCount = event.touches.length;
+        let minX = 0;
+        let maxX = 0;
+        let minY = 0;
+        let maxY = 0;
+        for (let i = 0; i < touchCount; i++) {
+            const touch = event.touches[i];
+            const position = this.getTouchOffsetPosition(touch);
+            touches.push({
+                id: touch.identifier,
+                touch,
+                position,
+            });
+            if (i === 0) {
+                minX = position.x;
+                maxX = position.x;
+                minY = position.y;
+                maxY = position.y;
+            }
+            else {
+                minX = Math.min(minX, position.x);
+                maxX = Math.max(maxX, position.x);
+                minY = Math.min(minY, position.y);
+                maxY = Math.max(maxY, position.y);
+            }
+        }
+        let cntX = 0;
+        let cntY = 0;
+        if (touchCount === 1) {
+            cntX = maxX;
+            cntY = maxY;
+        }
+        else {
+            cntX = minX + (maxX - minX) / 2;
+            cntY = minY + (maxY - minY) / 2;
+        }
+        return {
+            touchCenter: new ValueObjects_1.Vector2(cntX, cntY),
+            touchCount,
+            touches,
+            event,
+        };
+    }
+}

package/lib/AppObjectComponents/TouchController/Mock/MockTouchInput.d.ts

@@ -0,0 +1,13 @@
+/// <reference types="jest" />
+import { AppObject } from "../../../AppObject/AppObject";
+import { TouchInputEntity } from "../Entities/TouchInput";
+export declare class MockTouchInputEntity extends TouchInputEntity {
+    get eventElement(): HTMLElement | undefined;
+    eventElementBounds?: DOMRect | undefined;
+    setEventElement: jest.Mock<any, any>;
+    clearInputElement: jest.Mock<any, any>;
+    updateInputElementBounds: jest.Mock<any, any>;
+    registerController: jest.Mock<any, any>;
+    removeController: jest.Mock<any, any>;
+    constructor(appObject: AppObject);
+}

package/lib/AppObjectComponents/TouchController/Mock/MockTouchInput.js

@@ -0,0 +1,18 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MockTouchInputEntity = void 0;
+const TouchInput_1 = require("../Entities/TouchInput");
+class MockTouchInputEntity extends TouchInput_1.TouchInputEntity {
+    constructor(appObject) {
+        super(appObject, TouchInput_1.TouchInputEntity.type);
+        this.setEventElement = jest.fn();
+        this.clearInputElement = jest.fn();
+        this.updateInputElementBounds = jest.fn();
+        this.registerController = jest.fn();
+        this.removeController = jest.fn();
+    }
+    get eventElement() {
+        return undefined;
+    }
+}
+exports.MockTouchInputEntity = MockTouchInputEntity;

package/lib/AppObjectComponents/TouchController/Mock/mockTouchInputEvent.d.ts

@@ -0,0 +1,3 @@
+import { Vector2 } from "../../../ValueObjects";
+import { TouchInputEvent } from "../Entities/TouchInput";
+export declare function mockTouchInputEvent(touchPositions: Vector2[]): TouchInputEvent;

package/lib/AppObjectComponents/TouchController/Mock/mockTouchInputEvent.js

@@ -0,0 +1,26 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.mockTouchInputEvent = void 0;
+const ValueObjects_1 = require("../../../ValueObjects");
+function mockTouchInputEvent(touchPositions) {
+    const mockEvt = new TouchEvent("");
+    const touchCount = touchPositions.length;
+    let sumPos = ValueObjects_1.Vector2.Zero();
+    const touches = touchPositions.map((pos, i) => {
+        sumPos = ValueObjects_1.Vector2.Add(sumPos, pos);
+        return {
+            id: i,
+            position: pos,
+        };
+    });
+    const avgPos = touchCount === 0
+        ? ValueObjects_1.Vector2.Zero()
+        : new ValueObjects_1.Vector2(sumPos.x / touchCount, sumPos.y / touchCount);
+    return {
+        event: mockEvt,
+        touchCenter: avgPos,
+        touchCount,
+        touches,
+    };
+}
+exports.mockTouchInputEvent = mockTouchInputEvent;

package/lib/AppObjectComponents/TouchController/index.d.ts

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

package/lib/AppObjectComponents/TouchController/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("./Entities/TouchInput"), exports);

package/lib/AppObjectComponents/XR/Entity/XREntity.d.ts

@@ -0,0 +1,13 @@
+/// <reference types="webxr" />
+import { AppObject } from "../../../AppObject/AppObject";
+import { AppObjectEntity } from "../../../AppObject/AppObjectEntity";
+export interface OnXRFrameObserver {
+    onNewXRFrame: (frame: XRFrame) => void;
+}
+export declare abstract class XREntity extends AppObjectEntity {
+    static readonly type = "XREntity";
+    abstract xrReferenceSpace?: XRReferenceSpace;
+    abstract get lastXRFrame(): XRFrame | undefined;
+    abstract submitXRFrame: (frame: XRFrame) => void;
+}
+export declare function makeXREntity(appObj: AppObject): XREntity;

package/lib/AppObjectComponents/XR/Entity/XREntity.js

@@ -0,0 +1,24 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.makeXREntity = exports.XREntity = void 0;
+const AppObjectEntity_1 = require("../../../AppObject/AppObjectEntity");
+class XREntity extends AppObjectEntity_1.AppObjectEntity {
+}
+exports.XREntity = XREntity;
+XREntity.type = "XREntity";
+function makeXREntity(appObj) {
+    return new XREntityImp(appObj);
+}
+exports.makeXREntity = makeXREntity;
+class XREntityImp extends XREntity {
+    constructor(appObj) {
+        super(appObj, XREntity.type);
+        this.submitXRFrame = (frame) => {
+            this._lastXRFrame = frame;
+            this.notifyOnChange();
+        };
+    }
+    get lastXRFrame() {
+        return this._lastXRFrame;
+    }
+}

package/lib/AppObjectComponents/XR/UseCase/RenderToXR.d.ts

@@ -0,0 +1,7 @@
+/// <reference types="webxr" />
+import { AppObjectUC } from "../../../AppObject/AppObjectUC";
+export declare abstract class RenderToXR extends AppObjectUC {
+    static readonly type = "RenderToXR";
+    abstract startRenderingXR(session: XRSession): void;
+    abstract stopRenderingXR(): void;
+}

package/lib/AppObjectComponents/XR/UseCase/RenderToXR.js

@@ -0,0 +1,8 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RenderToXR = void 0;
+const AppObjectUC_1 = require("../../../AppObject/AppObjectUC");
+class RenderToXR extends AppObjectUC_1.AppObjectUC {
+}
+exports.RenderToXR = RenderToXR;
+RenderToXR.type = "RenderToXR";

package/lib/AppObjectComponents/XR/index.d.ts

@@ -0,0 +1,2 @@
+export * from "./Entity/XREntity";
+export * from "./UseCase/RenderToXR";

package/lib/AppObjectComponents/XR/index.js

@@ -0,0 +1,14 @@
+"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("./Entity/XREntity"), exports);
+__exportStar(require("./UseCase/RenderToXR"), exports);

package/lib/AppObjectComponents/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/AppObjectComponents/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.SceneRoot.get(appObject.appObjectRepo);
+        this.scaleSceneRootWithRay = sceneRoot === null || sceneRoot === void 0 ? void 0 : sceneRoot.appObject.getComponent(ScaleSceneRootWithRay_1.ScaleSceneRootWithRay.type);
+        if (!this.stylus) {
+            console.error("StylusInputPointer Controller has been added to an app object that does not have a ZSpaceStylusEntity");
+        }
+        else if (!this.scaleSceneRootWithRay) {
+            console.error("StylusRootScaleSceneRootWithRay was not found on the Scene Root App Object");
+        }
+        else {
+            this.stylus.registerController(this);
+        }
+    }
+}
+exports.ZSpaceScaleRoot = ZSpaceScaleRoot;
+ZSpaceScaleRoot.type = "ZSpaceScaleRoot";

package/lib/AppObjectComponents/zSpace/Controllers/ZSpaceStylusRootMovement.d.ts

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

package/lib/AppObjectComponents/zSpace/Controllers/ZSpaceStylusRootMovement.js

@@ -0,0 +1,51 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ZSpaceStylusRootMovement = void 0;
+const AppObjectController_1 = require("../../../AppObject/AppObjectController");
+const ZSpaceStylusEntity_1 = require("../Entities/ZSpaceStylusEntity");
+const StylusRootMovementUC_1 = require("../UseCases/StylusRootMovementUC");
+class ZSpaceStylusRootMovement extends AppObjectController_1.AppObjectController {
+    constructor(appObject) {
+        super(appObject, ZSpaceStylusRootMovement.type);
+        this.allow = (button) => {
+            if (button === ZSpaceStylusEntity_1.ZSpaceStylusButton.PRIMARY)
+                return true;
+            return false;
+        };
+        this.onButtonDown = (button) => {
+            var _a;
+            if (!this.stylus)
+                return;
+            if (!this.allow(button))
+                return;
+            const pointerRay = this.stylus.pickRay;
+            (_a = this.stylusRootMovementUC) === null || _a === void 0 ? void 0 : _a.initialize(pointerRay);
+        };
+        this.onButtonUp = (button) => {
+            var _a;
+            if (!this.stylus)
+                return;
+            (_a = this.stylusRootMovementUC) === null || _a === void 0 ? void 0 : _a.stop();
+        };
+        this.onStylusMove = () => {
+            var _a;
+            if (!this.stylus)
+                return;
+            const pointerRay = this.stylus.pickRay;
+            (_a = this.stylusRootMovementUC) === null || _a === void 0 ? void 0 : _a.move(pointerRay);
+        };
+        this.stylus = appObject.getComponent(ZSpaceStylusEntity_1.ZSpaceStylusEntity.type);
+        this.stylusRootMovementUC = StylusRootMovementUC_1.StylusRootMovementUC.get(appObject.appObjectRepo);
+        if (!this.stylus) {
+            console.error("StylusInputPointer Controller has been added to an app object that does not have a ZSpaceStylusEntity");
+        }
+        else if (!this.stylusRootMovementUC) {
+            console.error("StylusRootMovementUC has not been found on any objects in the app object repo");
+        }
+        else {
+            this.stylus.registerController(this);
+        }
+    }
+}
+exports.ZSpaceStylusRootMovement = ZSpaceStylusRootMovement;
+ZSpaceStylusRootMovement.type = "ZSpaceStylusRootMovement";