@vived/app 3.8.0 → 3.9.0

package/lib/AppObjectComponents/zSpace/Entities/ZSpaceDisplayEntity.d.ts

@@ -0,0 +1,21 @@
+import { AppObject } from "../../../AppObject/AppObject";
+import { AppObjectEntity } from "../../../AppObject/AppObjectEntity";
+import { Vector2 } from "../../../ValueObjects";
+import { Transform3D } from "../../Transform3D";
+export declare enum ZSpaceDevice {
+    MAKO = "MAKO",
+    INSPIRE = "INSPIRE",
+    AIO = "AIO"
+}
+export declare abstract class ZSpaceDisplayEntity extends AppObjectEntity {
+    static readonly type = "ZSpaceDisplayEntity";
+    abstract readonly transform: Transform3D;
+    abstract get displaySizeMeters(): Vector2;
+    abstract set displaySizeMeters(val: Vector2);
+    abstract get displaySizePixels(): Vector2;
+    abstract set displaySizePixels(val: Vector2);
+    abstract get metersPerPixel(): number;
+    abstract get pixelPerMeter(): number;
+    abstract setForDevice(device: ZSpaceDevice): void;
+}
+export declare function makeZSpaceDisplayEntity(appObj: AppObject): ZSpaceDisplayEntity;

package/lib/AppObjectComponents/zSpace/Entities/ZSpaceDisplayEntity.js

@@ -0,0 +1,60 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.makeZSpaceDisplayEntity = exports.ZSpaceDisplayEntity = exports.ZSpaceDevice = void 0;
+const AppObjectEntity_1 = require("../../../AppObject/AppObjectEntity");
+const Entities_1 = require("../../../Entities");
+const ValueObjects_1 = require("../../../ValueObjects");
+const Transform3D_1 = require("../../Transform3D");
+var ZSpaceDevice;
+(function (ZSpaceDevice) {
+    ZSpaceDevice["MAKO"] = "MAKO";
+    ZSpaceDevice["INSPIRE"] = "INSPIRE";
+    ZSpaceDevice["AIO"] = "AIO";
+})(ZSpaceDevice = exports.ZSpaceDevice || (exports.ZSpaceDevice = {}));
+class ZSpaceDisplayEntity extends AppObjectEntity_1.AppObjectEntity {
+}
+exports.ZSpaceDisplayEntity = ZSpaceDisplayEntity;
+ZSpaceDisplayEntity.type = "ZSpaceDisplayEntity";
+function makeZSpaceDisplayEntity(appObj) {
+    return new ZSpaceDisplayEntityImp(appObj);
+}
+exports.makeZSpaceDisplayEntity = makeZSpaceDisplayEntity;
+class ZSpaceDisplayEntityImp extends ZSpaceDisplayEntity {
+    constructor(appObject) {
+        super(appObject, ZSpaceDisplayEntity.type);
+        this.memoizedSizeMeters = new Entities_1.MemoizedVector2(ValueObjects_1.Vector2.One(), this.notifyOnChange);
+        this.memoizedSizePixels = new Entities_1.MemoizedVector2(ValueObjects_1.Vector2.One(), this.notifyOnChange);
+        this.transform = Transform3D_1.Transform3D.addIfMissing(appObject);
+    }
+    get displaySizeMeters() {
+        return this.memoizedSizeMeters.val;
+    }
+    set displaySizeMeters(val) {
+        this.memoizedSizeMeters.val = val;
+    }
+    get displaySizePixels() {
+        return this.memoizedSizePixels.val;
+    }
+    set displaySizePixels(val) {
+        this.memoizedSizePixels.val = val;
+    }
+    get metersPerPixel() {
+        if (this.memoizedSizePixels.val.x === 0)
+            return 0;
+        return this.memoizedSizeMeters.val.x / this.memoizedSizePixels.val.x;
+    }
+    get pixelPerMeter() {
+        if (this.memoizedSizeMeters.val.x === 0)
+            return 0;
+        return this.memoizedSizePixels.val.x / this.memoizedSizeMeters.val.x;
+    }
+    setForDevice(device) {
+        if (device === ZSpaceDevice.AIO) {
+            this.displaySizeMeters = new ValueObjects_1.Vector2(0.521, 0.293);
+        }
+        else {
+            this.displaySizeMeters = new ValueObjects_1.Vector2(0.344, 0.193);
+        }
+        this.displaySizePixels = new ValueObjects_1.Vector2(1920, 1080);
+    }
+}

