@vived/app 4.11.3 → 4.13.0

package/lib/Components/Stylus/Mocks/MockEmulateStylusUC.js

@@ -0,0 +1,19 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.makeMockEmulateStylusUC = exports.MockEmulateStylusUC = void 0;
+const EmulateStylusUC_1 = require("../UCs/EmulateStylusUC");
+class MockEmulateStylusUC extends EmulateStylusUC_1.EmulateStylusUC {
+    constructor(appObject) {
+        super(appObject, EmulateStylusUC_1.EmulateStylusUC.type);
+        this.startEmulating = jest.fn();
+        this.stopEmulating = jest.fn();
+    }
+    get isEmulating() {
+        throw new Error("Method not implemented.");
+    }
+}
+exports.MockEmulateStylusUC = MockEmulateStylusUC;
+function makeMockEmulateStylusUC(appObjects) {
+    return new MockEmulateStylusUC(appObjects.getOrCreate("MockEmulateStylusUC"));
+}
+exports.makeMockEmulateStylusUC = makeMockEmulateStylusUC;

package/lib/Components/Stylus/Mocks/index.d.ts

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

package/lib/Components/Stylus/Mocks/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("./MockEmulateStylusUC"), exports);

package/lib/Components/Stylus/PMs/StylusColorLengthPM.d.ts

@@ -0,0 +1,14 @@
+import { AppObject, AppObjectPM, AppObjectRepo } 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;
+    static get(appObjects: AppObjectRepo): StylusColorLengthPM | undefined;
+}
+export declare function makeStylusColorLengthPM(appObject: AppObject): StylusColorLengthPM;

package/lib/Components/Stylus/PMs/StylusColorLengthPM.js

@@ -0,0 +1,81 @@
+"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 StylusEntity_1 = require("../Entity/StylusEntity");
+class StylusColorLengthPM extends AppObject_1.AppObjectPM {
+    static get(appObjects) {
+        return AppObject_1.getSingletonComponent(StylusColorLengthPM.type, appObjects);
+    }
+}
+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(StylusEntity_1.StylusEntity.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");
+        }
+        this.appObjects.registerSingleton(this);
+    }
+    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/Stylus/PMs/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/Stylus/PMs/StylusIsInUsePM.js

@@ -0,0 +1,36 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.makeStylusIsInUsePM = exports.StylusIsInUsePM = void 0;
+const AppObject_1 = require("../../../AppObject");
+const StylusEntity_1 = require("../Entity/StylusEntity");
+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.onStylusChange = () => {
+            if (!this.stylus)
+                return;
+            this.doUpdateView(this.stylus.isInUse);
+        };
+        this.stylus = appObject.getComponent(StylusEntity_1.StylusEntity.type);
+        if (this.stylus) {
+            this.stylus.addChangeObserver(this.onStylusChange);
+            this.onStylusChange();
+        }
+        else {
+            this.warn("App Object does not have a Stylus Entity");
+        }
+        this.appObjects.registerSingleton(this);
+    }
+    vmsAreEqual(a, b) {
+        return a === b;
+    }
+}

package/lib/Components/Stylus/PMs/index.d.ts

@@ -0,0 +1,2 @@
+export * from "./StylusColorLengthPM";
+export * from "./StylusIsInUsePM";

package/lib/Components/Stylus/PMs/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("./StylusColorLengthPM"), exports);
+__exportStar(require("./StylusIsInUsePM"), exports);

package/lib/Components/Stylus/UCs/EmulateStylusUC.d.ts

@@ -0,0 +1,9 @@
+import { AppObject, AppObjectRepo, AppObjectUC } from "../../../AppObject";
+export declare abstract class EmulateStylusUC extends AppObjectUC {
+    static type: string;
+    abstract get isEmulating(): boolean;
+    abstract startEmulating(): void;
+    abstract stopEmulating(): void;
+    static get(appObjects: AppObjectRepo): EmulateStylusUC | undefined;
+}
+export declare function makeEmulateStylusUC(appObject: AppObject): EmulateStylusUC;

package/lib/Components/Stylus/UCs/EmulateStylusUC.js

