@vived/app 3.9.2 → 4.0.0

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

@@ -0,0 +1,54 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.makeShowBabylonInspectorUC = exports.ShowBabylonInspectorUC = void 0;
+const AppObjectUC_1 = require("../../../AppObject/AppObjectUC");
+const Babylon_1 = require("../../Babylon");
+const Entities_1 = require("../Entities");
+class ShowBabylonInspectorUC extends AppObjectUC_1.AppObjectUC {
+    constructor() {
+        super(...arguments);
+        this.requestType = "SHOW_BABYLON_INSPECTOR";
+        this.payloadVersion = 1;
+    }
+}
+exports.ShowBabylonInspectorUC = ShowBabylonInspectorUC;
+ShowBabylonInspectorUC.type = "ShowBabylonInspectorBaseUC";
+function makeShowBabylonInspectorUC(appObject) {
+    return new ShowBabylonInspectorUCImp(appObject);
+}
+exports.makeShowBabylonInspectorUC = makeShowBabylonInspectorUC;
+class ShowBabylonInspectorUCImp extends ShowBabylonInspectorUC {
+    constructor(appObject) {
+        super(appObject, ShowBabylonInspectorUC.type);
+        this.action = (show) => {
+            const appObjects = this.appObject.appObjectRepo;
+            const babylon = Babylon_1.BabylonEntity.get(appObjects);
+            if (!babylon) {
+                return;
+            }
+            babylon.showInspector = show;
+        };
+        this.handleRequest = (version, payload) => {
+            if (version === this.payloadVersion) {
+                const { showBabylonInspector } = this.castPayloadV1(payload);
+                this.action(showBabylonInspector);
+            }
+            else {
+                throw new Entities_1.UnsupportedRequestVersion(this.requestType, version);
+            }
+        };
+        const handler = appObject.getComponent(Entities_1.AppHandlerEntity.type);
+        if (!handler) {
+            this.warn("ShowBabylonInspectorBaseUC has been added to an app object that does not have an AppHandlerEntity. Add one first");
+            return;
+        }
+        handler.registerRequestHandler(this);
+    }
+    castPayloadV1(payload) {
+        const castPayload = payload;
+        if (castPayload.showBabylonInspector === undefined) {
+            throw new Entities_1.UnableToParsePayload(this.requestType, 1, JSON.stringify(payload));
+        }
+        return castPayload;
+    }
+}

package/lib/Components/RequestHandler/UC/StartAppUC.d.ts

@@ -0,0 +1,12 @@
+import { AppObject } from "../../../AppObject/AppObject";
+import { AppObjectUC } from "../../../AppObject/AppObjectUC";
+import { RequestHandler } from "../Entities";
+export declare type StartAppAction = (container: HTMLElement) => void;
+export declare abstract class StartAppBaseUC extends AppObjectUC implements RequestHandler {
+    static readonly type = "StartAppBaseUC";
+    readonly requestType = "START_APP";
+    readonly payloadVersion = 2;
+    abstract action: StartAppAction;
+    abstract handleRequest: (version: number, payload?: unknown) => void;
+}
+export declare function makeStartAppUC(appObject: AppObject): StartAppBaseUC;

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

@@ -0,0 +1,55 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.makeStartAppUC = exports.StartAppBaseUC = void 0;
+const AppObjectUC_1 = require("../../../AppObject/AppObjectUC");
+const App_1 = require("../../App");
+const Entities_1 = require("../Entities");
+class StartAppBaseUC extends AppObjectUC_1.AppObjectUC {
+    constructor() {
+        super(...arguments);
+        this.requestType = "START_APP";
+        this.payloadVersion = 2;
+    }
+}
+exports.StartAppBaseUC = StartAppBaseUC;
+StartAppBaseUC.type = "StartAppBaseUC";
+function makeStartAppUC(appObject) {
+    return new StartAppBaseUCImp(appObject);
+}
+exports.makeStartAppUC = makeStartAppUC;
+class StartAppBaseUCImp extends StartAppBaseUC {
+    constructor(appObject) {
+        super(appObject, StartAppBaseUC.type);
+        this.action = (container) => {
+            const appObjects = this.appObject.appObjectRepo;
+            const appRenderingUC = App_1.AppRenderingUC.get(appObjects);
+            if (!appRenderingUC) {
+                console.warn("Unable to find AppRenderingUC");
+                return;
+            }
+            appRenderingUC.startRendering(container);
+        };
+        this.handleRequest = (version, payload) => {
+            if (version === this.payloadVersion) {
+                const { container } = this.castPayloadV2(payload);
+                this.action(container);
+            }
+            else {
+                throw new Entities_1.UnsupportedRequestVersion(this.requestType, version);
+            }
+        };
+        const handler = appObject.getComponent(Entities_1.AppHandlerEntity.type);
+        if (!handler) {
+            this.warn("StartAppBaseUC has been added to an app object that does not have an AppHandlerEntity. Add one first");
+            return;
+        }
+        handler.registerRequestHandler(this);
+    }
+    castPayloadV2(payload) {
+        const castPayload = payload;
+        if (castPayload.container === undefined) {
+            throw new Entities_1.UnableToParsePayload(this.requestType, 1, JSON.stringify(payload));
+        }
+        return castPayload;
+    }
+}