package/lib/AppObjectComponents/zSpace/Entities/ZSpaceEntity.d.ts

@@ -0,0 +1,21 @@
+import { AppObject } from "../../../AppObject/AppObject";
+import { AppObjectEntity } from "../../../AppObject/AppObjectEntity";
+import { AppObjectRepo } from "../../../AppObject/AppObjectRepo";
+import { ZSpaceDisplayEntity } from "./ZSpaceDisplayEntity";
+import { ZSpaceStylusEntity } from "./ZSpaceStylusEntity";
+import { ZSpaceViewEntity } from "./ZSpaceViewEntity";
+export declare abstract class ZSpaceEntity extends AppObjectEntity {
+    static readonly type = "ZSpaceEntity";
+    abstract get enabled(): boolean;
+    abstract set enabled(val: boolean);
+    abstract get emulate(): boolean;
+    abstract set emulate(val: boolean);
+    abstract readonly viewerScale: number;
+    abstract readonly stylus: ZSpaceStylusEntity;
+    abstract readonly headView: ZSpaceViewEntity;
+    abstract readonly leftEyeView: ZSpaceViewEntity;
+    abstract readonly rightEyeView: ZSpaceViewEntity;
+    abstract readonly display: ZSpaceDisplayEntity;
+    static get(appObjects: AppObjectRepo): ZSpaceEntity | undefined;
+}
+export declare function makeZSpaceEntity(appObj: AppObject): ZSpaceEntity;

package/lib/AppObjectComponents/zSpace/Entities/ZSpaceEntity.js

@@ -0,0 +1,64 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.makeZSpaceEntity = exports.ZSpaceEntity = void 0;
+const AppObjectEntity_1 = require("../../../AppObject/AppObjectEntity");
+const Entities_1 = require("../../../Entities");
+const ZSpaceDisplayEntity_1 = require("./ZSpaceDisplayEntity");
+const ZSpaceStylusEntity_1 = require("./ZSpaceStylusEntity");
+const ZSpaceViewEntity_1 = require("./ZSpaceViewEntity");
+class ZSpaceEntity extends AppObjectEntity_1.AppObjectEntity {
+    static get(appObjects) {
+        const selectionEntities = appObjects.getAllComponents(ZSpaceEntity.type);
+        if (selectionEntities.length === 0) {
+            console.warn("Unable to find a ZSpaceEntity. Add one on Mount");
+            return undefined;
+        }
+        else if (selectionEntities.length > 1) {
+            console.warn("Multiple ZSpaceEntity have been found. There should only be one. Using the first one");
+        }
+        return selectionEntities[0];
+    }
+}
+exports.ZSpaceEntity = ZSpaceEntity;
+ZSpaceEntity.type = "ZSpaceEntity";
+function makeZSpaceEntity(appObj) {
+    return new ZSpaceImp(appObj);
+}
+exports.makeZSpaceEntity = makeZSpaceEntity;
+class ZSpaceImp extends ZSpaceEntity {
+    constructor(appObj) {
+        super(appObj, ZSpaceEntity.type);
+        this.viewerScale = 1;
+        this.memoizedEnabled = new Entities_1.MemoizedBoolean(false, this.notifyOnChange);
+        this.memoizedEmulate = new Entities_1.MemoizedBoolean(false, this.notifyOnChange);
+        this.memoizedIsRendering = new Entities_1.MemoizedBoolean(false, this.notifyOnChange);
+        const headView = appObj.appObjectRepo.getOrCreate("zSpaceHeadView");
+        this.headView = ZSpaceViewEntity_1.makeZSpaceView(headView, ZSpaceViewEntity_1.ZSapceViewType.CENTER);
+        const leftEye = appObj.appObjectRepo.getOrCreate("zSpaceLeftEyeView");
+        this.leftEyeView = ZSpaceViewEntity_1.makeZSpaceView(leftEye, ZSpaceViewEntity_1.ZSapceViewType.LEFT);
+        const rightEye = appObj.appObjectRepo.getOrCreate("zSpaceRightEyeView");
+        this.rightEyeView = ZSpaceViewEntity_1.makeZSpaceView(rightEye, ZSpaceViewEntity_1.ZSapceViewType.RIGHT);
+        const stylusAO = appObj.appObjectRepo.getOrCreate("zSpaceStylus");
+        this.stylus = ZSpaceStylusEntity_1.makeZSpaceStylus(stylusAO);
+        const displayAO = appObj.appObjectRepo.getOrCreate("zSpaceDisplay");
+        this.display = ZSpaceDisplayEntity_1.makeZSpaceDisplayEntity(displayAO);
+    }
+    get enabled() {
+        return this.memoizedEnabled.val;
+    }
+    set enabled(val) {
+        this.memoizedEnabled.val = val;
+    }
+    get emulate() {
+        return this.memoizedEmulate.val;
+    }
+    set emulate(val) {
+        this.memoizedEmulate.val = val;
+    }
+    get isRendering() {
+        return this.memoizedIsRendering.val;
+    }
+    set isRendering(val) {
+        this.memoizedIsRendering.val = val;
+    }
+}

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

