@vived/app 4.27.1 → 4.28.1

package/lib/Components/Callouts/UC/LookAtCameraUC.js

@@ -0,0 +1,104 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.makeLookAtCameraUC = exports.LookAtCameraUC = void 0;
+const AppObject_1 = require("../../../AppObject");
+const ValueObjects_1 = require("../../../ValueObjects");
+const SceneRootEntity_1 = require("../../SceneRoot/Entities/SceneRootEntity");
+const CalloutEntity_1 = require("../Entities/CalloutEntity");
+class LookAtCameraUC extends AppObject_1.AppObjectUC {
+    static get(appObj) {
+        return appObj.getComponent(this.type);
+    }
+}
+exports.LookAtCameraUC = LookAtCameraUC;
+LookAtCameraUC.type = "LookAtCameraUC";
+function makeLookAtCameraUC(appObject) {
+    return new LookAtCameraUCIMP(appObject);
+}
+exports.makeLookAtCameraUC = makeLookAtCameraUC;
+class LookAtCameraUCIMP extends LookAtCameraUC {
+    constructor(appObject) {
+        var _a, _b;
+        super(appObject, LookAtCameraUC.type);
+        this.cameraPos = new ValueObjects_1.Vector3(0, 0, -0.6);
+        this.targetQ = ValueObjects_1.Quaternion.Identity();
+        this.isSlerping = false;
+        this.onChange = () => {
+            if (!this.callout)
+                return;
+            const parent = this.callout.labelTransform.parent;
+            if (!parent) {
+                return;
+            }
+            const worldDir = ValueObjects_1.Vector3.Subtract(this.cameraPos, this.callout.labelTransform.worldPosition);
+            const localDir = parent.worldDirectionToLocal(worldDir);
+            const desiredQ = ValueObjects_1.Quaternion.FromDirectionVector(localDir);
+            if (ValueObjects_1.Quaternion.Close(this.targetQ, desiredQ)) {
+                return;
+            }
+            this.targetQ = desiredQ;
+            if (!this.isSlerping) {
+                this.kickOffSlerping();
+            }
+        };
+        this.stopSlerping = () => {
+            if (this.callout) {
+                this.callout.labelTransform.localRotation = this.targetQ;
+            }
+            if (this.slerpInterval) {
+                clearInterval(this.slerpInterval);
+                this.slerpInterval = undefined;
+            }
+            this.isSlerping = false;
+        };
+        this.dispose = () => {
+            var _a;
+            super.dispose();
+            (_a = this.sceneRootEntity) === null || _a === void 0 ? void 0 : _a.removeChangeObserver(this.onChange);
+        };
+        (_a = this.sceneRootEntity) === null || _a === void 0 ? void 0 : _a.addChangeObserver(this.onChange);
+        (_b = this.callout) === null || _b === void 0 ? void 0 : _b.addChangeObserver(this.onChange);
+        this.onChange();
+    }
+    get sceneRootEntity() {
+        return this.getCachedSingleton(SceneRootEntity_1.SceneRootEntity.type);
+    }
+    get callout() {
+        return this.getCachedLocalComponent(CalloutEntity_1.CalloutEntity.type);
+    }
+    kickOffSlerping() {
+        var _a;
+        if (this.slerpInterval) {
+            this.stopSlerping();
+        }
+        this.isSlerping = true;
+        const transform = (_a = this.callout) === null || _a === void 0 ? void 0 : _a.labelTransform;
+        if (!transform)
+            return;
+        let previousError = ValueObjects_1.Quaternion.AngleBetween(transform.localRotation, this.targetQ).degrees;
+        this.slerpInterval = setInterval(() => {
+            const error = ValueObjects_1.Quaternion.AngleBetween(transform.localRotation, this.targetQ).degrees;
+            if (error < 0.15) {
+                this.stopSlerping();
+                return;
+            }
+            const deltaError = error - previousError;
+            if (deltaError === 0) {
+                this.stopSlerping();
+                return;
+            }
+            const kp = 0.05;
+            const kd = 5;
+            const pEffect = kp * error;
+            const dEffect = kd * (deltaError / 10);
+            const deltaAng = pEffect + dEffect;
+            let slerpPercent = deltaAng / error;
+            if (slerpPercent > 1) {
+                slerpPercent = 1;
+            }
+            const slerpedQ = ValueObjects_1.Quaternion.Slerp(transform.localRotation, this.targetQ, slerpPercent);
+            transform.localRotation = slerpedQ;
+            previousError = error;
+        }, 10);
+    }
+}

