@vived/app 3.4.0 → 3.5.1

package/lib/Entities/MeshModel.js

@@ -0,0 +1,174 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.makeMeshModel = exports.MeshModel = void 0;
+const ValueObjects_1 = require("../ValueObjects");
+const MemoizedNumber_1 = require("./MemoizedNumber");
+const MemoizedString_1 = require("./MemoizedString");
+const MemoizedVector3_1 = require("./MemoizedVector3");
+const ModelObject_1 = require("./ModelObject");
+const ObservableEntity_1 = require("./ObservableEntity");
+class MeshModel extends ObservableEntity_1.ObservableEntity {
+}
+exports.MeshModel = MeshModel;
+function makeMeshModel() {
+    return new MeshModelImp();
+}
+exports.makeMeshModel = makeMeshModel;
+class MeshModelImp extends MeshModel {
+    constructor() {
+        super(...arguments);
+        this.objects = [];
+        this._modelFile = undefined;
+        this._memoizedVersion = new MemoizedNumber_1.MemoizedNumber(0, this.notify);
+        this._memoizedName = new MemoizedString_1.MemoizedString("", this.notify);
+        this._memoizedDescription = new MemoizedString_1.MemoizedString("", this.notify);
+        this._image = undefined;
+        this._memoizedBoundsMin = new MemoizedVector3_1.MemoizedVector3(ValueObjects_1.Vector3.Zero(), this.notify);
+        this._memoizedBoundsMax = new MemoizedVector3_1.MemoizedVector3(ValueObjects_1.Vector3.Zero(), this.notify);
+        this._memoizedDefaultPosition = new MemoizedVector3_1.MemoizedVector3(ValueObjects_1.Vector3.Zero(), this.notify);
+        this._defaultRotation = ValueObjects_1.Quaternion.Identity();
+        this._memoizedDefaultScale = new MemoizedNumber_1.MemoizedNumber(1, this.notify);
+        this._imageURL = undefined;
+    }
+    hasObject(id) {
+        return !!this.objects.find((obj) => obj.id === id);
+    }
+    getObjectById(id) {
+        return this.objects.find((obj) => obj.id === id);
+    }
+    getObjectByPath(path) {
+        let rVal;
+        this.objects.forEach((obj) => {
+            if (obj.meshPaths.includes(path)) {
+                rVal = obj;
+            }
+        });
+        return rVal;
+    }
+    addObject(object) {
+        object.addObserver(this.notify);
+        this.objects.push(object);
+        this.notify();
+    }
+    deleteObject(id) {
+        this.objects = this.objects.filter((obj) => {
+            if (obj.id === id) {
+                obj.removeObserver(this.notify);
+                return false;
+            }
+            return true;
+        });
+        this.notify();
+    }
+    get modelFile() {
+        return this._modelFile;
+    }
+    set modelFile(file) {
+        this._modelFile = file;
+        this.notify();
+    }
+    get version() {
+        return this._memoizedVersion.val;
+    }
+    set version(version) {
+        this._memoizedVersion.val = version;
+    }
+    get name() {
+        return this._memoizedName.val;
+    }
+    set name(name) {
+        this._memoizedName.val = name;
+    }
+    get description() {
+        return this._memoizedDescription.val;
+    }
+    set description(description) {
+        this._memoizedDescription.val = description;
+    }
+    get image() {
+        return this._image;
+    }
+    set image(image) {
+        if (!this._image && !image)
+            return;
+        if (this._image && image && this._image.size === image.size)
+            return;
+        this._image = image;
+        if (image === undefined) {
+            this._imageURL = undefined;
+        }
+        else {
+            this._imageURL = URL.createObjectURL(image);
+        }
+        this.notify();
+    }
+    get imageURL() {
+        return this._imageURL;
+    }
+    get bounds_min() {
+        return this._memoizedBoundsMin.val;
+    }
+    set bounds_min(bounds_min) {
+        this._memoizedBoundsMin.val = bounds_min;
+    }
+    get bounds_max() {
+        return this._memoizedBoundsMax.val;
+    }
+    set bounds_max(bounds_max) {
+        this._memoizedBoundsMax.val = bounds_max;
+    }
+    get defaultPosition() {
+        return this._memoizedDefaultPosition.val;
+    }
+    set defaultPosition(position) {
+        this._memoizedDefaultPosition.val = position;
+    }
+    get defaultRotation() {
+        return this._defaultRotation;
+    }
+    set defaultRotation(rotation) {
+        if (ValueObjects_1.Quaternion.Equal(this._defaultRotation, rotation))
+            return;
+        this._defaultRotation = rotation;
+        this.notify();
+    }
+    get defaultScale() {
+        return this._memoizedDefaultScale.val;
+    }
+    set defaultScale(scale) {
+        this._memoizedDefaultScale.val = scale;
+    }
+    getData() {
+        return {
+            version: this.version,
+            objects: this.objects.map((obj) => ({
+                id: obj.id,
+                label: obj.label,
+                meshPaths: [...obj.meshPaths],
+            })),
+            name: this.name,
+            description: this.description,
+            bounds_min: this.bounds_min,
+            bounds_max: this.bounds_max,
+            defaultPosition: this.defaultPosition,
+            defaultRotation: this.defaultRotation,
+            defaultScale: this.defaultScale,
+        };
+    }
+    setData(data) {
+        this.version = data.version;
+        data.objects.forEach((obj) => {
+            const modelObject = ModelObject_1.makeModelObject(obj.id);
+            modelObject.label = obj.label;
+            obj.meshPaths.forEach((path) => modelObject.addMeshPath(path));
+            this.addObject(modelObject);
+        });
+        this.name = data.name;
+        this.description = data.description;
+        this.bounds_min = data.bounds_min;
+        this.bounds_max = data.bounds_max;
+        this.defaultPosition = data.defaultPosition;
+        this.defaultRotation = data.defaultRotation;
+        this.defaultScale = data.defaultScale;
+    }
+}

