@vived/app 4.12.0 → 4.14.0

package/lib/Components/HoverLabel/Controllers/StylusHoverLabel.d.ts

@@ -1,6 +1,6 @@
 import { AppObject, AppObjectController } from "../../../AppObject";
-import { ZSpaceStylusController } from "../../zSpace";
-export declare abstract class ZSpaceStylusHoverLabel extends AppObjectController implements ZSpaceStylusController {
+import { StylusController } from "../../Stylus";
+export declare abstract class ZSpaceStylusHoverLabel extends AppObjectController implements StylusController {
     static readonly type = "StylusHoverLabelController";
     abstract onStylusMove(): void;
     abstract allow: () => boolean;

package/lib/Components/HoverLabel/Controllers/StylusHoverLabel.js

@@ -2,7 +2,7 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.makeStylusHoverLabelController = exports.ZSpaceStylusHoverLabel = void 0;
 const AppObject_1 = require("../../../AppObject");
-const zSpace_1 = require("../../zSpace");
+const Stylus_1 = require("../../Stylus");
 const UseCases_1 = require("../UseCases");
 class ZSpaceStylusHoverLabel extends AppObject_1.AppObjectController {
 }
@@ -28,10 +28,10 @@ class ZSpaceStylusHoverLabelImp extends ZSpaceStylusHoverLabel {
             }
             (_a = this.tryShowStylusHoverLabel) === null || _a === void 0 ? void 0 : _a.tryShowWorldHoverLabel(this.stylus.pickRay);
         };
-        this.stylus = zSpace_1.ZSpaceStylusEntity.get(this.appObjects);
+        this.stylus = Stylus_1.StylusEntity.get(this.appObjects);
         this.tryShowStylusHoverLabel = UseCases_1.TryShowHoverLabel.get(this.appObjects);
         if (!this.stylus) {
-            this.error("Cannot find ZSpaceStylusEntity");
+            this.error("Cannot find StylusEntity");
         }
         else if (!this.tryShowStylusHoverLabel) {
             this.error("Cannot find TryShowHoverLabel");

package/lib/Components/Question/Entities/QuestionAnswerEntity.d.ts

@@ -5,7 +5,6 @@ export declare const MAX_QUESTION_LENGTH = 40;
 export declare const LONG_TEXT_VALIDATION_MESSAGE: string;
 export declare const MAX_FEEDBACK_LENGTH = 200;
 export declare const LONG_FEEDBACK_VALIDATION_MESSAGE: string;
-export declare const FEEDBACK_STRING_CANNOT_BE_0_CHARACTERS = "Feedback string cannot be 0 characters.";
 export declare abstract class QuestionAnswerEntity extends AppObjectEntity {
     static readonly type = "QuestionAnswerEntity";
     abstract readonly id: string;

package/lib/Components/Question/Entities/QuestionAnswerEntity.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.makeQuestionAnswerEntity = exports.QuestionAnswerEntity = exports.FEEDBACK_STRING_CANNOT_BE_0_CHARACTERS = exports.LONG_FEEDBACK_VALIDATION_MESSAGE = exports.MAX_FEEDBACK_LENGTH = exports.LONG_TEXT_VALIDATION_MESSAGE = exports.MAX_QUESTION_LENGTH = exports.EMPTY_TEXT_VALIDATION_MESSAGE = void 0;
+exports.makeQuestionAnswerEntity = exports.QuestionAnswerEntity = exports.LONG_FEEDBACK_VALIDATION_MESSAGE = exports.MAX_FEEDBACK_LENGTH = exports.LONG_TEXT_VALIDATION_MESSAGE = exports.MAX_QUESTION_LENGTH = exports.EMPTY_TEXT_VALIDATION_MESSAGE = void 0;
 const AppObjectEntity_1 = require("../../../AppObject/AppObjectEntity");
 const Entities_1 = require("../../../Entities");
 exports.EMPTY_TEXT_VALIDATION_MESSAGE = "Answer text is required.";
@@ -8,7 +8,6 @@ exports.MAX_QUESTION_LENGTH = 40;
 exports.LONG_TEXT_VALIDATION_MESSAGE = `Answer text may not exceed ${exports.MAX_QUESTION_LENGTH} characters.`;
 exports.MAX_FEEDBACK_LENGTH = 200;
 exports.LONG_FEEDBACK_VALIDATION_MESSAGE = `Answer feedback may not exceed ${exports.MAX_FEEDBACK_LENGTH} characters.`;
-exports.FEEDBACK_STRING_CANNOT_BE_0_CHARACTERS = "Feedback string cannot be 0 characters.";
 class QuestionAnswerEntity extends AppObjectEntity_1.AppObjectEntity {
 }
 exports.QuestionAnswerEntity = QuestionAnswerEntity;
@@ -52,10 +51,7 @@ class QuestionAnswerEntityImp extends QuestionAnswerEntity {
         this.memoizedFeedback.val = val;
     }
     get feedbackValidationMessage() {
-        if (this.feedbackText.length === 0) {
-            return exports.FEEDBACK_STRING_CANNOT_BE_0_CHARACTERS;
-        }
-        else if (this.feedbackText.length > exports.MAX_FEEDBACK_LENGTH) {
+        if (this.feedbackText.length > exports.MAX_FEEDBACK_LENGTH) {
             return exports.LONG_FEEDBACK_VALIDATION_MESSAGE;
         }
         else {

package/lib/Components/RequestHandler/UC/StartZSpaceUC.js

@@ -2,6 +2,7 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.makeStartZSpaceUC = exports.StartZSpaceBaseUC = void 0;
 const AppObjectUC_1 = require("../../../AppObject/AppObjectUC");
+const Stylus_1 = require("../../Stylus");
 const XR_1 = require("../../XR");
 const zSpace_1 = require("../../zSpace");
 const Entities_1 = require("../Entities");
@@ -35,7 +36,17 @@ class StartZSpaceBaseUCImp extends StartZSpaceBaseUC {
             }
             zSpaceEntity.display.setForDevice(zSpace_1.ZSpaceDevice.INSPIRE);
             zSpaceEntity.emulate = emulate;
-            if (!emulate) {
+            if (emulate) {
+                const emulateStylus = Stylus_1.EmulateStylusUC.get(appObjects);
+                if (emulateStylus) {
+                    emulateStylus.startEmulating();
+                }
+                else {
+                    appObjects.submitWarning("startZSpaceAction", "EmulateStylusUC not found");
+                    return;
+                }
+            }
+            else {
                 const xrSession = session;
                 if (!xrSession) {
                     this.warn("Unable to cast the XR session");

package/lib/Components/RequestHandler/UC/StopZSpaceUC.js

@@ -2,6 +2,7 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.makeStopZSpaceUC = exports.StopZSpaceUC = void 0;
 const AppObjectUC_1 = require("../../../AppObject/AppObjectUC");
+const Stylus_1 = require("../../Stylus");
 const XR_1 = require("../../XR");
 const zSpace_1 = require("../../zSpace");
 const Entities_1 = require("../Entities");
@@ -24,18 +25,30 @@ class StopZSpaceUCImp extends StopZSpaceUC {
         this.action = () => {
             const appObjects = this.appObject.appObjectRepo;
             const zSpaceEntity = zSpace_1.ZSpaceEntity.get(appObjects);
-            if (!zSpaceEntity) {
-                console.warn("No zSpace Entity Found");
+            if (zSpaceEntity) {
+                zSpaceEntity.enabled = false;
+                zSpaceEntity.emulate = false;
+            }
+            else {
+                appObjects.submitError("stopZSpaceAction", "No zSpace Entity Found");
                 return;
             }
             const renderUC = zSpaceEntity.appObject.getComponent(XR_1.RenderToXR.type);
-            if (!renderUC) {
-                console.warn("No renderUC found");
+            if (renderUC) {
+                renderUC.stopRenderingXR();
+            }
+            else {
+                appObjects.submitError("stopZSpaceAction", "No renderUC found");
+                return;
+            }
+            const emulateStylus = Stylus_1.EmulateStylusUC.get(appObjects);
+            if (emulateStylus) {
+                emulateStylus.stopEmulating();
+            }
+            else {
+                appObjects.submitWarning("stopZSpaceAction", "EmulateStylusUC not found");
                 return;
             }
-            renderUC.stopRenderingXR();
-            zSpaceEntity.enabled = false;
-            zSpaceEntity.emulate = false;
         };
         this.handleRequest = (version) => {
             if (version === this.payloadVersion) {

package/lib/Components/SceneRoot/Controllers/ScaleSceneRootSC.d.ts

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

package/lib/Components/SceneRoot/Controllers/ScaleSceneRootSC.js

@@ -0,0 +1,55 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ScaleSceneRootSC = void 0;
+const AppObjectController_1 = require("../../../AppObject/AppObjectController");
+const ScaleSceneRootWithRay_1 = require("../UC/ScaleSceneRootWithRay");
+const Stylus_1 = require("../../Stylus");
+class ScaleSceneRootSC extends AppObjectController_1.AppObjectController {
+    constructor(appObject) {
+        super(appObject, ScaleSceneRootSC.type);
+        this.isScaling = false;
+        this.allow = (button) => {
+            if (button === 1)
+                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 = Stylus_1.StylusEntity.get(this.appObjects);
+        if (!this.stylus) {
+            this.warn("Unable to find StylusEntity");
+            return;
+        }
+        this.scaleSceneRootWithRay = appObject.getComponent(ScaleSceneRootWithRay_1.ScaleSceneRootWithRay.type);
+        if (!this.scaleSceneRootWithRay) {
+            this.error("StylusMoveSceneRoot has been added to an App Object that does not have a scaleSceneRootWithRay");
+            return;
+        }
+        this.stylus.registerController(this);
+    }
+}
+exports.ScaleSceneRootSC = ScaleSceneRootSC;
+ScaleSceneRootSC.type = "ScaleSceneRootSC";

package/lib/Components/SceneRoot/Controllers/SceneRootMoveSC.d.ts

@@ -0,0 +1,14 @@
+import { AppObject } from "../../../AppObject/AppObject";
+import { AppObjectController } from "../../../AppObject/AppObjectController";
+import { StylusController } from "../../Stylus";
+export declare class SceneRootMoveSC extends AppObjectController implements StylusController {
+    static readonly type = "SceneRootMoveSC";
+    private stylus?;
+    private stylusRootMovementUC?;
+    private isMoving;
+    allow: (button: number) => boolean;
+    onButtonDown: (button: number) => void;
+    onButtonUp: () => void;
+    onStylusMove: () => void;
+    constructor(appObject: AppObject);
+}

package/lib/Components/SceneRoot/Controllers/SceneRootMoveSC.js

@@ -0,0 +1,53 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SceneRootMoveSC = void 0;
+const AppObjectController_1 = require("../../../AppObject/AppObjectController");
+const Stylus_1 = require("../../Stylus");
+const StylusMoveTransformUC_1 = require("../../Transform3D/UC/StylusMoveTransformUC");
+class SceneRootMoveSC extends AppObjectController_1.AppObjectController {
+    constructor(appObject) {
+        super(appObject, SceneRootMoveSC.type);
+        this.isMoving = false;
+        this.allow = (button) => {
+            if (button === 0)
+                return true;
+            return false;
+        };
+        this.onButtonDown = (button) => {
+            var _a;
+            this.isMoving = false;
+            if (!this.stylus)
+                return;
+            if (!this.allow(button))
+                return;
+            (_a = this.stylusRootMovementUC) === null || _a === void 0 ? void 0 : _a.initialize();
+            this.isMoving = true;
+        };
+        this.onButtonUp = () => {
+            var _a;
+            this.isMoving = true;
+            if (!this.stylus)
+                return;
+            (_a = this.stylusRootMovementUC) === null || _a === void 0 ? void 0 : _a.stop();
+        };
+        this.onStylusMove = () => {
+            var _a;
+            if (!this.stylus || !this.isMoving)
+                return;
+            (_a = this.stylusRootMovementUC) === null || _a === void 0 ? void 0 : _a.move();
+        };
+        this.stylus = Stylus_1.StylusEntity.get(this.appObjects);
+        if (!this.stylus) {
+            this.warn("Unable to find StylusEntity");
+            return;
+        }
+        this.stylusRootMovementUC = appObject.getComponent(StylusMoveTransformUC_1.StylusMoveTransformUC.type);
+        if (!this.stylusRootMovementUC) {
+            this.error("StylusMoveSceneRoot has been added to an App Object that does not have a StylusMoveTransformUC");
+            return;
+        }
+        this.stylus.registerController(this);
+    }
+}
+exports.SceneRootMoveSC = SceneRootMoveSC;
+SceneRootMoveSC.type = "SceneRootMoveSC";

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

@@ -5,8 +5,8 @@ export * from "./MouseOrbit";
 export * from "./MousePan";
 export * from "./MouseRoll";
 export * from "./MouseScale";
-export * from "./StylusMove";
-export * from "./StylusScale";
+export * from "./SceneRootMoveSC";
+export * from "./ScaleSceneRootSC";
 export * from "./TouchOrbit";
 export * from "./TouchPan";
 export * from "./TouchPinch";

package/lib/Components/SceneRoot/Controllers/index.js

@@ -17,8 +17,8 @@ __exportStar(require("./MouseOrbit"), exports);
 __exportStar(require("./MousePan"), exports);
 __exportStar(require("./MouseRoll"), exports);
 __exportStar(require("./MouseScale"), exports);
-__exportStar(require("./StylusMove"), exports);
-__exportStar(require("./StylusScale"), exports);
+__exportStar(require("./SceneRootMoveSC"), exports);
+__exportStar(require("./ScaleSceneRootSC"), exports);
 __exportStar(require("./TouchOrbit"), exports);
 __exportStar(require("./TouchPan"), exports);
 __exportStar(require("./TouchPinch"), exports);

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

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

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

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

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

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

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

@@ -0,0 +1,70 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PressOnAppObjectSC = void 0;
+const AppObjectController_1 = require("../../../AppObject/AppObjectController");
+const Vector3_1 = require("../../../ValueObjects/Vector3");
+const Stylus_1 = require("../../Stylus");
+const PressAppObjectUC_1 = require("../UC/PressAppObjectUC");
+class PressOnAppObjectSC extends AppObjectController_1.AppObjectController {
+    constructor(appObject) {
+        super(appObject, PressOnAppObjectSC.type);
+        this.startPosition = Vector3_1.Vector3.Zero();
+        this.endPosition = Vector3_1.Vector3.Zero();
+        this.pressedID = null;
+        this.isPressed = false;
+        this.allow = (button) => {
+            return true;
+        };
+        this.onButtonDown = (button) => {
+            var _a;
+            if (!this.stylus)
+                return;
+            if (!this.pressUC)
+                return;
+            if (!this.allow(button))
+                return;
+            this.startPosition = this.stylus.transform.localPosition;
+            this.endPosition = this.startPosition;
+            this.isPressed = true;
+            this.pressedID = (_a = this.pressUC) === null || _a === void 0 ? void 0 : _a.tryPressSceneObject(this.stylus.pickRay);
+        };
+        this.onButtonUp = (button) => {
+            this.isPressed = false;
+            if (button !== 0)
+                return;
+            if (!this.pressUC)
+                return;
+            // Set pressedID to null
+            this.pressUC.pressSceneObject(this.pressedID, this.isPressed);
+        };
+        this.onStylusMove = () => {
+            var _a;
+            if (!this.pressUC) {
+                return;
+            }
+            if (this.isPressed) {
+                this.endPosition = (_a = this.stylus) === null || _a === void 0 ? void 0 : _a.transform.localPosition;
+                const movement = Vector3_1.Vector3.Subtract(this.startPosition, this.endPosition)
+                    .magnitude;
+                if (movement > PressOnAppObjectSC.maxTapDistancePx) {
+                    // Set pressedID to null
+                    this.pressUC.pressSceneObject(null, this.isPressed);
+                }
+            }
+        };
+        this.stylus = Stylus_1.StylusEntity.get(this.appObjects);
+        if (!this.stylus) {
+            this.error("Unable to find StylusEntity");
+            return;
+        }
+        this.pressUC = appObject.getComponent(PressAppObjectUC_1.PressAppObjectUC.type);
+        if (!this.pressUC) {
+            this.error("Unable to get PressAppObjectUC from the App Object");
+            return;
+        }
+        this.stylus.registerController(this);
+    }
+}
+exports.PressOnAppObjectSC = PressOnAppObjectSC;
+PressOnAppObjectSC.type = "PressOnAppObjectSC";
+PressOnAppObjectSC.maxTapDistancePx = 5;

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

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

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

@@ -0,0 +1,39 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SelectAppObjectSC = void 0;
+const AppObjectController_1 = require("../../../AppObject/AppObjectController");
+const Stylus_1 = require("../../Stylus");
+const UC_1 = require("../UC");
+class SelectAppObjectSC extends AppObjectController_1.AppObjectController {
+    constructor(appObject) {
+        super(appObject, SelectAppObjectSC.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);
+        };
+        this.stylus = Stylus_1.StylusEntity.get(this.appObjects);
+        if (!this.stylus) {
+            this.error("Unable to find StylusEntity");
+            return;
+        }
+        this.selectUC = appObject.getComponent(UC_1.SelectAppObjectUC.type);
+        if (!this.selectUC) {
+            this.error("Added to an App Object that does not have SelectAppObjectUC");
+            return;
+        }
+        this.stylus.registerController(this);
+    }
+}
+exports.SelectAppObjectSC = SelectAppObjectSC;
+SelectAppObjectSC.type = "SelectAppObjectSC";

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

@@ -3,6 +3,6 @@ export * from "./MousePressOnAppObject";
 export * from "./MouseSelectAppObject";
 export * from "./TapToSelectAppObject";
 export * from "./TouchPressOnAppObject";
-export * from "./StylusHoverOnAppObject";
-export * from "./StylusPressOnAppObject";
-export * from "./StylusSelectAppObject";
+export * from "./HoverOnAppObjectSC";
+export * from "./PressOnAppObjectSC";
+export * from "./SelectAppObjectSC";

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

@@ -15,6 +15,6 @@ __exportStar(require("./MousePressOnAppObject"), exports);
 __exportStar(require("./MouseSelectAppObject"), exports);
 __exportStar(require("./TapToSelectAppObject"), exports);
 __exportStar(require("./TouchPressOnAppObject"), exports);
-__exportStar(require("./StylusHoverOnAppObject"), exports);
-__exportStar(require("./StylusPressOnAppObject"), exports);
-__exportStar(require("./StylusSelectAppObject"), exports);
+__exportStar(require("./HoverOnAppObjectSC"), exports);
+__exportStar(require("./PressOnAppObjectSC"), exports);
+__exportStar(require("./SelectAppObjectSC"), exports);

package/lib/Components/Stylus/Entity/StylusEntity.d.ts

@@ -0,0 +1,21 @@
+import { AppObject, AppObjectEntity, AppObjectRepo } from "../../../AppObject";
+import { ParametricLine } from "../../../ValueObjects";
+import { Transform3D } from "../../Transform3D";
+export interface StylusController {
+    onButtonDown?: (button: number) => void;
+    onButtonUp?: (button: number) => void;
+    onButtonClick?: (button: number) => void;
+    onStylusMove?: (transform: Transform3D) => void;
+}
+export declare abstract class StylusEntity extends AppObjectEntity {
+    static readonly type = "StylusEntity";
+    static clickMovementThreshold: number;
+    static clickTimeThresholdMS: number;
+    abstract registerController: (controller: StylusController) => void;
+    abstract updateButtonState: (button: number, isPressed: boolean) => void;
+    abstract readonly transform: Transform3D;
+    abstract get isInUse(): boolean;
+    abstract get pickRay(): ParametricLine;
+    static get(appObjects: AppObjectRepo): StylusEntity | undefined;
+}
+export declare function makeStylusEntity(appObj: AppObject): StylusEntity;

package/lib/Components/Stylus/Entity/StylusEntity.js

@@ -0,0 +1,104 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.makeStylusEntity = exports.StylusEntity = void 0;
+const AppObject_1 = require("../../../AppObject");
+const Entities_1 = require("../../../Entities");
+const ValueObjects_1 = require("../../../ValueObjects");
+const Transform3D_1 = require("../../Transform3D");
+class StylusEntity extends AppObject_1.AppObjectEntity {
+    static get(appObjects) {
+        return AppObject_1.getSingletonComponent(StylusEntity.type, appObjects);
+    }
+}
+exports.StylusEntity = StylusEntity;
+StylusEntity.type = "StylusEntity";
+StylusEntity.clickMovementThreshold = 0.32;
+StylusEntity.clickTimeThresholdMS = 350;
+function makeStylusEntity(appObj) {
+    return new StylusImp(appObj);
+}
+exports.makeStylusEntity = makeStylusEntity;
+class StylusImp extends StylusEntity {
+    constructor(appObject) {
+        super(appObject, StylusEntity.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 < StylusEntity.clickMovementThreshold;
+            const passedTime = Date.now() - this.pressTime;
+            const pressTimeIsShortEnough = passedTime < StylusEntity.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 = Transform3D_1.Transform3D.addIfMissing(appObject);
+        this.transform.addChangeObserver(this.onTransformUpdate);
+    }
+    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/Stylus/Entity/index.d.ts

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