package/lib/Components/Callouts/UC/MoveCalloutToCamUC.d.ts

@@ -0,0 +1,14 @@
+import { AppObject, AppObjectRepo, AppObjectUC } from "../../../AppObject";
+export declare function makeMoveCalloutToCamUC(appObject: AppObject): MoveCalloutToCamUCImp;
+export declare abstract class MoveCalloutToCamUC extends AppObjectUC {
+    static readonly type = "MoveCalloutToCamUC";
+    abstract moveCalloutToCam(delta: number): void;
+    static get(appObject: AppObject): MoveCalloutToCamUC | undefined;
+    static getById(id: string, appObjects: AppObjectRepo): MoveCalloutToCamUC | undefined;
+}
+declare class MoveCalloutToCamUCImp extends MoveCalloutToCamUC {
+    private get callout();
+    moveCalloutToCam: (delta: number) => void;
+    constructor(appObject: AppObject);
+}
+export {};

package/lib/Components/Callouts/UC/MoveCalloutToCamUC.js

@@ -0,0 +1,35 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MoveCalloutToCamUC = exports.makeMoveCalloutToCamUC = void 0;
+const AppObject_1 = require("../../../AppObject");
+const ValueObjects_1 = require("../../../ValueObjects");
+const CalloutEntity_1 = require("../Entities/CalloutEntity");
+function makeMoveCalloutToCamUC(appObject) {
+    return new MoveCalloutToCamUCImp(appObject);
+}
+exports.makeMoveCalloutToCamUC = makeMoveCalloutToCamUC;
+class MoveCalloutToCamUC extends AppObject_1.AppObjectUC {
+    static get(appObject) {
+        return appObject.getComponent(this.type);
+    }
+    static getById(id, appObjects) {
+        var _a;
+        return (_a = appObjects.get(id)) === null || _a === void 0 ? void 0 : _a.getComponent(this.type);
+    }
+}
+exports.MoveCalloutToCamUC = MoveCalloutToCamUC;
+MoveCalloutToCamUC.type = "MoveCalloutToCamUC";
+class MoveCalloutToCamUCImp extends MoveCalloutToCamUC {
+    constructor(appObject) {
+        super(appObject, MoveCalloutToCamUC.type);
+        this.moveCalloutToCam = (delta) => {
+            if (!this.callout) {
+                return;
+            }
+            this.callout.labelTransform.worldPosition = this.callout.labelTransform.localPointToWorld(new ValueObjects_1.Vector3(0, 0, this.callout.labelTransform.localScale.x * delta));
+        };
+    }
+    get callout() {
+        return this.getCachedLocalComponent(CalloutEntity_1.CalloutEntity.type);
+    }
+}

package/lib/Components/Callouts/UC/SerializeCallouts.d.ts

@@ -0,0 +1,17 @@
+import { AppObject, AppObjectUC } from "../../../AppObject";
+import { SerializedSystem } from "../../StateMachine/Entities/StateMachineEntity";
+import { CalloutDTO } from "../Entities/CalloutEntity";
+export declare class SerializeCallouts extends AppObjectUC implements SerializedSystem {
+    static readonly type = "SerializeCallouts";
+    name: string;
+    seriliziationVersion: number;
+    private get calloutGlobal();
+    getSystemState(): object;
+    applySystemState(state: object, version: number): void;
+    private handleStateVersion1;
+    applyDefaultState(): void;
+    constructor(appObj: AppObject);
+}
+export interface SerilizedCalloutsV1 {
+    callouts: CalloutDTO[];
+}

package/lib/Components/Callouts/UC/SerializeCallouts.js