package/lib/Entities/ModelObject.d.ts

@@ -0,0 +1,10 @@
+import { ObservableEntity } from "./ObservableEntity";
+export declare abstract class ModelObject extends ObservableEntity {
+    abstract readonly id: string;
+    abstract get label(): string;
+    abstract set label(label: string);
+    abstract get meshPaths(): string[];
+    abstract addMeshPath(path: string): void;
+    abstract removeMeshPath(path: string): void;
+}
+export declare function makeModelObject(id: string): ModelObject;

package/lib/Entities/ModelObject.js

@@ -0,0 +1,42 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.makeModelObject = exports.ModelObject = void 0;
+const MemoizedString_1 = require("./MemoizedString");
+const ObservableEntity_1 = require("./ObservableEntity");
+class ModelObject extends ObservableEntity_1.ObservableEntity {
+}
+exports.ModelObject = ModelObject;
+function makeModelObject(id) {
+    return new ModelObjectImp(id);
+}
+exports.makeModelObject = makeModelObject;
+class ModelObjectImp extends ModelObject {
+    constructor(id) {
+        super();
+        this.memoizedLabel = new MemoizedString_1.MemoizedString("", this.notify);
+        this._meshPaths = new Set([]);
+        this.id = id;
+    }
+    get label() {
+        return this.memoizedLabel.val;
+    }
+    set label(label) {
+        this.memoizedLabel.val = label;
+    }
+    get meshPaths() {
+        return Array.from(this._meshPaths);
+    }
+    addMeshPath(path) {
+        if (this._meshPaths.has(path)) {
+            return;
+        }
+        this._meshPaths.add(path);
+        this.notify();
+    }
+    removeMeshPath(path) {
+        if (this._meshPaths.has(path)) {
+            this._meshPaths.delete(path);
+            this.notify();
+        }
+    }
+}

package/lib/PresentationManagers/FocusCameraPM.d.ts

@@ -0,0 +1,15 @@
+import { FocusCamera } from "../Entities";
+import { Vector3 } from "../ValueObjects";
+export interface FocusCameraVM {
+    alphaEuler: Vector3;
+    betaEuler: Vector3;
+    cameraLocalPosition: Vector3;
+    target: Vector3;
+}
+export declare class FocusCameraPM {
+    private orbitCam;
+    private view;
+    dispose(): void;
+    private doUpdateView;
+    constructor(orbitCamera: FocusCamera, view: (vm: FocusCameraVM) => void);
+}

package/lib/PresentationManagers/FocusCameraPM.js