@@ -0,0 +1,26 @@
+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;
+}
+export declare function makeZSpaceStylus(appObj: AppObject): ZSpaceStylusEntity;

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

@@ -0,0 +1,86 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.makeZSpaceStylus = exports.ZSpaceStylusEntity = exports.ZSpaceStylusButton = void 0;
+const AppObjectEntity_1 = require("../../../AppObject/AppObjectEntity");
+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.isClick = (button) => {
+            const buttonIsCorrect = button === this.lassPressedButton;
+            const movement = ValueObjects_1.Vector3.Subtract(this.transform.localPosition, this.pressPosition).magnitued;
+            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.controllers.forEach((controller) => {
+                if (controller.onStylusMove) {
+                    controller.onStylusMove(this.transform);
+                }
+            });
+        };
+        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()));
+    }
+}

package/lib/AppObjectComponents/zSpace/Entities/ZSpaceViewEntity.d.ts

@@ -0,0 +1,25 @@
+/// <reference types="webxr" />
+import { AppObject } from "../../../AppObject/AppObject";
+import { AppObjectEntity } from "../../../AppObject/AppObjectEntity";
+import { Matrix, Quaternion, Vector3 } from "../../../ValueObjects";
+import { Transform3D } from "../../Transform3D";
+export interface UpdateDTO {
+    position: Vector3;
+    rotation: Quaternion;
+    projectionMatrix: Matrix;
+    view?: XRView;
+}
+export declare enum ZSapceViewType {
+    CENTER = "Center",
+    LEFT = "Left",
+    RIGHT = "Right"
+}
+export declare abstract class ZSpaceViewEntity extends AppObjectEntity {
+    static readonly type = "ZSpaceViewEntity";
+    abstract update(data: UpdateDTO): void;
+    abstract get view(): XRView | undefined;
+    abstract readonly transform: Transform3D;
+    abstract get projectionMatrix(): Matrix;
+    abstract readonly viewType: ZSapceViewType;
+}
+export declare function makeZSpaceView(appObj: AppObject, viewType: ZSapceViewType): ZSpaceViewEntity;

package/lib/AppObjectComponents/zSpace/Entities/ZSpaceViewEntity.js