@@ -0,0 +1,94 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SerializeCallouts = void 0;
+const AppObject_1 = require("../../../AppObject");
+const StateMachineEntity_1 = require("../../StateMachine/Entities/StateMachineEntity");
+const CalloutEntity_1 = require("../Entities/CalloutEntity");
+const CalloutGlobals_1 = require("../Entities/CalloutGlobals");
+const CalloutRepo_1 = require("../Entities/CalloutRepo");
+class SerializeCallouts extends AppObject_1.AppObjectUC {
+    constructor(appObj) {
+        super(appObj, SerializeCallouts.type);
+        this.name = "callouts";
+        this.seriliziationVersion = 1;
+        const stateMachine = this.appObjects.getSingleton(StateMachineEntity_1.StateMachineEntity.type);
+        if (stateMachine) {
+            stateMachine.registerSerializedSystem(this);
+        }
+        else {
+            this.warn("Unable to find StateMachineEntity");
+        }
+    }
+    get calloutGlobal() {
+        return this.getCachedSingleton(CalloutGlobals_1.CalloutGlobals.type);
+    }
+    getSystemState() {
+        const repos = this.appObjects.getAllComponents(CalloutRepo_1.CalloutRepo.type);
+        const callouts = [];
+        repos.forEach((repo) => {
+            repo.getAll().forEach((callout) => {
+                callouts.push(callout.data);
+            });
+        });
+        return {
+            callouts,
+        };
+    }
+    applySystemState(state, version) {
+        if (version === 1) {
+            this.handleStateVersion1(state);
+        }
+        else {
+            this.warn("Unsupported state version. Reverting to default");
+            this.applyDefaultState();
+        }
+    }
+    handleStateVersion1(state) {
+        const { callouts } = state;
+        if (!callouts) {
+            this.warn("Unable to parse state. Reverting to default");
+            this.applyDefaultState();
+            return;
+        }
+        const previousCalloutLookup = new Map();
+        const allCallouts = this.appObjects.getAllComponents(CalloutEntity_1.CalloutEntity.type);
+        allCallouts.forEach((callout) => {
+            previousCalloutLookup.set(callout.appObject.id, callout);
+        });
+        callouts.forEach((calloutData) => {
+            var _a;
+            let callout = previousCalloutLookup.get(calloutData.id);
+            if (callout) {
+                previousCalloutLookup.delete(calloutData.id);
+            }
+            else {
+                let repo = CalloutRepo_1.CalloutRepo.getById(calloutData.parentID, this.appObjects);
+                if (!repo) {
+                    repo = (_a = this.calloutGlobal) === null || _a === void 0 ? void 0 : _a.calloutRepoFactory(calloutData.parentID);
+                }
+                callout = repo === null || repo === void 0 ? void 0 : repo.makeCallout(calloutData.id);
+            }
+            if (!callout) {
+                this.warn("Unable to create or find callout");
+                return;
+            }
+            callout.data = calloutData;
+        });
+        previousCalloutLookup.forEach((callout) => {
+            var _a;
+            (_a = callout.inRepo) === null || _a === void 0 ? void 0 : _a.deleteCallout(callout.appObject.id);
+        });
+    }
+    applyDefaultState() {
+        const repos = this.appObjects.getAllComponents(CalloutRepo_1.CalloutRepo.type);
+        repos.forEach((repo) => {
+            const callouts = repo.getAll();
+            callouts.forEach((callout) => {
+                var _a;
+                (_a = callout.inRepo) === null || _a === void 0 ? void 0 : _a.deleteCallout(callout.appObject.id);
+            });
+        });
+    }
+}
+exports.SerializeCallouts = SerializeCallouts;
+SerializeCallouts.type = "SerializeCallouts";

package/lib/Components/Callouts/UC/SetCalloutSizeUC.d.ts

@@ -0,0 +1,9 @@
+import { AppObject, AppObjectRepo, AppObjectUC } from "../../../AppObject";
+export declare abstract class SetCalloutSizeUC extends AppObjectUC {
+    static readonly type = "SetCalloutSizeUC";
+    abstract updateSize(size: number): void;
+    abstract submitSize(size: number): void;
+    static get(appObj: AppObject): SetCalloutSizeUC | undefined;
+    static getById(id: string, appObjects: AppObjectRepo): SetCalloutSizeUC | undefined;
+}
+export declare function makeSetCalloutSizeUC(appObject: AppObject): SetCalloutSizeUC;

package/lib/Components/Callouts/UC/SetCalloutSizeUC.js