package/lib/Components/RequestHandler/UC/StartZSpaceUC.d.ts

@@ -0,0 +1,12 @@
+import { AppObject } from "../../../AppObject/AppObject";
+import { AppObjectUC } from "../../../AppObject/AppObjectUC";
+import { RequestHandler } from "../Entities";
+export declare type StartZSpaceAction = (session: any, emulate: boolean) => void;
+export declare abstract class StartZSpaceBaseUC extends AppObjectUC implements RequestHandler {
+    static readonly type = "StartZSpaceBaseUC";
+    readonly requestType = "START_ZSPACE";
+    readonly payloadVersion = 3;
+    abstract action: StartZSpaceAction;
+    abstract handleRequest: (version: number, payload?: unknown) => void;
+}
+export declare function makeStartZSpaceUC(appObject: AppObject): StartZSpaceBaseUC;

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

@@ -0,0 +1,81 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.makeStartZSpaceUC = exports.StartZSpaceBaseUC = void 0;
+const AppObjectUC_1 = require("../../../AppObject/AppObjectUC");
+const XR_1 = require("../../XR");
+const zSpace_1 = require("../../zSpace");
+const Entities_1 = require("../Entities");
+class StartZSpaceBaseUC extends AppObjectUC_1.AppObjectUC {
+    constructor() {
+        super(...arguments);
+        this.requestType = "START_ZSPACE";
+        this.payloadVersion = 3;
+    }
+}
+exports.StartZSpaceBaseUC = StartZSpaceBaseUC;
+StartZSpaceBaseUC.type = "StartZSpaceBaseUC";
+function makeStartZSpaceUC(appObject) {
+    return new StartZSpaceBaseUCImp(appObject);
+}
+exports.makeStartZSpaceUC = makeStartZSpaceUC;
+class StartZSpaceBaseUCImp extends StartZSpaceBaseUC {
+    constructor(appObject) {
+        super(appObject, StartZSpaceBaseUC.type);
+        this.action = (session, emulate) => {
+            const appObjects = this.appObject.appObjectRepo;
+            const zSpaceEntity = zSpace_1.ZSpaceEntity.get(appObjects);
+            if (!zSpaceEntity) {
+                this.warn("No zSpace Entity Found");
+                return;
+            }
+            const renderUC = zSpaceEntity.appObject.getComponent(XR_1.RenderToXR.type);
+            if (!renderUC) {
+                console.warn("No renderUC found");
+                return;
+            }
+            zSpaceEntity.display.setForDevice(zSpace_1.ZSpaceDevice.INSPIRE);
+            zSpaceEntity.emulate = emulate;
+            if (!emulate) {
+                const xrSession = session;
+                if (!xrSession) {
+                    this.warn("Unable to cast the XR session");
+                    return;
+                }
+                renderUC.startRenderingXR(xrSession);
+                const checkDisplaySizeUC = zSpaceEntity.appObject.getComponent(zSpace_1.CheckZSpaceDisplaySizeUC.type);
+                if (checkDisplaySizeUC) {
+                    checkDisplaySizeUC.checkDisplayFromXRSession(session);
+                }
+                else {
+                    console.warn("No checkDisplaySizeUC found");
+                }
+            }
+            zSpaceEntity.enabled = true;
+        };
+        this.handleRequest = (version, payload) => {
+            if (version === this.payloadVersion) {
+                const { session, emulate } = this.castPayloadV3(payload);
+                this.action(session, emulate);
+            }
+            else {
+                throw new Entities_1.UnsupportedRequestVersion(this.requestType, version);
+            }
+        };
+        const handler = appObject.getComponent(Entities_1.AppHandlerEntity.type);
+        if (!handler) {
+            this.warn("StartZSpaceBaseUC has been added to an app object that does not have an AppHandlerEntity. Add one first");
+            return;
+        }
+        handler.registerRequestHandler(this);
+    }
+    castPayloadV3(payload) {
+        const castPayload = payload;
+        if (castPayload.session === undefined) {
+            throw new Entities_1.UnableToParsePayload(this.requestType, 1, JSON.stringify(payload));
+        }
+        if (castPayload.emulate === undefined) {
+            castPayload.emulate = false;
+        }
+        return castPayload;
+    }
+}