@@ -0,0 +1,47 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.makeZSpaceView = exports.ZSpaceViewEntity = exports.ZSapceViewType = void 0;
+const AppObjectEntity_1 = require("../../../AppObject/AppObjectEntity");
+const ValueObjects_1 = require("../../../ValueObjects");
+const Transform3D_1 = require("../../Transform3D");
+var ZSapceViewType;
+(function (ZSapceViewType) {
+    ZSapceViewType["CENTER"] = "Center";
+    ZSapceViewType["LEFT"] = "Left";
+    ZSapceViewType["RIGHT"] = "Right";
+})(ZSapceViewType = exports.ZSapceViewType || (exports.ZSapceViewType = {}));
+class ZSpaceViewEntity extends AppObjectEntity_1.AppObjectEntity {
+}
+exports.ZSpaceViewEntity = ZSpaceViewEntity;
+ZSpaceViewEntity.type = "ZSpaceViewEntity";
+function makeZSpaceView(appObj, viewType) {
+    const transform = Transform3D_1.Transform3D.addIfMissing(appObj);
+    return new ZSpaceViewImp(appObj, viewType, transform);
+}
+exports.makeZSpaceView = makeZSpaceView;
+class ZSpaceViewImp extends ZSpaceViewEntity {
+    constructor(appObject, viewType, transform) {
+        super(appObject, ZSpaceViewEntity.type);
+        this._projectionMatrix = ValueObjects_1.Matrix.Identity();
+        this.viewType = viewType;
+        this.transform = transform;
+        this.transform.addChangeObserver(this.notifyOnChange);
+    }
+    update(data) {
+        this.transform.localPosition = data.position;
+        this.transform.localRotation = data.rotation;
+        this._projectionMatrix = data.projectionMatrix;
+        this._view = data.view;
+        this.notifyOnChange();
+    }
+    get view() {
+        return this._view;
+    }
+    submitView(view) {
+        this._view = view;
+        this.notifyOnChange();
+    }
+    get projectionMatrix() {
+        return this._projectionMatrix;
+    }
+}

package/lib/AppObjectComponents/zSpace/Factories/makeZSpace.d.ts

@@ -0,0 +1,3 @@
+import { AppObject } from "../../../AppObject/AppObject";
+import { AppObjectRepo } from "../../../AppObject/AppObjectRepo";
+export declare function makeZSpace(appObjectRepo: AppObjectRepo): AppObject;

package/lib/AppObjectComponents/zSpace/Factories/makeZSpace.js

@@ -0,0 +1,31 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.makeZSpace = void 0;
+const Transform3D_1 = require("../../Transform3D");
+const XR_1 = require("../../XR");
+const ZSpaceScaleRoot_1 = require("../Controllers/ZSpaceScaleRoot");
+const ZSpaceStylusRootMovement_1 = require("../Controllers/ZSpaceStylusRootMovement");
+const ZSpaceEntity_1 = require("../Entities/ZSpaceEntity");
+const ZSpaceDisplayPM_1 = require("../PM/ZSpaceDisplayPM");
+const ZSpaceIsEnabledPM_1 = require("../PM/ZSpaceIsEnabledPM");
+const StylusFromGamepadHook_1 = require("../UseCases/StylusFromGamepadHook");
+const StylusRootMovementUC_1 = require("../UseCases/StylusRootMovementUC");
+const ViewFromPoseHook_1 = require("../UseCases/ViewFromPoseHook");
+function makeZSpace(appObjectRepo) {
+    const zSpaceAO = appObjectRepo.getOrCreate("zSpace");
+    const zSpaceEntity = ZSpaceEntity_1.makeZSpaceEntity(zSpaceAO);
+    XR_1.makeXREntity(zSpaceAO);
+    ViewFromPoseHook_1.makeViewFromPoseHook(zSpaceAO);
+    StylusFromGamepadHook_1.makeStylusFromGamepadHook(zSpaceAO);
+    ZSpaceIsEnabledPM_1.makeZSpaceIsEnabledPM(zSpaceAO);
+    const stylusAO = zSpaceEntity.stylus.appObject;
+    new Transform3D_1.Transform3DPM(stylusAO);
+    StylusRootMovementUC_1.makeDefaultStylusRootMovementUC(stylusAO);
+    new ZSpaceStylusRootMovement_1.ZSpaceStylusRootMovement(stylusAO);
+    new ZSpaceScaleRoot_1.ZSpaceScaleRoot(stylusAO);
+    const displayAO = zSpaceEntity.display.appObject;
+    new Transform3D_1.Transform3DPM(displayAO);
+    ZSpaceDisplayPM_1.makeZSpaceDisplayPM(displayAO);
+    return zSpaceAO;
+}
+exports.makeZSpace = makeZSpace;

package/lib/AppObjectComponents/zSpace/PM/ZSpaceDisplayPM.d.ts