@@ -0,0 +1,63 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.makeSetCalloutSizeUC = exports.SetCalloutSizeUC = void 0;
+const AppObject_1 = require("../../../AppObject");
+const DispatchStateChangeUC_1 = require("../../Dispatcher/UC/DispatchStateChangeUC");
+const CalloutEntity_1 = require("../Entities/CalloutEntity");
+const CalloutGlobals_1 = require("../Entities/CalloutGlobals");
+const SetCalloutSizeUndoRedo_1 = require("./SetCalloutSizeUndoRedo");
+class SetCalloutSizeUC extends AppObject_1.AppObjectUC {
+    static get(appObj) {
+        return appObj.getComponent(this.type);
+    }
+    static getById(id, appObjects) {
+        var _a;
+        return (_a = appObjects.get(id)) === null || _a === void 0 ? void 0 : _a.getComponent(this.type);
+    }
+}
+exports.SetCalloutSizeUC = SetCalloutSizeUC;
+SetCalloutSizeUC.type = "SetCalloutSizeUC";
+function makeSetCalloutSizeUC(appObject) {
+    return new SetCalloutSizeUCImp(appObject);
+}
+exports.makeSetCalloutSizeUC = makeSetCalloutSizeUC;
+class SetCalloutSizeUCImp extends SetCalloutSizeUC {
+    constructor(appObject) {
+        super(appObject, SetCalloutSizeUC.type);
+    }
+    get callout() {
+        return this.getCachedLocalComponent(CalloutEntity_1.CalloutEntity.type);
+    }
+    get calloutsGlobals() {
+        return this.getCachedSingleton(CalloutGlobals_1.CalloutGlobals.type);
+    }
+    updateSize(size) {
+        if (!this.callout)
+            return;
+        if (!this.calloutsGlobals)
+            return;
+        if (this.initialValue === undefined) {
+            this.initialValue = this.callout.size;
+        }
+        this.callout.size = size;
+    }
+    submitSize(size) {
+        if (!this.initialValue)
+            return;
+        if (!this.callout)
+            return;
+        if (!this.calloutsGlobals)
+            return;
+        this.callout.size = size;
+        this.calloutsGlobals.lastSize = size;
+        if (this.initialValue && this.initialValue !== this.callout.size) {
+            new SetCalloutSizeUndoRedo_1.SetCalloutSizeUndoRedo({
+                callout: this.callout,
+                redoSize: this.callout.size,
+                undoSize: this.initialValue,
+            }, this.appObjects);
+            DispatchStateChangeUC_1.dispatchStateChange(this.appObjects);
+        }
+        this.initialValue = undefined;
+    }
+}

package/lib/Components/Callouts/UC/SetCalloutSizeUndoRedo.d.ts

@@ -0,0 +1,15 @@
+import { AppObjectRepo } from "../../../AppObject";
+import { UndoRedoAction } from "../../UndoRedo/Entities/UndoRedoEntity";
+import { CalloutEntity } from "../Entities/CalloutEntity";
+export interface UndoCalloutSizeDTO {
+    callout: CalloutEntity;
+    undoSize: number;
+    redoSize: number;
+}
+export declare class SetCalloutSizeUndoRedo implements UndoRedoAction {
+    private data;
+    private appObjects;
+    undoAction: () => void;
+    redoAction: () => void;
+    constructor(data: UndoCalloutSizeDTO, appObjects: AppObjectRepo);
+}

package/lib/Components/Callouts/UC/SetCalloutSizeUndoRedo.js

@@ -0,0 +1,28 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SetCalloutSizeUndoRedo = void 0;
+const DispatchStateChangeUC_1 = require("../../Dispatcher/UC/DispatchStateChangeUC");
+const UndoRedoEntity_1 = require("../../UndoRedo/Entities/UndoRedoEntity");
+class SetCalloutSizeUndoRedo {
+    constructor(data, appObjects) {
+        this.data = data;
+        this.appObjects = appObjects;
+        this.undoAction = () => {
+            const { callout, undoSize } = this.data;
+            callout.size = undoSize;
+            DispatchStateChangeUC_1.dispatchStateChange(this.appObjects);
+        };
+        this.redoAction = () => {
+            const { callout, redoSize } = this.data;
+            callout.size = redoSize;
+            DispatchStateChangeUC_1.dispatchStateChange(this.appObjects);
+        };
+        const undoRedo = UndoRedoEntity_1.UndoRedoEntity.get(appObjects);
+        if (!undoRedo) {
+            appObjects.submitWarning("SetCalloutSizeUndoRedo", "Unable to find UndoRedoEntity");
+            return;
+        }
+        undoRedo.submitAction(this);
+    }
+}
+exports.SetCalloutSizeUndoRedo = SetCalloutSizeUndoRedo;

