@vived/app 4.2.0 → 4.3.0

package/lib/PresentationManagers/SceneModel/SceneModelPM.js

@@ -0,0 +1,36 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.defaultSceneModelVM = exports.SceneModelPM = void 0;
+const PresentationManager_1 = require("../PresentationManager");
+class SceneModelPM extends PresentationManager_1.PresentionManager {
+    constructor(sceneModelRepo, updateView) {
+        super(sceneModelRepo);
+        this.sceneModelRepo = sceneModelRepo;
+        this.updateView = updateView;
+        this.doUpdateView = () => {
+            const sceneModelID = this.sceneModelRepo.activeModelID;
+            const vm = {
+                activeSceneModelID: sceneModelID,
+                isLoading: this.sceneModelRepo.isLoadingSceneModel,
+            };
+            if (!this.vmHasChanged(vm))
+                return;
+            this.updateView(vm);
+            this.previousVM = vm;
+        };
+        this.doUpdateView();
+    }
+    vmHasChanged(vm) {
+        if (this.previousVM === undefined)
+            return true;
+        if (this.previousVM.activeSceneModelID !== vm.activeSceneModelID ||
+            this.previousVM.isLoading !== vm.isLoading)
+            return true;
+        return false;
+    }
+}
+exports.SceneModelPM = SceneModelPM;
+exports.defaultSceneModelVM = {
+    isLoading: false,
+    activeSceneModelID: "",
+};

package/lib/PresentationManagers/SceneModel/index.d.ts

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

package/lib/PresentationManagers/SceneModel/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("./SceneModelPM"), exports);

package/lib/PresentationManagers/SceneObject/SceneObjectPM.d.ts

@@ -0,0 +1,22 @@
+import { SceneObject } from "../../Entities";
+import { Quaternion, Vector3 } from "../../ValueObjects";
+import { PresentionManager } from "../PresentationManager";
+export interface SceneObjectVM {
+    position: Vector3;
+    rotation: Quaternion;
+    scale: Vector3;
+    enabled: boolean;
+    selected: boolean;
+    hovered: boolean;
+    pressed: boolean;
+    defaultLabel: string;
+    label: string;
+}
+export declare class SceneObjectPM extends PresentionManager {
+    private sceneObject;
+    private updateView;
+    private lastVM?;
+    doUpdateView: () => void;
+    private vmHasChanged;
+    constructor(sceneObject: SceneObject, updateView: (vm: SceneObjectVM) => void);
+}

package/lib/PresentationManagers/SceneObject/SceneObjectPM.js

@@ -0,0 +1,57 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SceneObjectPM = void 0;
+const ValueObjects_1 = require("../../ValueObjects");
+const PresentationManager_1 = require("../PresentationManager");
+class SceneObjectPM extends PresentationManager_1.PresentionManager {
+    constructor(sceneObject, updateView) {
+        super(sceneObject);
+        this.sceneObject = sceneObject;
+        this.updateView = updateView;
+        this.doUpdateView = () => {
+            const enabled = this.sceneObject.shown && this.sceneObject.enabled;
+            const label = this.sceneObject.customLabel.length > 0 ?
+                this.sceneObject.customLabel : this.sceneObject.defaultLabel;
+            const vm = {
+                position: this.sceneObject.transform.localPosition,
+                rotation: this.sceneObject.transform.localRotation,
+                scale: this.sceneObject.transform.localScale,
+                enabled,
+                selected: this.sceneObject.selected,
+                hovered: this.sceneObject.hovered,
+                pressed: this.sceneObject.pressed,
+                defaultLabel: this.sceneObject.defaultLabel,
+                label
+            };
+            if (this.vmHasChanged(vm)) {
+                this.updateView(vm);
+                this.lastVM = vm;
+            }
+        };
+        this.doUpdateView();
+    }
+    vmHasChanged(newVM) {
+        if (this.lastVM === undefined)
+            return true;
+        if (this.lastVM.enabled !== newVM.enabled)
+            return true;
+        if (!ValueObjects_1.Vector3.Equal(this.lastVM.position, newVM.position))
+            return true;
+        if (!ValueObjects_1.Vector3.Equal(this.lastVM.scale, newVM.scale))
+            return true;
+        if (!ValueObjects_1.Quaternion.Close(this.lastVM.rotation, newVM.rotation))
+            return true;
+        if (this.lastVM.selected !== newVM.selected)
+            return true;
+        if (this.lastVM.hovered !== newVM.hovered)
+            return true;
+        if (this.lastVM.pressed !== newVM.pressed)
+            return true;
+        if (this.lastVM.defaultLabel !== newVM.defaultLabel)
+            return true;
+        if (this.lastVM.label !== newVM.label)
+            return true;
+        return false;
+    }
+}
+exports.SceneObjectPM = SceneObjectPM;