@@ -0,0 +1,12 @@
+import { AppObject } from "../../../AppObject/AppObject";
+import { AppObjectPM } from "../../../AppObject/AppObjectPM";
+import { Vector2 } from "../../../ValueObjects";
+export interface ZSpaceDisplayVM {
+    show: boolean;
+    pixelSize: Vector2;
+    worldSize: Vector2;
+}
+export declare abstract class ZSpaceDisplayPM extends AppObjectPM<ZSpaceDisplayVM> {
+    static readonly type = "ZSpaceDisplayPM";
+}
+export declare function makeZSpaceDisplayPM(appObject: AppObject): ZSpaceDisplayPM;

package/lib/AppObjectComponents/zSpace/PM/ZSpaceDisplayPM.js

@@ -0,0 +1,65 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.makeZSpaceDisplayPM = exports.ZSpaceDisplayPM = void 0;
+const AppObjectPM_1 = require("../../../AppObject/AppObjectPM");
+const ValueObjects_1 = require("../../../ValueObjects");
+const ZSpaceDisplayEntity_1 = require("../Entities/ZSpaceDisplayEntity");
+const ZSpaceEntity_1 = require("../Entities/ZSpaceEntity");
+class ZSpaceDisplayPM extends AppObjectPM_1.AppObjectPM {
+}
+exports.ZSpaceDisplayPM = ZSpaceDisplayPM;
+ZSpaceDisplayPM.type = "ZSpaceDisplayPM";
+function makeZSpaceDisplayPM(appObject) {
+    return new ZSpaceDisplayPMImp(appObject);
+}
+exports.makeZSpaceDisplayPM = makeZSpaceDisplayPM;
+class ZSpaceDisplayPMImp extends ZSpaceDisplayPM {
+    constructor(appObject) {
+        super(appObject, ZSpaceDisplayPM.type);
+        this.onEntityChange = () => {
+            var _a, _b;
+            if (!this.zSpaceDisplay)
+                return;
+            const show = (_b = (_a = this.zSpaceEntity) === null || _a === void 0 ? void 0 : _a.enabled) !== null && _b !== void 0 ? _b : false;
+            const vm = {
+                show,
+                pixelSize: this.zSpaceDisplay.displaySizePixels,
+                worldSize: this.zSpaceDisplay.displaySizeMeters
+            };
+            this.doUpdateView(vm);
+        };
+        this.dispose = () => {
+            var _a, _b, _c, _d;
+            super.dispose();
+            (_a = this.zSpaceDisplay) === null || _a === void 0 ? void 0 : _a.removeChangeObserver(this.onEntityChange);
+            (_b = this.zSpaceDisplay) === null || _b === void 0 ? void 0 : _b.removeOnDisposeObserver(this.dispose);
+            (_c = this.zSpaceEntity) === null || _c === void 0 ? void 0 : _c.removeChangeObserver(this.onEntityChange);
+            (_d = this.zSpaceEntity) === null || _d === void 0 ? void 0 : _d.removeOnDisposeObserver(this.dispose);
+        };
+        this.zSpaceDisplay = appObject.getComponent(ZSpaceDisplayEntity_1.ZSpaceDisplayEntity.type);
+        if (!this.zSpaceDisplay) {
+            console.error("[ZSpaceDisplayPM] App Object does not have a ZSpace Display Entity");
+            return;
+        }
+        this.zSpaceEntity = ZSpaceEntity_1.ZSpaceEntity.get(appObject.appObjectRepo);
+        if (!this.zSpaceEntity) {
+            console.error("[ZSpaceDisplayPM] Could not find a ZSpace Entity");
+            return;
+        }
+        this.zSpaceDisplay.addChangeObserver(this.onEntityChange);
+        this.zSpaceDisplay.addOnDisposeObserver(this.dispose);
+        this.zSpaceEntity.addChangeObserver(this.onEntityChange);
+        this.zSpaceEntity.addOnDisposeObserver(this.dispose);
+        this.onEntityChange();
+    }
+    vmsAreEqual(a, b) {
+        if (a.show === b.show &&
+            ValueObjects_1.Vector2.Equal(a.pixelSize, b.pixelSize) &&
+            ValueObjects_1.Vector2.Equal(a.worldSize, b.worldSize)) {
+            return true;
+        }
+        else {
+            return false;
+        }
+    }
+}