package/lib/Components/RequestHandler/UC/StopAppUC.d.ts

@@ -0,0 +1,11 @@
+import { AppObject } from "../../../AppObject/AppObject";
+import { AppObjectUC } from "../../../AppObject/AppObjectUC";
+import { RequestHandler } from "../Entities";
+export declare abstract class StopAppBaseUC extends AppObjectUC implements RequestHandler {
+    static readonly type = "StopAppBaseUC";
+    readonly requestType = "STOP_APP";
+    readonly payloadVersion = 1;
+    abstract action: () => void;
+    abstract handleRequest: (version: number, payload?: unknown) => void;
+}
+export declare function makeStopAppUC(appObject: AppObject): StopAppBaseUC;

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

@@ -0,0 +1,47 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.makeStopAppUC = exports.StopAppBaseUC = void 0;
+const AppObjectUC_1 = require("../../../AppObject/AppObjectUC");
+const App_1 = require("../../App");
+const Entities_1 = require("../Entities");
+class StopAppBaseUC extends AppObjectUC_1.AppObjectUC {
+    constructor() {
+        super(...arguments);
+        this.requestType = "STOP_APP";
+        this.payloadVersion = 1;
+    }
+}
+exports.StopAppBaseUC = StopAppBaseUC;
+StopAppBaseUC.type = "StopAppBaseUC";
+function makeStopAppUC(appObject) {
+    return new StopAppBaseUCImp(appObject);
+}
+exports.makeStopAppUC = makeStopAppUC;
+class StopAppBaseUCImp extends StopAppBaseUC {
+    constructor(appObject) {
+        super(appObject, StopAppBaseUC.type);
+        this.action = () => {
+            const appObjects = this.appObject.appObjectRepo;
+            const appRenderingUC = App_1.AppRenderingUC.get(appObjects);
+            if (!appRenderingUC) {
+                console.warn("Unable to find AppRenderingUC");
+                return;
+            }
+            appRenderingUC.stopRendering();
+        };
+        this.handleRequest = (version) => {
+            if (version === this.payloadVersion) {
+                this.action();
+            }
+            else {
+                throw new Entities_1.UnsupportedRequestVersion(this.requestType, version);
+            }
+        };
+        const handler = appObject.getComponent(Entities_1.AppHandlerEntity.type);
+        if (!handler) {
+            this.warn("StopAppBaseUC has been added to an app object that does not have an AppHandlerEntity. Add one first");
+            return;
+        }
+        handler.registerRequestHandler(this);
+    }
+}

package/lib/Components/RequestHandler/UC/StopZSpaceUC.d.ts

@@ -0,0 +1,11 @@
+import { AppObject } from "../../../AppObject/AppObject";
+import { AppObjectUC } from "../../../AppObject/AppObjectUC";
+import { RequestHandler } from "../Entities";
+export declare abstract class StopZSpaceUC extends AppObjectUC implements RequestHandler {
+    static readonly type = "StopZSpaceBaseUC";
+    readonly requestType = "STOP_ZSPACE";
+    readonly payloadVersion = 1;
+    abstract action: () => void;
+    abstract handleRequest: (version: number, payload?: unknown) => void;
+}
+export declare function makeStopZSpaceUC(appObject: AppObject): StopZSpaceUC;

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