@@ -0,0 +1,132 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.makeEmulateStylusUC = exports.EmulateStylusUC = void 0;
+const AppObject_1 = require("../../../AppObject");
+const ValueObjects_1 = require("../../../ValueObjects");
+const Babylon_1 = require("../../Babylon");
+const MouseInput_1 = require("../../MouseInput");
+const TouchController_1 = require("../../TouchController");
+const StylusEntity_1 = require("../Entity/StylusEntity");
+class EmulateStylusUC extends AppObject_1.AppObjectUC {
+    static get(appObjects) {
+        return AppObject_1.getSingletonComponent(EmulateStylusUC.type, appObjects);
+    }
+}
+exports.EmulateStylusUC = EmulateStylusUC;
+EmulateStylusUC.type = "EmulateStylusUC";
+function makeEmulateStylusUC(appObject) {
+    return new EmulateStylusUCImp(appObject);
+}
+exports.makeEmulateStylusUC = makeEmulateStylusUC;
+class EmulateStylusUCImp extends EmulateStylusUC {
+    constructor(appObject) {
+        super(appObject, EmulateStylusUC.type);
+        this._eventElement = undefined;
+        this.lastMousePos = ValueObjects_1.Vector2.Zero();
+        this._isEmulating = false;
+        this.screenPlane = ValueObjects_1.ParametricPlane.FromPointNormal(ValueObjects_1.Vector3.Zero(), ValueObjects_1.Vector3.Backward());
+        this.startEmulating = () => {
+            var _a;
+            if (!this.mouseInput)
+                return;
+            if (!this.stylus)
+                return;
+            if (this._isEmulating === true)
+                return;
+            this._eventElement = this.mouseInput.eventElement;
+            if (!this._eventElement) {
+                this.warn("No event element");
+                return;
+            }
+            this.mouseInput.clearInputElement();
+            (_a = this.touchInput) === null || _a === void 0 ? void 0 : _a.clearInputElement();
+            this._eventElement.addEventListener("mousedown", this.onMouseDown, false);
+            this._eventElement.addEventListener("mouseup", this.onMouseUp, false);
+            this._eventElement.addEventListener("mousemove", this.onMouseMove, false);
+            this._eventElement.addEventListener("keydown", this.submitKeyDown, false);
+            this.stylus.transform.localPosition = new ValueObjects_1.Vector3(0.05, -0.05, -0.5);
+            this._isEmulating = true;
+        };
+        this.stopEmulating = () => {
+            var _a;
+            if (!this.mouseInput)
+                return;
+            if (this._isEmulating === false)
+                return;
+            if (this._eventElement) {
+                this._eventElement.removeEventListener("mousedown", this.onMouseDown, false);
+                this._eventElement.removeEventListener("mouseup", this.onMouseUp, false);
+                this._eventElement.removeEventListener("mousemove", this.onMouseMove, false);
+                this._eventElement.removeEventListener("keydown", this.submitKeyDown, false);
+                this.mouseInput.setEventElement(this._eventElement);
+                (_a = this.touchInput) === null || _a === void 0 ? void 0 : _a.setEventElement(this._eventElement);
+            }
+            this._eventElement = undefined;
+            this._isEmulating = false;
+        };
+        this.submitKeyDown = (e) => {
+            const bumpAmount = 0.01;
+            let bump = ValueObjects_1.Vector3.Zero();
+            switch (e.code) {
+                case "KeyA":
+                    bump = new ValueObjects_1.Vector3(-bumpAmount, 0, 0);
+                    break;
+                case "KeyD":
+                    bump = new ValueObjects_1.Vector3(bumpAmount, 0, 0);
+                    break;
+                case "KeyW":
+                    bump = new ValueObjects_1.Vector3(0, 0, bumpAmount);
+                    break;
+                case "KeyS":
+                    bump = new ValueObjects_1.Vector3(0, 0, -bumpAmount);
+                    break;
+            }
+            if (!this.stylus)
+                return;
+            const currentPos = this.stylus.transform.localPosition;
+            this.stylus.transform.localPosition = ValueObjects_1.Vector3.Add(currentPos, bump);
+            this.pointAtMouse(this.lastMousePos);
+        };
+        this.onMouseDown = (e) => {
+            if (!this.stylus)
+                return;
+            this.stylus.updateButtonState(e.button, true);
+        };
+        this.onMouseUp = (e) => {
+            if (!this.stylus)
+                return;
+            this.stylus.updateButtonState(e.button, false);
+        };
+        this.onMouseMove = (e) => {
+            const px = e.offsetX;
+            const py = e.offsetY;
+            const pos = new ValueObjects_1.Vector2(px, py);
+            this.pointAtMouse(pos);
+            this.lastMousePos = pos;
+        };
+        this.pointAtMouse = (pos) => {
+            if (!this.stylus)
+                return;
+            const ray = Babylon_1.pixelToSceneRay(pos, this.appObjects);
+            const hit = this.screenPlane.intersectLine(ray);
+            if (!hit) {
+                return;
+            }
+            const direction = ValueObjects_1.Vector3.Subtract(hit, this.stylus.transform.localPosition);
+            this.stylus.transform.localRotation = ValueObjects_1.Quaternion.FromDirectionVector(direction);
+        };
+        this.appObjects.registerSingleton(this);
+    }
+    get mouseInput() {
+        return this.getCachedSingleton(MouseInput_1.MouseInputEntity.type);
+    }
+    get touchInput() {
+        return this.getCachedSingleton(TouchController_1.TouchInputEntity.type);
+    }
+    get stylus() {
+        return this.getCachedSingleton(StylusEntity_1.StylusEntity.type);
+    }
+    get isEmulating() {
+        return this._isEmulating;
+    }
+}