package/lib/Components/Callouts/UC/TryAddCallout.d.ts

@@ -0,0 +1,14 @@
+import { AppObject, AppObjectRepo, AppObjectUC } from "../../../AppObject";
+import { ParametricLine, Vector2 } from "../../../ValueObjects";
+export declare abstract class TryAddCalloutUC extends AppObjectUC {
+    static readonly type = "TryAddCalloutUC";
+    abstract allow(): boolean;
+    abstract initializeWithPixel(pixel: Vector2): boolean;
+    abstract moveWithPixel(pixel: Vector2): void;
+    abstract initializeWithRay(ray: ParametricLine): boolean;
+    abstract moveWithRay(ray: ParametricLine): void;
+    abstract stop(): void;
+    abstract cancel(): void;
+    static get(appObjects: AppObjectRepo): TryAddCalloutUC | undefined;
+}
+export declare function makeTryAddCalloutUC(appObject: AppObject): TryAddCalloutUC;

package/lib/Components/Callouts/UC/TryAddCallout.js

@@ -0,0 +1,111 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.makeTryAddCalloutUC = exports.TryAddCalloutUC = void 0;
+const AppObject_1 = require("../../../AppObject");
+const UC_1 = require("../../Babylon/UC");
+const Selection_1 = require("../../Selection/Entities/Selection");
+const PanTransformUC_1 = require("../../Transform3D/UC/PanTransformUC");
+const CreateCalloutUC_1 = require("./CreateCalloutUC");
+class TryAddCalloutUC extends AppObject_1.AppObjectUC {
+    static get(appObjects) {
+        return AppObject_1.getSingletonComponent(TryAddCalloutUC.type, appObjects);
+    }
+}
+exports.TryAddCalloutUC = TryAddCalloutUC;
+TryAddCalloutUC.type = "TryAddCalloutUC";
+function makeTryAddCalloutUC(appObject) {
+    return new TryAddCalloutImpUC(appObject);
+}
+exports.makeTryAddCalloutUC = makeTryAddCalloutUC;
+class TryAddCalloutImpUC extends TryAddCalloutUC {
+    constructor(appObject) {
+        super(appObject, TryAddCalloutUC.type);
+        this.allow = () => {
+            return true;
+        };
+        this.moveWithPixel = (pixel) => {
+            if (!this.pixelToRay) {
+                this.error("Missing component");
+                return;
+            }
+            const ray = this.pixelToRay(pixel);
+            return this.moveWithRay(ray);
+        };
+        this.initializeWithRay = (ray) => {
+            var _a;
+            this.addingCallout = undefined;
+            if (!this.allow())
+                return false;
+            const scenePick = (_a = UC_1.SceneRayPickUC.get(this.appObjects)) === null || _a === void 0 ? void 0 : _a.sceneRayPick(ray);
+            if (!scenePick ||
+                !scenePick.worldPickPoint ||
+                scenePick.hit === false ||
+                !scenePick.normal ||
+                !scenePick.objectPickMeta) {
+                return false;
+            }
+            const appObjectID = scenePick.objectPickMeta.appObjectID;
+            if (!appObjectID) {
+                return false;
+            }
+            const appObject = this.appObject.appObjectRepo.get(appObjectID);
+            if (!appObject) {
+                return false;
+            }
+            const createCalloutUC = CreateCalloutUC_1.CreateCalloutUC.get(appObject);
+            if (!createCalloutUC) {
+                return false;
+            }
+            this.addingCallout = createCalloutUC.fromPick(scenePick.worldPickPoint, scenePick.normal);
+            if (!this.addingCallout)
+                return false;
+            this.dragUC = this.addingCallout.labelTransform.appObject.getComponent(PanTransformUC_1.PanTransformUC.type);
+            if (this.dragUC) {
+                this.dragUC.dispatchStateChangeOnComplete = false;
+                this.dragUC.submitUndoOnComplete = false;
+                this.dragUC.initializeRay(ray);
+            }
+            return true;
+        };
+        this.moveWithRay = (ray) => {
+            if (this.dragUC) {
+                this.dragUC.updateRay(ray);
+            }
+        };
+        this.stop = () => {
+            if (this.dragUC) {
+                this.dragUC.finish();
+                this.dragUC.dispatchStateChangeOnComplete = true;
+                this.dragUC.submitUndoOnComplete = true;
+                if (this.selection && this.addingCallout) {
+                    this.selection.selectedObjectId = this.addingCallout.appObject.id;
+                }
+            }
+            this.addingCallout = undefined;
+            this.dragUC = undefined;
+        };
+        this.cancel = () => {
+            var _a;
+            if (!this.addingCallout)
+                return;
+            (_a = this.addingCallout.inRepo) === null || _a === void 0 ? void 0 : _a.deleteCallout(this.addingCallout.id);
+            this.addingCallout = undefined;
+            this.dragUC = undefined;
+        };
+    }
+    get selection() {
+        return this.getCachedSingleton(Selection_1.Selection.type);
+    }
+    get pixelToRay() {
+        var _a;
+        return (_a = this.getCachedSingleton(UC_1.PixelToSceneRayUC.type)) === null || _a === void 0 ? void 0 : _a.pixelToSceneRay;
+    }
+    initializeWithPixel(pixel) {
+        if (!this.pixelToRay) {
+            this.error("Missing component");
+            return false;
+        }
+        const ray = this.pixelToRay(pixel);
+        return this.initializeWithRay(ray);
+    }
+}