@@ -0,0 +1,55 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.makeStopZSpaceUC = exports.StopZSpaceUC = void 0;
+const AppObjectUC_1 = require("../../../AppObject/AppObjectUC");
+const XR_1 = require("../../XR");
+const zSpace_1 = require("../../zSpace");
+const Entities_1 = require("../Entities");
+class StopZSpaceUC extends AppObjectUC_1.AppObjectUC {
+    constructor() {
+        super(...arguments);
+        this.requestType = "STOP_ZSPACE";
+        this.payloadVersion = 1;
+    }
+}
+exports.StopZSpaceUC = StopZSpaceUC;
+StopZSpaceUC.type = "StopZSpaceBaseUC";
+function makeStopZSpaceUC(appObject) {
+    return new StopZSpaceUCImp(appObject);
+}
+exports.makeStopZSpaceUC = makeStopZSpaceUC;
+class StopZSpaceUCImp extends StopZSpaceUC {
+    constructor(appObject) {
+        super(appObject, StopZSpaceUC.type);
+        this.action = () => {
+            const appObjects = this.appObject.appObjectRepo;
+            const zSpaceEntity = zSpace_1.ZSpaceEntity.get(appObjects);
+            if (!zSpaceEntity) {
+                console.warn("No zSpace Entity Found");
+                return;
+            }
+            const renderUC = zSpaceEntity.appObject.getComponent(XR_1.RenderToXR.type);
+            if (!renderUC) {
+                console.warn("No renderUC found");
+                return;
+            }
+            renderUC.stopRenderingXR();
+            zSpaceEntity.enabled = false;
+            zSpaceEntity.emulate = false;
+        };
+        this.handleRequest = (version) => {
+            if (version === this.payloadVersion) {
+                this.action();
+            }
+            else {
+                throw new Entities_1.UnsupportedRequestVersion(this.requestType, version);
+            }
+        };
+        const handler = appObject.getComponent(Entities_1.AppHandlerEntity.type);
+        if (!handler) {
+            this.warn("StopZSpaceBaseUC has been added to an app object that does not have an AppHandlerEntity. Add one first");
+            return;
+        }
+        handler.registerRequestHandler(this);
+    }
+}

package/lib/Components/RequestHandler/UC/index.d.ts

@@ -0,0 +1,10 @@
+export * from "./DisposeAppUC";
+export * from "./SetAppStateUC";
+export * from "./SetIsAuthoringUC";
+export * from "./SetThemeColorUC";
+export * from "./StartZSpaceUC";
+export * from "./ShowBabylonInspectorUC";
+export * from "./StartAppUC";
+export * from "./StartZSpaceUC";
+export * from "./StopAppUC";
+export * from "./StopZSpaceUC";

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

@@ -0,0 +1,22 @@
+"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("./DisposeAppUC"), exports);
+__exportStar(require("./SetAppStateUC"), exports);
+__exportStar(require("./SetIsAuthoringUC"), exports);
+__exportStar(require("./SetThemeColorUC"), exports);
+__exportStar(require("./StartZSpaceUC"), exports);
+__exportStar(require("./ShowBabylonInspectorUC"), exports);
+__exportStar(require("./StartAppUC"), exports);
+__exportStar(require("./StartZSpaceUC"), exports);
+__exportStar(require("./StopAppUC"), exports);
+__exportStar(require("./StopZSpaceUC"), exports);

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

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

package/lib/Components/RequestHandler/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("./Entities"), exports);
+__exportStar(require("./UC"), exports);

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