package/lib/PresentationManagers/SceneObject/index.d.ts

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

package/lib/PresentationManagers/SceneObject/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("./SceneObjectPM"), exports);

package/lib/PresentationManagers/ShowBabylonInspectorPM.d.ts

@@ -0,0 +1,9 @@
+import { Babylon } from "../Entities";
+export declare class ShowBabylonInspectorPM {
+    private babylon;
+    private updateView;
+    private lastSetState?;
+    private doUpdateView;
+    dispose(): void;
+    constructor(babylon: Babylon, updateView: (showInspector: boolean) => void);
+}

package/lib/PresentationManagers/ShowBabylonInspectorPM.js

@@ -0,0 +1,24 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ShowBabylonInspectorPM = void 0;
+class ShowBabylonInspectorPM {
+    constructor(babylon, updateView) {
+        this.doUpdateView = () => {
+            const showInspector = this.babylon.showInspector;
+            const hasCanvas = this.babylon.renderCanvas === undefined ? false : true;
+            const showBeShown = hasCanvas && showInspector;
+            if (showBeShown === this.lastSetState)
+                return;
+            this.updateView(showBeShown);
+            this.lastSetState = showBeShown;
+        };
+        this.babylon = babylon;
+        this.updateView = updateView;
+        this.doUpdateView();
+        this.babylon.addObserver(this.doUpdateView);
+    }
+    dispose() {
+        this.babylon.removeObserver(this.doUpdateView);
+    }
+}
+exports.ShowBabylonInspectorPM = ShowBabylonInspectorPM;

package/lib/PresentationManagers/ToolPM.d.ts

@@ -0,0 +1,17 @@
+import { Tool } from "../Entities";
+import { PresentionManager } from "./PresentationManager";
+export interface ToolVM<ToolType> {
+    type: ToolType;
+    label: string;
+    enabled: boolean;
+    selected: boolean;
+    show: boolean;
+    shortcutLabel: string;
+    tooltipLabel: string;
+}
+export declare class ToolPM<ToolType> extends PresentionManager {
+    private tool;
+    private updateView;
+    doUpdateView: () => void;
+    constructor(tool: Tool<ToolType>, updateView: (tools: ToolVM<ToolType>) => void);
+}

package/lib/PresentationManagers/ToolPM.js

@@ -0,0 +1,35 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ToolPM = void 0;
+const Entities_1 = require("../Entities");
+const PresentationManager_1 = require("./PresentationManager");
+class ToolPM extends PresentationManager_1.PresentionManager {
+    constructor(tool, updateView) {
+        super(tool);
+        this.tool = tool;
+        this.updateView = updateView;
+        this.doUpdateView = () => {
+            const { type, state, label, shortcutLabel } = this.tool;
+            let enabled = false;
+            if (state === Entities_1.ToolState.ACTIVE ||
+                state === Entities_1.ToolState.ENABLED) {
+                enabled = true;
+            }
+            const selected = state === Entities_1.ToolState.ACTIVE ? true : false;
+            const show = state === Entities_1.ToolState.HIDDEN ? false : true;
+            const tooltipLabel = `${label} [${shortcutLabel}]`;
+            const vm = {
+                type,
+                enabled,
+                label,
+                selected,
+                show,
+                shortcutLabel,
+                tooltipLabel,
+            };
+            this.updateView(vm);
+        };
+        this.doUpdateView();
+    }
+}
+exports.ToolPM = ToolPM;

package/lib/PresentationManagers/TransformNodePM.d.ts