package/lib/AppObjectComponents/zSpace/PM/ZSpaceIsEnabledPM.d.ts

@@ -0,0 +1,6 @@
+import { AppObject } from "../../../AppObject/AppObject";
+import { AppObjectPM } from "../../../AppObject/AppObjectPM";
+export declare abstract class ZSpaceIsEnabledPM extends AppObjectPM<boolean> {
+    static readonly type = "ZSpaceIsEnabledPM";
+}
+export declare function makeZSpaceIsEnabledPM(appObject: AppObject): ZSpaceIsEnabledPM;

package/lib/AppObjectComponents/zSpace/PM/ZSpaceIsEnabledPM.js

@@ -0,0 +1,41 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.makeZSpaceIsEnabledPM = exports.ZSpaceIsEnabledPM = void 0;
+const AppObjectPM_1 = require("../../../AppObject/AppObjectPM");
+const ZSpaceEntity_1 = require("../Entities/ZSpaceEntity");
+class ZSpaceIsEnabledPM extends AppObjectPM_1.AppObjectPM {
+}
+exports.ZSpaceIsEnabledPM = ZSpaceIsEnabledPM;
+ZSpaceIsEnabledPM.type = "ZSpaceIsEnabledPM";
+function makeZSpaceIsEnabledPM(appObject) {
+    return new ZSpaceIsEnabledPMImp(appObject);
+}
+exports.makeZSpaceIsEnabledPM = makeZSpaceIsEnabledPM;
+class ZSpaceIsEnabledPMImp extends ZSpaceIsEnabledPM {
+    constructor(appObject) {
+        super(appObject, ZSpaceIsEnabledPM.type);
+        this.onRepoChange = () => {
+            if (!this.zSpace)
+                return;
+            this.doUpdateView(this.zSpace.enabled);
+        };
+        this.dispose = () => {
+            var _a, _b;
+            super.dispose();
+            (_a = this.zSpace) === null || _a === void 0 ? void 0 : _a.removeChangeObserver(this.onRepoChange);
+            (_b = this.zSpace) === null || _b === void 0 ? void 0 : _b.removeOnDisposeObserver(this.dispose);
+        };
+        this.zSpace = appObject.getComponent(ZSpaceEntity_1.ZSpaceEntity.type);
+        if (this.zSpace) {
+            this.zSpace.addChangeObserver(this.onRepoChange);
+            this.zSpace.addOnDisposeObserver(() => this.dispose());
+            this.onRepoChange();
+        }
+        else {
+            console.warn("[ZSpaceIsEnabledPMImp] App Object does not have a ZSpace Entity");
+        }
+    }
+    vmsAreEqual(a, b) {
+        return a === b;
+    }
+}

package/lib/AppObjectComponents/zSpace/UseCases/StylusFromGamepadHook.d.ts

@@ -0,0 +1,18 @@
+/// <reference types="webxr" />
+import { AppObject } from "../../../AppObject/AppObject";
+import { AppObjectUC } from "../../../AppObject/AppObjectUC";
+export declare abstract class StylusFromGamepadHook extends AppObjectUC {
+    static readonly type = "StylusFromGamepadHook";
+    abstract onNewXRFrame(frame: XRFrame): void;
+}
+export declare function makeStylusFromGamepadHook(appObj: AppObject): StylusFromGamepadUCImp;
+declare class StylusFromGamepadUCImp extends StylusFromGamepadHook {
+    private lastPresses;
+    private zSpace;
+    private xrEntity;
+    onNewXRFrame: () => void;
+    private processStylusPose;
+    private processButtons;
+    constructor(appObject: AppObject);
+}
+export {};

package/lib/AppObjectComponents/zSpace/UseCases/StylusFromGamepadHook.js