@@ -0,0 +1,88 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DoubleTapToFocus = void 0;
+const AppObjectController_1 = require("../../../AppObject/AppObjectController");
+const ValueObjects_1 = require("../../../ValueObjects");
+const TouchController_1 = require("../../TouchController");
+const FocusOnPixel_1 = require("../UC/FocusOnPixel");
+class DoubleTapToFocus extends AppObjectController_1.AppObjectController {
+    constructor(appObject) {
+        super(appObject, DoubleTapToFocus.type);
+        this.focusDurationMS = 500;
+        this.tapTimeMS = 300;
+        this.maxTapDistancePx = 30;
+        this.initialTouchPos = ValueObjects_1.Vector2.Zero();
+        this.initialTouchTime = 0;
+        this.tapCount = 0;
+        this.allow = (e) => {
+            return true;
+        };
+        this.onTouchStart = (e) => {
+            if (!this.allow(e)) {
+                this.cancelDoubleTap();
+                return;
+            }
+            if (e.touchCount !== 1) {
+                this.cancelDoubleTap();
+                return;
+            }
+            this.tapCount = this.tapCount + 1;
+            if (this.tapCount === 1) {
+                this.initialTouchPos = e.touchCenter;
+                this.initialTouchTime = Date.now();
+            }
+            else if (this.tapCount === 2) {
+                this.checkForMovement(e.touchCenter);
+            }
+        };
+        this.onTouchMove = (e) => {
+            if (this.tapCount !== 1)
+                return;
+            if (e.touchCount !== 1) {
+                this.cancelDoubleTap();
+                return;
+            }
+            this.checkForMovement(e.touchCenter);
+        };
+        this.onTouchEnd = () => {
+            var _a;
+            if (this.tapCount === 2) {
+                const passedTime = Date.now() - this.initialTouchTime;
+                if (passedTime > this.tapTimeMS) {
+                    this.cancelDoubleTap();
+                    return;
+                }
+                (_a = this.focusOnPixelUC) === null || _a === void 0 ? void 0 : _a.centerOnPixel(this.initialTouchPos);
+                this.tapCount = 0;
+                this.initialTouchTime = 0;
+            }
+        };
+        this.cancelDoubleTap = () => {
+            this.initialTouchTime = 0;
+            this.tapCount = 0;
+        };
+        const appObjects = appObject.appObjectRepo;
+        this.focusOnPixelUC = appObject.getComponent(FocusOnPixel_1.FocusOnPixelUC.type);
+        if (!this.focusOnPixelUC) {
+            this.warn("Controller has been added to an App Object that does not have FocusOnPixelUC. Add one first.");
+            return;
+        }
+        const touchInput = TouchController_1.TouchInputEntity.get(appObjects);
+        if (touchInput) {
+            touchInput.registerController(this);
+        }
+        else {
+            this.warn("Unable to find TouchInputEntity");
+        }
+    }
+    checkForMovement(currentPixelPos) {
+        const movement = ValueObjects_1.Vector2.Subtract(this.initialTouchPos, currentPixelPos)
+            .magnitued;
+        if (movement > this.maxTapDistancePx) {
+            this.cancelDoubleTap();
+            return;
+        }
+    }
+}
+exports.DoubleTapToFocus = DoubleTapToFocus;
+DoubleTapToFocus.type = "DoubleTapToFocus";

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

@@ -0,0 +1,10 @@
+import { AppObject } from "../../../AppObject/AppObject";
+import { AppObjectController } from "../../../AppObject/AppObjectController";
+import { MouseController, MouseInputEvent } from "../../MouseInput";
+export declare class MouseClickToFocus extends AppObjectController implements MouseController {
+    static readonly type = "MouseClickToFocus";
+    private centerOnPixelUI?;
+    allow: (e: MouseInputEvent) => boolean;
+    onClick: (e: MouseInputEvent) => void;
+    constructor(appObject: AppObject);
+}

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

@@ -0,0 +1,34 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MouseClickToFocus = void 0;
+const AppObjectController_1 = require("../../../AppObject/AppObjectController");
+const MouseInput_1 = require("../../MouseInput");
+const CenterSceneRootOnPixelPick_1 = require("../UC/CenterSceneRootOnPixelPick");
+class MouseClickToFocus extends AppObjectController_1.AppObjectController {
+    constructor(appObject) {
+        super(appObject, MouseClickToFocus.type);
+        this.allow = (e) => {
+            return true;
+        };
+        this.onClick = (e) => {
+            var _a;
+            if (this.allow(e)) {
+                (_a = this.centerOnPixelUI) === null || _a === void 0 ? void 0 : _a.centerOnPixel(e.position);
+            }
+        };
+        this.centerOnPixelUI = appObject.getComponent(CenterSceneRootOnPixelPick_1.CenterSceneRootOnPixelPickUC.type);
+        if (!this.centerOnPixelUI) {
+            this.warn("Controller has been added to an App Object that does not have CenterSceneRootOnPixelPickUC. Add one first.");
+            return;
+        }
+        const mouseInput = MouseInput_1.MouseInputEntity.get(this.appObjects);
+        if (mouseInput) {
+            mouseInput.registerController(this);
+        }
+        else {
+            this.warn("Unable to find MouseInputEntity");
+        }
+    }
+}
+exports.MouseClickToFocus = MouseClickToFocus;
+MouseClickToFocus.type = "MouseClickToFocus";

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

@@ -0,0 +1,11 @@
+import { AppObject } from "../../../AppObject/AppObject";
+import { AppObjectController } from "../../../AppObject/AppObjectController";
+import { MouseController, MouseInputEvent } from "../../MouseInput";
+export declare class MouseDoubleClickToRecenter extends AppObjectController implements MouseController {
+    static readonly type = "MouseDoubleClickToRecenter";
+    protected focusDurationMS: number;
+    private focusUC?;
+    allow: (e: MouseInputEvent) => boolean;
+    onDoubleClick: (e: MouseInputEvent) => void;
+    constructor(appObject: AppObject);
+}

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