package/lib/Components/Callouts/UC/TryBumpLabelUC.d.ts

@@ -0,0 +1,9 @@
+import { AppObject, AppObjectUC } from "../../../AppObject";
+import { ParametricLine, Vector2 } from "../../../ValueObjects";
+export declare abstract class TryBumpLabelUC extends AppObjectUC {
+    static readonly type = "TryBumpLabelUC";
+    abstract allow(): boolean;
+    abstract tryWithRay(direction: "IN" | "OUT", ray: ParametricLine): void;
+    abstract tryWithPixel(direction: "IN" | "OUT", pixel: Vector2): void;
+}
+export declare function makeTryBumpLabelUC(appObject: AppObject): TryBumpLabelUC;

package/lib/Components/Callouts/UC/TryBumpLabelUC.js

@@ -0,0 +1,61 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.makeTryBumpLabelUC = exports.TryBumpLabelUC = void 0;
+const AppObject_1 = require("../../../AppObject");
+const Babylon_1 = require("../../Babylon");
+const SceneRayPickUC_1 = require("../../Babylon/UC/SceneRayPickUC");
+const CalloutEntity_1 = require("../Entities/CalloutEntity");
+const MoveCalloutToCamUC_1 = require("./MoveCalloutToCamUC");
+class TryBumpLabelUC extends AppObject_1.AppObjectUC {
+}
+exports.TryBumpLabelUC = TryBumpLabelUC;
+TryBumpLabelUC.type = "TryBumpLabelUC";
+function makeTryBumpLabelUC(appObject) {
+    return new TryBumpLabelUCImp(appObject);
+}
+exports.makeTryBumpLabelUC = makeTryBumpLabelUC;
+class TryBumpLabelUCImp extends TryBumpLabelUC {
+    constructor(appObject) {
+        super(appObject, TryBumpLabelUC.type);
+        this.allow = () => {
+            return true;
+        };
+        this.tryWithRay = (direction, ray) => {
+            var _a;
+            if (!this.allow()) {
+                return;
+            }
+            const scenePick = (_a = SceneRayPickUC_1.SceneRayPickUC.get(this.appObjects)) === null || _a === void 0 ? void 0 : _a.sceneRayPick(ray);
+            if (!scenePick || !scenePick.worldPickPoint)
+                return;
+            const appObjectID = scenePick.appObjectID;
+            if (!appObjectID)
+                return;
+            const callout = CalloutEntity_1.CalloutEntity.getById(appObjectID, this.appObjects);
+            if (!callout) {
+                return;
+            }
+            const uc = callout.labelTransform.appObject.getComponent(MoveCalloutToCamUC_1.MoveCalloutToCamUC.type);
+            if (!uc) {
+                return;
+            }
+            let bump = 0.1;
+            if (direction === "IN") {
+                bump = -bump;
+            }
+            uc.moveCalloutToCam(bump);
+            return;
+        };
+    }
+    get pixelToRay() {
+        var _a;
+        return (_a = this.getCachedSingleton(Babylon_1.PixelToSceneRayUC.type)) === null || _a === void 0 ? void 0 : _a.pixelToSceneRay;
+    }
+    tryWithPixel(direction, pixel) {
+        if (!this.pixelToRay) {
+            return;
+        }
+        const ray = this.pixelToRay(pixel);
+        return this.tryWithRay(direction, ray);
+    }
+}