@@ -0,0 +1,14 @@
+import { TransformNode } from "../Entities";
+import { Quaternion, Vector3 } from "../ValueObjects";
+export interface TransformNodeVM {
+    position: Vector3;
+    rotation: Quaternion;
+    scale: Vector3;
+}
+export declare class TransformNodePM {
+    private transformNode;
+    private updateView;
+    dispose: () => void;
+    doUpdateView: () => void;
+    constructor(transformNode: TransformNode, updateView: (vm: TransformNodeVM) => void);
+}

package/lib/PresentationManagers/TransformNodePM.js

@@ -0,0 +1,23 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TransformNodePM = void 0;
+class TransformNodePM {
+    constructor(transformNode, updateView) {
+        this.transformNode = transformNode;
+        this.updateView = updateView;
+        this.dispose = () => {
+            this.transformNode.removeObserver(this.doUpdateView);
+        };
+        this.doUpdateView = () => {
+            const vm = {
+                position: this.transformNode.localPosition,
+                rotation: this.transformNode.localRotation,
+                scale: this.transformNode.localScale,
+            };
+            this.updateView(vm);
+        };
+        transformNode.addObserver(this.doUpdateView);
+        this.doUpdateView();
+    }
+}
+exports.TransformNodePM = TransformNodePM;

package/lib/PresentationManagers/index.d.ts

@@ -0,0 +1,13 @@
+export * from "./DevicePreviewPM";
+export * from "./FramedScreenContainerPM";
+export * from "./IsAuthoringPM";
+export * from "./PresentationManager";
+export * from "./ShowBabylonInspectorPM";
+export * from "./HasRedoPM";
+export * from "./HasUndoPM";
+export * from "./QuestionChallenge";
+export * from "./SceneModel";
+export * from "./SceneObject";
+export * from "./ToolPM";
+export * from "./TransformNodePM";
+export * from "./HoverLabels";

package/lib/PresentationManagers/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("./DevicePreviewPM"), exports);
+__exportStar(require("./FramedScreenContainerPM"), exports);
+__exportStar(require("./IsAuthoringPM"), exports);
+__exportStar(require("./PresentationManager"), exports);
+__exportStar(require("./ShowBabylonInspectorPM"), exports);
+__exportStar(require("./HasRedoPM"), exports);
+__exportStar(require("./HasUndoPM"), exports);
+__exportStar(require("./QuestionChallenge"), exports);
+__exportStar(require("./SceneModel"), exports);
+__exportStar(require("./SceneObject"), exports);
+__exportStar(require("./ToolPM"), exports);
+__exportStar(require("./TransformNodePM"), exports);
+__exportStar(require("./HoverLabels"), exports);

package/lib/UseCases/FocusCamera/BumpDollyFocusCamera.d.ts

@@ -0,0 +1,17 @@
+import { FocusCamera } from "../../Entities";
+import { Vector3 } from "../../ValueObjects";
+export declare class BumpDollyFocusCamera {
+    private focusCamera;
+    bumpDurationMS: number;
+    bumpLerp: (percent: number) => number;
+    bumpAmount: number;
+    private interval?;
+    private chrono;
+    private delta;
+    private initialRadius;
+    private finalRadius;
+    private pickPoint?;
+    private onTick;
+    bump(direction: "IN" | "OUT", target?: Vector3): void;
+    constructor(focusCamera: FocusCamera);
+}

package/lib/UseCases/FocusCamera/BumpDollyFocusCamera.js