@@ -0,0 +1,79 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.makeStylusFromGamepadHook = exports.StylusFromGamepadHook = void 0;
+const AppObjectUC_1 = require("../../../AppObject/AppObjectUC");
+const ValueObjects_1 = require("../../../ValueObjects");
+const XR_1 = require("../../XR");
+const ZSpaceEntity_1 = require("../Entities/ZSpaceEntity");
+class StylusFromGamepadHook extends AppObjectUC_1.AppObjectUC {
+}
+exports.StylusFromGamepadHook = StylusFromGamepadHook;
+StylusFromGamepadHook.type = "StylusFromGamepadHook";
+function makeStylusFromGamepadHook(appObj) {
+    return new StylusFromGamepadUCImp(appObj);
+}
+exports.makeStylusFromGamepadHook = makeStylusFromGamepadHook;
+class StylusFromGamepadUCImp extends StylusFromGamepadHook {
+    constructor(appObject) {
+        super(appObject, StylusFromGamepadHook.type);
+        this.lastPresses = [false, false, false];
+        this.onNewXRFrame = () => {
+            const frame = this.xrEntity.lastXRFrame;
+            if (!frame)
+                return;
+            let stylusSource = null;
+            if (frame &&
+                frame.session.inputSources &&
+                frame.session.inputSources[0] &&
+                frame.session.inputSources[0].gripSpace) {
+                stylusSource = frame.session.inputSources[0];
+            }
+            if (stylusSource === null) {
+                console.log("No stylus source");
+                return;
+            }
+            this.processButtons(stylusSource);
+            if (!this.xrEntity.xrReferenceSpace) {
+                console.log("No reference space");
+                return;
+            }
+            let stylusPose = frame.getPose(stylusSource.targetRaySpace, this.xrEntity.xrReferenceSpace);
+            if (stylusPose)
+                this.processStylusPose(stylusPose);
+        };
+        const zSpaceEntity = appObject.getComponent(ZSpaceEntity_1.ZSpaceEntity.type);
+        if (!zSpaceEntity) {
+            throw new Error("No ZSpace Entity");
+        }
+        this.zSpace = zSpaceEntity;
+        const xrEntity = zSpaceEntity.appObject.getComponent(XR_1.XREntity.type);
+        if (!xrEntity) {
+            throw new Error("No XR Entity");
+        }
+        this.xrEntity = xrEntity;
+        this.xrEntity.addChangeObserver(this.onNewXRFrame);
+    }
+    processStylusPose(pose) {
+        const matrix = ValueObjects_1.Matrix.FromFloat32Array(pose.transform.matrix);
+        const flippedMatrix = ValueObjects_1.Matrix.FlipTransformMatrixHand(matrix);
+        this.zSpace.stylus.transform.localMatrix = flippedMatrix;
+    }
+    processButtons(stylusSource) {
+        var _a, _b, _c;
+        const gamepad = stylusSource.gamepad;
+        if (!gamepad) {
+            console.log("No gamepad");
+            return;
+        }
+        const presses = [false, false, false];
+        presses[0] = (_a = gamepad.buttons[0]) === null || _a === void 0 ? void 0 : _a.pressed;
+        presses[1] = (_b = gamepad.buttons[3]) === null || _b === void 0 ? void 0 : _b.pressed;
+        presses[2] = (_c = gamepad.buttons[4]) === null || _c === void 0 ? void 0 : _c.pressed;
+        presses.forEach((press, i) => {
+            if (this.lastPresses[i] !== press) {
+                this.lastPresses[i] = press;
+                this.zSpace.stylus.updateButtonState(i, press);
+            }
+        });
+    }
+}

package/lib/AppObjectComponents/zSpace/UseCases/StylusRootMovementUC.d.ts

@@ -0,0 +1,12 @@
+import { AppObject } from "../../../AppObject/AppObject";
+import { AppObjectRepo } from "../../../AppObject/AppObjectRepo";
+import { AppObjectUC } from "../../../AppObject/AppObjectUC";
+import { ParametricLine } from "../../../ValueObjects";
+export declare abstract class StylusRootMovementUC extends AppObjectUC {
+    static readonly type = "StylusRootMovementUC";
+    abstract initialize(ray: ParametricLine, appObject?: AppObject): boolean;
+    abstract move(ray: ParametricLine): void;
+    abstract stop(): void;
+    static get(appObjects: AppObjectRepo): StylusRootMovementUC | undefined;
+}
+export declare function makeDefaultStylusRootMovementUC(appObject: AppObject): StylusRootMovementUC;