@@ -0,0 +1,35 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MouseDoubleClickToRecenter = void 0;
+const AppObjectController_1 = require("../../../AppObject/AppObjectController");
+const MouseInput_1 = require("../../MouseInput");
+const FocusOnPixel_1 = require("../UC/FocusOnPixel");
+class MouseDoubleClickToRecenter extends AppObjectController_1.AppObjectController {
+    constructor(appObject) {
+        super(appObject, MouseDoubleClickToRecenter.type);
+        this.focusDurationMS = 500;
+        this.allow = (e) => {
+            return true;
+        };
+        this.onDoubleClick = (e) => {
+            var _a;
+            if (this.allow(e)) {
+                (_a = this.focusUC) === null || _a === void 0 ? void 0 : _a.centerOnPixel(e.position);
+            }
+        };
+        this.focusUC = appObject.getComponent(FocusOnPixel_1.FocusOnPixelUC.type);
+        if (!this.focusUC) {
+            this.warn("Controller has been added to an App Object that does not have FocusOnPixelUC. Add one first.");
+            return;
+        }
+        const mouseInput = MouseInput_1.MouseInputEntity.get(this.appObjects);
+        if (mouseInput) {
+            mouseInput.registerController(this);
+        }
+        else {
+            this.warn("Unable to find MouseInputEntity");
+        }
+    }
+}
+exports.MouseDoubleClickToRecenter = MouseDoubleClickToRecenter;
+MouseDoubleClickToRecenter.type = "MouseDoubleClickToRecenter";

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

@@ -0,0 +1,13 @@
+import { AppObject } from "../../../AppObject/AppObject";
+import { AppObjectController } from "../../../AppObject/AppObjectController";
+import { MouseController, MouseInputEvent } from "../../MouseInput";
+export declare class MouseOrbit extends AppObjectController implements MouseController {
+    static readonly type = "MouseOrbit";
+    private isOrbiting;
+    private orbitSceneRoot?;
+    allow: (e: MouseInputEvent) => boolean;
+    onDown: (e: MouseInputEvent) => void;
+    onMove: (e: MouseInputEvent) => void;
+    onUp: () => void;
+    constructor(appObject: AppObject);
+}

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

@@ -0,0 +1,53 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MouseOrbit = void 0;
+const AppObjectController_1 = require("../../../AppObject/AppObjectController");
+const MouseInput_1 = require("../../MouseInput");
+const OrbitSceneRoot_1 = require("../UC/OrbitSceneRoot");
+class MouseOrbit extends AppObjectController_1.AppObjectController {
+    constructor(appObject) {
+        super(appObject, MouseOrbit.type);
+        this.isOrbiting = false;
+        this.allow = (e) => {
+            return true;
+        };
+        this.onDown = (e) => {
+            this.isOrbiting = false;
+            if (!this.orbitSceneRoot)
+                return;
+            if (!this.allow(e))
+                return;
+            const pixelPosition = e.position;
+            this.orbitSceneRoot.initializeOrbit(pixelPosition);
+            this.isOrbiting = true;
+        };
+        this.onMove = (e) => {
+            if (!this.orbitSceneRoot)
+                return;
+            if (!this.isOrbiting)
+                return;
+            const currentPixelPos = e.position;
+            this.orbitSceneRoot.doOrbit(currentPixelPos);
+        };
+        this.onUp = () => {
+            if (!this.orbitSceneRoot)
+                return;
+            this.orbitSceneRoot.finishOrbit();
+            this.isOrbiting = false;
+        };
+        this.orbitSceneRoot = appObject.getComponent(OrbitSceneRoot_1.OrbitSceneRootUC.type);
+        if (!this.orbitSceneRoot) {
+            this.warn("Controller has been added to an App Object that does not have OrbitSceneRootUC. Add one first.");
+            return;
+        }
+        const mouseInput = MouseInput_1.MouseInputEntity.get(this.appObjects);
+        if (mouseInput) {
+            mouseInput.registerController(this);
+        }
+        else {
+            this.warn("Unable to find MouseInputEntity");
+        }
+    }
+}
+exports.MouseOrbit = MouseOrbit;
+MouseOrbit.type = "MouseOrbit";