@@ -0,0 +1,64 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BumpDollyFocusCamera = void 0;
+const ValueObjects_1 = require("../../ValueObjects");
+class BumpDollyFocusCamera {
+    constructor(focusCamera) {
+        this.focusCamera = focusCamera;
+        this.bumpDurationMS = 500;
+        this.bumpLerp = (p) => {
+            return p;
+        }; // Linear
+        this.bumpAmount = 0.1;
+        this.chrono = 0;
+        this.delta = 10;
+        this.initialRadius = 0;
+        this.finalRadius = 0;
+        this.onTick = () => {
+            this.chrono = this.chrono + this.delta;
+            let nomralizedTime = this.chrono / this.bumpDurationMS;
+            if (nomralizedTime > 1) {
+                nomralizedTime = 1;
+            }
+            const percent = this.bumpLerp(nomralizedTime);
+            const range = this.finalRadius - this.initialRadius;
+            const currentRadius = this.focusCamera.radius;
+            this.focusCamera.radius = this.initialRadius + range * percent;
+            if (this.pickPoint !== undefined) {
+                const percentChange = this.focusCamera.radius / currentRadius;
+                let pickToTarget = ValueObjects_1.Vector3.Subtract(this.focusCamera.target, this.pickPoint);
+                const newLength = pickToTarget.magnitued * percentChange;
+                pickToTarget = ValueObjects_1.Vector3.NewVectorOfLength(pickToTarget, newLength);
+                const newTargetPos = ValueObjects_1.Vector3.Add(this.pickPoint, pickToTarget);
+                this.focusCamera.target = newTargetPos;
+            }
+            if (nomralizedTime >= 1 && this.interval) {
+                this.focusCamera.radius = this.finalRadius;
+                clearInterval(this.interval);
+                this.interval = undefined;
+                this.pickPoint = undefined;
+            }
+        };
+    }
+    bump(direction, target) {
+        let delta = this.bumpAmount;
+        if (direction === "IN") {
+            delta *= -1;
+        }
+        this.initialRadius = this.focusCamera.radius;
+        if (this.interval) {
+            clearInterval(this.interval);
+            this.interval = undefined;
+            this.finalRadius = this.finalRadius + delta;
+        }
+        else {
+            this.finalRadius = this.initialRadius + delta;
+        }
+        this.chrono = 0;
+        this.pickPoint = target;
+        this.interval = setInterval(() => {
+            this.onTick();
+        }, 10);
+    }
+}
+exports.BumpDollyFocusCamera = BumpDollyFocusCamera;

package/lib/UseCases/FocusCamera/LerpFocusCamera.d.ts

@@ -0,0 +1,36 @@
+import { FocusCamera } from "../../Entities";
+export interface LerpFocusCameraParameters {
+    duration: number;
+    finalRadius?: number;
+    finalBeta?: number;
+    finalAlpha?: number;
+    finalTarget?: {
+        x: number;
+        y: number;
+        z: number;
+    };
+    onComplete?: () => void;
+    onAbort?: () => void;
+}
+export declare class LerpFocusCamera {
+    get isLerping(): boolean;
+    private _isLerping;
+    private focusCamera;
+    private easeFn;
+    private lerpDuration;
+    private lerpRadius;
+    private lerpBeta;
+    private lerpAlpha;
+    private lerpX;
+    private lerpY;
+    private lerpZ;
+    private onComplete?;
+    private onAbort?;
+    private interval;
+    private chrono;
+    private delta;
+    cancelLerp: () => void;
+    private onTick;
+    constructor(focusCamera: FocusCamera, easeFn: (normalizedTime: number) => number, parameters: LerpFocusCameraParameters);
+    private makeLerpNumber;
+}

package/lib/UseCases/FocusCamera/LerpFocusCamera.js