package/lib/Components/Callouts/UC/TryPanLabelUC.d.ts

@@ -0,0 +1,3 @@
+import { AppObject } from "../../../AppObject";
+import { TryPanTransformUC } from "../../Transform3D/UC";
+export declare function makeTryPanLabelUC(appObject: AppObject): TryPanTransformUC;

package/lib/Components/Callouts/UC/TryPanLabelUC.js

@@ -0,0 +1,38 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.makeTryPanLabelUC = void 0;
+const SceneRayPickUC_1 = require("../../Babylon/UC/SceneRayPickUC");
+const UC_1 = require("../../Transform3D/UC");
+const CalloutEntity_1 = require("../Entities/CalloutEntity");
+function makeTryPanLabelUC(appObject) {
+    return new TryPanLabelUC(appObject);
+}
+exports.makeTryPanLabelUC = makeTryPanLabelUC;
+class TryPanLabelUC extends UC_1.TryPanTransformUCImp {
+    constructor() {
+        super(...arguments);
+        this.tryWithRay = (pickRay) => {
+            var _a;
+            this.panUC = undefined;
+            if (!this.allow()) {
+                return false;
+            }
+            const scenePick = (_a = SceneRayPickUC_1.SceneRayPickUC.get(this.appObjects)) === null || _a === void 0 ? void 0 : _a.sceneRayPick(pickRay);
+            if (!scenePick || !scenePick.worldPickPoint)
+                return false;
+            const appObjectID = scenePick.appObjectID;
+            if (!appObjectID)
+                return false;
+            const callout = CalloutEntity_1.CalloutEntity.getById(appObjectID, this.appObjects);
+            if (!callout) {
+                return false;
+            }
+            this.panUC = callout.labelTransform.appObject.getComponent(UC_1.PanTransformUC.type);
+            if (!this.panUC) {
+                return false;
+            }
+            this.panUC.initializeRay(pickRay);
+            return true;
+        };
+    }
+}

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

@@ -0,0 +1,13 @@
+export * from "./CalloutScaleHook";
+export * from "./CreateCalloutUC";
+export * from "./CreateCalloutUndoRedo";
+export * from "./DeleteAllCalloutsUC";
+export * from "./DeleteAllCalloutsUndoRedo";
+export * from "./DeleteCallout";
+export * from "./DeleteCalloutUndoRedo";
+export * from "./LookAtCameraUC";
+export * from "./SerializeCallouts";
+export * from "./SetCalloutSizeUC";
+export * from "./SetCalloutSizeUndoRedo";
+export * from "./TryAddCallout";
+export * from "./TryPanLabelUC";

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

@@ -0,0 +1,25 @@
+"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("./CalloutScaleHook"), exports);
+__exportStar(require("./CreateCalloutUC"), exports);
+__exportStar(require("./CreateCalloutUndoRedo"), exports);
+__exportStar(require("./DeleteAllCalloutsUC"), exports);
+__exportStar(require("./DeleteAllCalloutsUndoRedo"), exports);
+__exportStar(require("./DeleteCallout"), exports);
+__exportStar(require("./DeleteCalloutUndoRedo"), exports);
+__exportStar(require("./LookAtCameraUC"), exports);
+__exportStar(require("./SerializeCallouts"), exports);
+__exportStar(require("./SetCalloutSizeUC"), exports);
+__exportStar(require("./SetCalloutSizeUndoRedo"), exports);
+__exportStar(require("./TryAddCallout"), exports);
+__exportStar(require("./TryPanLabelUC"), exports);