package/lib/Components/Stylus/UCs/index.d.ts

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

package/lib/Components/Stylus/UCs/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("./EmulateStylusUC"), exports);

package/lib/Components/Stylus/index.d.ts

@@ -0,0 +1,4 @@
+export * from "./Entity";
+export * from "./Mocks";
+export * from "./PMs";
+export * from "./UCs";

package/lib/Components/Stylus/index.js

@@ -0,0 +1,16 @@
+"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"), exports);
+__exportStar(require("./Mocks"), exports);
+__exportStar(require("./PMs"), exports);
+__exportStar(require("./UCs"), exports);

package/lib/Components/Transform3D/UC/StylusMoveTransformUC.js

@@ -5,8 +5,9 @@ const __1 = require("..");
 const AppObjectUC_1 = require("../../../AppObject/AppObjectUC");
 const ValueObjects_1 = require("../../../ValueObjects");
 const Dispatcher_1 = require("../../Dispatcher");
+const Stylus_1 = require("../../Stylus");
 const UndoRedo_1 = require("../../UndoRedo");
-const ZSpaceEntity_1 = require("../../zSpace/Entities/ZSpaceEntity");
+const Entities_1 = require("../Entities");
 const MoveTransformUndoRedo_1 = require("./MoveTransformUndoRedo");
 class StylusMoveTransformUC extends AppObjectUC_1.AppObjectUC {
     static get(appObject) {
@@ -33,8 +34,8 @@ class StylusMoveTransformUCImp extends StylusMoveTransformUC {
                 return;
             if (!this.stylus)
                 return;
-            this.transform.worldPosition = this.stylus.helperTransform.worldPosition;
-            this.transform.worldRotation = this.stylus.helperTransform.worldRotation;
+            this.transform.worldPosition = this.helperTransform.worldPosition;
+            this.transform.worldRotation = this.helperTransform.worldRotation;
             this.didMove = true;
         };
         this.stop = (registerUndo = false) => {
@@ -54,43 +55,21 @@ class StylusMoveTransformUCImp extends StylusMoveTransformUC {
             this.isMoving = false;
             this.didMove = false;
         };
-        const appObjects = appObject.appObjectRepo;
-        this.transform = appObject.getComponent(__1.Transform3D.type);
-        if (!this.transform) {
-            this.warn("StylusMoveTransformUCImp has been added to an app object that does not have a Transform3D. Add one first");
-            return;
+        this.transform = __1.Transform3D.addIfMissing(this.appObject);
+        const helperAO = this.appObjects.getOrCreate(this.appObject.id + "_helper");
+        this.helperTransform = Entities_1.makeTransform3D(helperAO);
+        if (this.stylus) {
+            this.helperTransform.parent = this.stylus.transform;
         }
     }
     get dispatchStateChange() {
-        if (!this._cachedDispatchStateChange) {
-            this._cachedDispatchStateChange = Dispatcher_1.DispatchStateChangeUC.get(this.appObject.appObjectRepo);
-            if (!this._cachedDispatchStateChange) {
-                this.warn("Unable to find DispatchStateChangeUC");
-                return;
-            }
-        }
-        return this._cachedDispatchStateChange;
+        return this.getCachedSingleton(Dispatcher_1.DispatchStateChangeUC.type);
     }
     get undoRedoEntity() {
-        if (!this._cachedUndoRedo) {
-            this._cachedUndoRedo = UndoRedo_1.UndoRedoEntity.get(this.appObject.appObjectRepo);
-            if (!this._cachedUndoRedo) {
-                this.warn("Unable to find UndoRedoEntity");
-                return;
-            }
-        }
-        return this._cachedUndoRedo;
+        return this.getCachedSingleton(UndoRedo_1.UndoRedoEntity.type);
     }
     get stylus() {
-        if (!this._cachedStylus) {
-            const zSpaceEntity = ZSpaceEntity_1.ZSpaceEntity.get(this.appObject.appObjectRepo);
-            if (!zSpaceEntity) {
-                this.warn("Unable to find ZSpaceEntity");
-                return;
-            }
-            this._cachedStylus = zSpaceEntity.stylus;
-        }
-        return this._cachedStylus;
+        return this.getCachedSingleton(Stylus_1.StylusEntity.type);
     }
     initialize() {
         if (!this.transform)
@@ -99,8 +78,8 @@ class StylusMoveTransformUCImp extends StylusMoveTransformUC {
             return false;
         this.initialPosition = this.transform.localPosition;
         this.initialRotation = this.transform.localRotation;
-        this.stylus.helperTransform.worldPosition = this.transform.worldPosition;
-        this.stylus.helperTransform.worldRotation = this.transform.worldRotation;
+        this.helperTransform.worldPosition = this.transform.worldPosition;
+        this.helperTransform.worldRotation = this.transform.worldRotation;
         this.isMoving = true;
         return;
     }

package/lib/Components/index.d.ts

@@ -6,23 +6,24 @@ export * from "./Dispatcher";
 export * from "./Enablement";
 export * from "./FramedScreen";
 export * from "./Hideable";
+export * from "./HoverLabel";
 export * from "./KeyboardInput";
 export * from "./Label";
+export * from "./Landmarks";
 export * from "./Mesh";
 export * from "./MouseInput";
 export * from "./OverlayColor";
 export * from "./Question";
 export * from "./RequestHandler";
 export * from "./SceneRoot";
+export * from "./Selection";
 export * from "./StateMachine";
-export * from "./ThemeColors";
 export * from "./StoredView";
+export * from "./Stylus";
+export * from "./ThemeColors";
 export * from "./Tools";
 export * from "./TouchController";
 export * from "./Transform3D";
 export * from "./UndoRedo";
 export * from "./XR";
 export * from "./zSpace";
-export * from "./Selection";
-export * from "./Landmarks";
-export * from "./HoverLabel";

package/lib/Components/index.js

@@ -18,23 +18,24 @@ __exportStar(require("./Dispatcher"), exports);
 __exportStar(require("./Enablement"), exports);
 __exportStar(require("./FramedScreen"), exports);
 __exportStar(require("./Hideable"), exports);
+__exportStar(require("./HoverLabel"), exports);
 __exportStar(require("./KeyboardInput"), exports);
 __exportStar(require("./Label"), exports);
+__exportStar(require("./Landmarks"), exports);
 __exportStar(require("./Mesh"), exports);
 __exportStar(require("./MouseInput"), exports);
 __exportStar(require("./OverlayColor"), exports);
 __exportStar(require("./Question"), exports);
 __exportStar(require("./RequestHandler"), exports);
 __exportStar(require("./SceneRoot"), exports);
+__exportStar(require("./Selection"), exports);
 __exportStar(require("./StateMachine"), exports);
-__exportStar(require("./ThemeColors"), exports);
 __exportStar(require("./StoredView"), exports);
+__exportStar(require("./Stylus"), exports);
+__exportStar(require("./ThemeColors"), exports);
 __exportStar(require("./Tools"), exports);
 __exportStar(require("./TouchController"), exports);
 __exportStar(require("./Transform3D"), exports);
 __exportStar(require("./UndoRedo"), exports);
 __exportStar(require("./XR"), exports);
 __exportStar(require("./zSpace"), exports);
-__exportStar(require("./Selection"), exports);
-__exportStar(require("./Landmarks"), exports);
-__exportStar(require("./HoverLabel"), exports);

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

@@ -1,9 +1,10 @@
 import { AppObject, AppObjectController } from "../../../AppObject";
-import { MouseController, MouseInputEvent } from "../../MouseInput";
+import { MouseController, MouseInputEvent, MouseWheelEvent } 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;
+    abstract onWheel: (e: MouseWheelEvent) => void;
 }
 export declare function makeEmulateZSpaceStylus(appObject: AppObject): EmulateZSpaceStylus;

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

@@ -47,6 +47,19 @@ class EmulateZSpaceStylusImp extends EmulateZSpaceStylus {
                 return;
             this.stylus.updateButtonState(e.button, false);
         };
+        this.onWheel = (e) => {
+            if (!this.emulationIsActive)
+                return;
+            if (!this.stylus)
+                return;
+            if (!this.stylusTransform)
+                return;
+            const bumpAmount = 0.01;
+            const bump = e.event.deltaY > 0 ? -bumpAmount : bumpAmount;
+            const newPos = this.stylusTransform.localPointToWorld(new ValueObjects_1.Vector3(0, 0, bump));
+            this.stylusTransform.worldPosition = newPos;
+            console.log(newPos);
+        };
         this.onZpsaceEnabledChange = (enabled) => {
             this.emulationIsActive = false;
             if (!enabled)

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

@@ -2,7 +2,6 @@ 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 const INSPIRE_WIDTH: number;
 export declare abstract class ZSpaceEntity extends AppObjectEntity {
@@ -15,7 +14,6 @@ export declare abstract class ZSpaceEntity extends AppObjectEntity {
     abstract set emulate(val: boolean);
     abstract get viewerScale(): number;
     abstract set viewerScale(val: number);
-    abstract readonly stylus: ZSpaceStylusEntity;
     abstract readonly headView: ZSpaceViewEntity;
     abstract readonly leftEyeView: ZSpaceViewEntity;
     abstract readonly rightEyeView: ZSpaceViewEntity;

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

@@ -5,7 +5,6 @@ const AppObject_1 = require("../../../AppObject");
 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");
 exports.INSPIRE_WIDTH = 0.344;
 class ZSpaceEntity extends AppObjectEntity_1.AppObjectEntity {
@@ -34,8 +33,6 @@ class ZSpaceImp extends ZSpaceEntity {
         this.leftEyeView = ZSpaceViewEntity_1.makeZSpaceView(leftEye, ZSpaceViewEntity_1.ZSpaceViewType.LEFT);
         const rightEye = appObj.appObjectRepo.getOrCreate("zSpaceRightEyeView");
         this.rightEyeView = ZSpaceViewEntity_1.makeZSpaceView(rightEye, ZSpaceViewEntity_1.ZSpaceViewType.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);
     }

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

@@ -1,4 +1,3 @@
 export * from "./ZSpaceDisplayEntity";
 export * from "./ZSpaceEntity";
-export * from "./ZSpaceStylusEntity";
 export * from "./ZSpaceViewEntity";

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

@@ -12,5 +12,4 @@ var __exportStar = (this && this.__exportStar) || function(m, exports) {
 Object.defineProperty(exports, "__esModule", { value: true });
 __exportStar(require("./ZSpaceDisplayEntity"), exports);
 __exportStar(require("./ZSpaceEntity"), exports);
-__exportStar(require("./ZSpaceStylusEntity"), exports);
 __exportStar(require("./ZSpaceViewEntity"), exports);

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

@@ -1,5 +1,3 @@
-export * from "./StylusColorLengthPM";
-export * from "./StylusIsInUsePM";
 export * from "./ZSpaceDisplayPM";
 export * from "./ZSpaceIsEnabledPM";
 export * from "./ZSpaceIsSupportedPM";

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

@@ -10,8 +10,6 @@ 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("./StylusColorLengthPM"), exports);
-__exportStar(require("./StylusIsInUsePM"), exports);
 __exportStar(require("./ZSpaceDisplayPM"), exports);
 __exportStar(require("./ZSpaceIsEnabledPM"), exports);
 __exportStar(require("./ZSpaceIsSupportedPM"), exports);

package/lib/Components/zSpace/UC/StylusFromGamepadHook.d.ts

@@ -1,6 +1,5 @@
 /// <reference types="webxr" />
-import { AppObject } from "../../../AppObject/AppObject";
-import { AppObjectUC } from "../../../AppObject/AppObjectUC";
+import { AppObject, AppObjectUC } from "../../../AppObject";
 export declare abstract class StylusFromGamepadHook extends AppObjectUC {
     static readonly type = "StylusFromGamepadHook";
     abstract onNewXRFrame(frame: XRFrame): void;
@@ -8,7 +7,7 @@ export declare abstract class StylusFromGamepadHook extends AppObjectUC {
 export declare function makeStylusFromGamepadHook(appObj: AppObject): StylusFromGamepadUCImp;
 declare class StylusFromGamepadUCImp extends StylusFromGamepadHook {
     private lastPresses;
-    private zSpace;
+    private get stylus();
     private xrEntity?;
     onNewXRFrame: () => void;
     private processStylusPose;