@@ -0,0 +1,71 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LerpFocusCamera = void 0;
+const ValueObjects_1 = require("../../ValueObjects");
+class LerpFocusCamera {
+    constructor(focusCamera, easeFn, parameters) {
+        var _a, _b, _c;
+        this._isLerping = false;
+        this.chrono = 0;
+        this.delta = 10;
+        this.cancelLerp = () => {
+            if (!this._isLerping)
+                return;
+            clearInterval(this.interval);
+            if (this.onAbort) {
+                this.onAbort();
+            }
+            this._isLerping = false;
+        };
+        this.onTick = () => {
+            this.chrono = this.chrono + this.delta / 1000;
+            let nomralizedTime = this.chrono / this.lerpDuration;
+            if (nomralizedTime > 1) {
+                nomralizedTime = 1;
+            }
+            const percent = this.easeFn(nomralizedTime);
+            this.focusCamera.radius = this.lerpRadius(percent);
+            this.focusCamera.beta = this.lerpBeta(percent);
+            this.focusCamera.alpha = this.lerpAlpha(percent);
+            const x = this.lerpX(percent);
+            const y = this.lerpY(percent);
+            const z = this.lerpZ(percent);
+            this.focusCamera.target = new ValueObjects_1.Vector3(x, y, z);
+            if (nomralizedTime >= 1) {
+                clearInterval(this.interval);
+                if (this.onComplete) {
+                    this.onComplete();
+                }
+                this._isLerping = false;
+                this.focusCamera.lerpCompleted();
+            }
+        };
+        this.focusCamera = focusCamera;
+        this.easeFn = easeFn;
+        this.lerpDuration = parameters.duration;
+        this.onComplete = parameters.onComplete;
+        this.onAbort = parameters.onAbort;
+        this.lerpRadius = this.makeLerpNumber(this.focusCamera.radius, parameters.finalRadius);
+        this.lerpBeta = this.makeLerpNumber(this.focusCamera.beta, parameters.finalBeta);
+        this.lerpAlpha = this.makeLerpNumber(this.focusCamera.alpha, parameters.finalAlpha);
+        this.lerpX = this.makeLerpNumber(this.focusCamera.target.x, (_a = parameters.finalTarget) === null || _a === void 0 ? void 0 : _a.x);
+        this.lerpY = this.makeLerpNumber(this.focusCamera.target.y, (_b = parameters.finalTarget) === null || _b === void 0 ? void 0 : _b.y);
+        this.lerpZ = this.makeLerpNumber(this.focusCamera.target.z, (_c = parameters.finalTarget) === null || _c === void 0 ? void 0 : _c.z);
+        this.interval = setInterval(() => {
+            this.onTick();
+        }, this.delta);
+        this.focusCamera.registerLerp(this);
+        this._isLerping = true;
+    }
+    get isLerping() {
+        return this._isLerping;
+    }
+    makeLerpNumber(initial, final) {
+        const actualFinal = final !== null && final !== void 0 ? final : initial;
+        return function Lerp(percent) {
+            const range = actualFinal - initial;
+            return initial + range * percent;
+        };
+    }
+}
+exports.LerpFocusCamera = LerpFocusCamera;

package/lib/UseCases/FocusCamera/PinchDollyFocusCamera.d.ts

@@ -0,0 +1,11 @@
+import { FocusCamera } from "../../Entities";
+import { Vector3 } from "../../ValueObjects";
+export declare class PinchDollyFocusCamera {
+    private focusCamera;
+    sensitivity: number;
+    private previousDistanceBetweenTouches;
+    private pickPoint?;
+    doDolly: (distanceBetweenTouches: number) => void;
+    initializeDolly: (distanceBetweenTouches: number, pickPoint?: Vector3 | undefined) => void;
+    constructor(focusCamera: FocusCamera);
+}

package/lib/UseCases/FocusCamera/PinchDollyFocusCamera.js

@@ -0,0 +1,36 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PinchDollyFocusCamera = void 0;
+const ValueObjects_1 = require("../../ValueObjects");
+class PinchDollyFocusCamera {
+    constructor(focusCamera) {
+        this.focusCamera = focusCamera;
+        this.sensitivity = 0.05;
+        this.previousDistanceBetweenTouches = 0;
+        this.doDolly = (distanceBetweenTouches) => {
+            const pinchDelta = distanceBetweenTouches - this.previousDistanceBetweenTouches;
+            const deltaRadius = pinchDelta * this.sensitivity;
+            const currentRadius = this.focusCamera.radius;
+            this.focusCamera.radius = currentRadius - deltaRadius;
+            if (this.pickPoint !== undefined) {
+                const percentChange = this.focusCamera.radius / currentRadius;
+                let pickToTarget = ValueObjects_1.Vector3.Subtract(this.focusCamera.target, this.pickPoint);
+                const newLength = pickToTarget.magnitued * percentChange;
+                pickToTarget = ValueObjects_1.Vector3.NewVectorOfLength(pickToTarget, newLength);
+                const newTargetPos = ValueObjects_1.Vector3.Add(this.pickPoint, pickToTarget);
+                this.focusCamera.target = newTargetPos;
+            }
+            this.previousDistanceBetweenTouches = distanceBetweenTouches;
+        };
+        this.initializeDolly = (distanceBetweenTouches, pickPoint) => {
+            this.previousDistanceBetweenTouches = distanceBetweenTouches;
+            if (pickPoint) {
+                this.pickPoint = pickPoint;
+            }
+            else {
+                this.pickPoint = undefined;
+            }
+        };
+    }
+}
+exports.PinchDollyFocusCamera = PinchDollyFocusCamera;

package/lib/UseCases/FocusCamera/PixelDollyFocusCamera.d.ts