@@ -0,0 +1,31 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FocusCameraPM = void 0;
+const Utilities_1 = require("../Utilities");
+const ValueObjects_1 = require("../ValueObjects");
+class FocusCameraPM {
+    constructor(orbitCamera, view) {
+        this.doUpdateView = () => {
+            const { alpha, beta, radius, target } = this.orbitCam;
+            const alphaRadians = Utilities_1.degreesToRadians(alpha);
+            const alphaEuler = new ValueObjects_1.Vector3(0, alphaRadians, 0);
+            const betaRadians = Utilities_1.degreesToRadians(beta);
+            const betaEuler = new ValueObjects_1.Vector3(betaRadians, 0, 0);
+            const cameraLocalPosition = new ValueObjects_1.Vector3(0, 0, -radius);
+            this.view({
+                alphaEuler,
+                betaEuler,
+                cameraLocalPosition,
+                target,
+            });
+        };
+        this.orbitCam = orbitCamera;
+        this.view = view;
+        this.doUpdateView();
+        this.orbitCam.addObserver(this.doUpdateView);
+    }
+    dispose() {
+        this.orbitCam.removeObserver(this.doUpdateView);
+    }
+}
+exports.FocusCameraPM = FocusCameraPM;

package/lib/PresentationManagers/FocusCameraPosRotPM.d.ts

@@ -0,0 +1,13 @@
+import { FocusCamera } from "../Entities";
+import { Vector3 } from "../ValueObjects";
+export interface FocusCameraPosRotVM {
+    position: Vector3;
+    rotation: Vector3;
+}
+export declare class FocusCameraPosRotPM {
+    private focusCam;
+    private view;
+    dispose(): void;
+    private doUpdateView;
+    constructor(orbitCamera: FocusCamera, view: (vm: FocusCameraPosRotVM) => void);
+}

package/lib/PresentationManagers/FocusCameraPosRotPM.js

@@ -0,0 +1,28 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FocusCameraPosRotPM = void 0;
+const Utilities_1 = require("../Utilities");
+const ValueObjects_1 = require("../ValueObjects");
+class FocusCameraPosRotPM {
+    constructor(orbitCamera, view) {
+        this.doUpdateView = () => {
+            const { alpha, beta } = this.focusCam;
+            const alphaRadians = Utilities_1.degreesToRadians(alpha);
+            const betaRadians = Utilities_1.degreesToRadians(beta);
+            const position = this.focusCam.cameraPosition;
+            const rotation = new ValueObjects_1.Vector3(betaRadians, alphaRadians, 0);
+            this.view({
+                position,
+                rotation,
+            });
+        };
+        this.focusCam = orbitCamera;
+        this.view = view;
+        this.doUpdateView();
+        this.focusCam.addObserver(this.doUpdateView);
+    }
+    dispose() {
+        this.focusCam.removeObserver(this.doUpdateView);
+    }
+}
+exports.FocusCameraPosRotPM = FocusCameraPosRotPM;

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

@@ -0,0 +1,15 @@
+import { Color, SceneModel } from "../../Entities";
+import { PresentionManager } from "../PresentationManager";
+export interface SceneMeshOverlayColorVM {
+    overlayColor: Color | undefined;
+}
+export declare class SceneMeshOverlayPM extends PresentionManager {
+    private sceneModel;
+    private id;
+    private updateView;
+    private previousVM?;
+    doUpdateView: () => void;
+    private vmHasChanged;
+    constructor(sceneModel: SceneModel, id: string, updateView: (vm: SceneMeshOverlayColorVM) => void);
+}
+export declare const defaultSceneModelVM: SceneMeshOverlayColorVM;

package/lib/PresentationManagers/SceneModel/SceneMeshOverlayPM.js

@@ -0,0 +1,34 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.defaultSceneModelVM = exports.SceneMeshOverlayPM = void 0;
+const PresentationManager_1 = require("../PresentationManager");
+class SceneMeshOverlayPM extends PresentationManager_1.PresentionManager {
+    constructor(sceneModel, id, updateView) {
+        super(sceneModel);
+        this.sceneModel = sceneModel;
+        this.id = id;
+        this.updateView = updateView;
+        this.doUpdateView = () => {
+            const sceneModelMesh = this.sceneModel.getMeshById(this.id);
+            const vm = {
+                overlayColor: sceneModelMesh === null || sceneModelMesh === void 0 ? void 0 : sceneModelMesh.overlayColor,
+            };
+            if (!this.vmHasChanged(vm))
+                return;
+            this.updateView(vm);
+            this.previousVM = vm;
+        };
+        this.doUpdateView();
+    }
+    vmHasChanged(vm) {
+        if (this.previousVM === undefined)
+            return true;
+        if (this.previousVM.overlayColor !== vm.overlayColor)
+            return true;
+        return false;
+    }
+}
+exports.SceneMeshOverlayPM = SceneMeshOverlayPM;
+exports.defaultSceneModelVM = {
+    overlayColor: undefined,
+};

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);
+}