@@ -0,0 +1,11 @@
+import { FocusCamera } from "../../Entities";
+import { Vector2, Vector3 } from "../../ValueObjects";
+export declare class PixelDollyFocusCamera {
+    private focusCamera;
+    sensitivity: number;
+    private previousPixelPosition;
+    private pickPoint?;
+    doDolly: (pixelPosition: Vector2) => void;
+    initializeDolly: (pixelPosition: Vector2, pickPoint?: Vector3 | undefined) => void;
+    constructor(focusCamera: FocusCamera);
+}

package/lib/UseCases/FocusCamera/PixelDollyFocusCamera.js

@@ -0,0 +1,36 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PixelDollyFocusCamera = void 0;
+const ValueObjects_1 = require("../../ValueObjects");
+class PixelDollyFocusCamera {
+    constructor(focusCamera) {
+        this.focusCamera = focusCamera;
+        this.sensitivity = 0.05;
+        this.previousPixelPosition = ValueObjects_1.Vector2.Zero();
+        this.doDolly = (pixelPosition) => {
+            const pixelDeltaY = pixelPosition.y - this.previousPixelPosition.y;
+            const deltaRadius = pixelDeltaY * this.sensitivity;
+            const currentRadius = this.focusCamera.radius;
+            this.focusCamera.radius = currentRadius - deltaRadius;
+            if (this.pickPoint !== undefined) {
+                const percentChange = this.focusCamera.radius / currentRadius;
+                let pickToTarget = ValueObjects_1.Vector3.Subtract(this.focusCamera.target, this.pickPoint);
+                const newLength = pickToTarget.magnitued * percentChange;
+                pickToTarget = ValueObjects_1.Vector3.NewVectorOfLength(pickToTarget, newLength);
+                const newTargetPos = ValueObjects_1.Vector3.Add(this.pickPoint, pickToTarget);
+                this.focusCamera.target = newTargetPos;
+            }
+            this.previousPixelPosition = pixelPosition;
+        };
+        this.initializeDolly = (pixelPosition, pickPoint) => {
+            this.previousPixelPosition = pixelPosition;
+            if (pickPoint) {
+                this.pickPoint = pickPoint;
+            }
+            else {
+                this.pickPoint = undefined;
+            }
+        };
+    }
+}
+exports.PixelDollyFocusCamera = PixelDollyFocusCamera;

package/lib/UseCases/FocusCamera/PixelOrbitFocusCamera.d.ts

@@ -0,0 +1,11 @@
+import { FocusCamera } from "../../Entities";
+import { Vector2, Vector3 } from "../../ValueObjects";
+export declare class PixelOrbitFocusCamera {
+    private focusCamera;
+    sensitivity: number;
+    private previousPixelPos?;
+    private pickPoint?;
+    doOrbit: (pixelPosition: Vector2) => void;
+    initializeOrbit: (initialPixelPos: Vector2, pickPoint?: Vector3 | undefined) => void;
+    constructor(focusCamera: FocusCamera);
+}

package/lib/UseCases/FocusCamera/PixelOrbitFocusCamera.js

@@ -0,0 +1,26 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PixelOrbitFocusCamera = void 0;
+const ValueObjects_1 = require("../../ValueObjects");
+class PixelOrbitFocusCamera {
+    constructor(focusCamera) {
+        this.focusCamera = focusCamera;
+        this.sensitivity = 0.5;
+        this.doOrbit = (pixelPosition) => {
+            if (!this.previousPixelPos) {
+                console.error("[PixelOrbitFocusCamera] You must initialize first!");
+                return;
+            }
+            const pixelChange = ValueObjects_1.Vector2.Subtract(pixelPosition, this.previousPixelPos);
+            this.focusCamera.alpha += pixelChange.x * this.sensitivity;
+            this.focusCamera.beta += pixelChange.y * this.sensitivity;
+            this.previousPixelPos = pixelPosition;
+        };
+        this.initializeOrbit = (initialPixelPos, pickPoint) => {
+            this.previousPixelPos = initialPixelPos;
+            this.pickPoint = pickPoint;
+            this.focusCamera.cancelLerp();
+        };
+    }
+}
+exports.PixelOrbitFocusCamera = PixelOrbitFocusCamera;