@vived/app 2.9.0 → 2.11.1

package/lib/Entities/OrbitCamera.js

@@ -8,11 +8,108 @@ function makeOrbitCamera() {
 exports.makeOrbitCamera = makeOrbitCamera;
 class OrbitCameraImp {
     constructor() {
+        this.farClip = 100;
+        this.nearClip = 0.01;
+        this.defaultAlpha = 0;
+        this.defaultBeta = 30;
+        this.defaultRadius = 8;
+        this.defaultTarget = _1.Vector3.Zero();
+        this.orbitPixelSensitivity = 0.5;
+        this.dollyPixelSensitivity = 0.01;
+        this.dollyRollSensitivity = 0.001;
+        this.dollyPinchSensitivity = 0.005;
+        this.limitRadius = false;
+        this.minRadius = 0;
+        this.maxRadius = 0;
+        this.limitAlpha = false;
+        this.minAlpha = 0;
+        this.maxAlpha = 0;
+        this.limitBeta = false;
+        this.minBeta = 0;
+        this.maxBeta = 0;
+        this.limitTarget = false;
+        this.maxTargetPosition = _1.Vector3.Zero();
+        this.minTargetPosition = _1.Vector3.Zero();
         this.observers = new _1.ObserverList();
         this.memoizedAlpha = new _1.MemoizedNumber(0, this.observers.notify);
         this.memoizedBeta = new _1.MemoizedNumber(0, this.observers.notify);
         this.memoizedRadius = new _1.MemoizedNumber(1, this.observers.notify);
         this.memoizedTarget = new _1.MemoizedVector3(_1.Vector3.Zero(), this.observers.notify);
+        this.setRadiusLimits = (min, max) => {
+            if (min < 0) {
+                throw new Error("[Orbit Camera] Mininum Radius must be greater >= 0");
+            }
+            if (max < min) {
+                throw new Error("[Orbit Camera] Max radius must be >= min radius");
+            }
+            this.maxRadius = max;
+            this.minRadius = min;
+            this.limitRadius = true;
+            this.radius = this.radius;
+        };
+        this.clearRadiusLimits = () => {
+            this.maxRadius = 0;
+            this.minRadius = 0;
+            this.limitRadius = false;
+        };
+        this.setAlphaLimits = (min, max) => {
+            if (min > max) {
+                throw new Error("[Orbit Camera] Max alpha must be >= min alpha");
+            }
+            if (min < -180) {
+                throw new Error("[Orbit Camera] Min alpha must be >= -180");
+            }
+            if (max > 180) {
+                throw new Error("[Orbit Camera] Max alpha must be <= 180");
+            }
+            this.maxAlpha = max;
+            this.minAlpha = min;
+            this.limitAlpha = true;
+            this.alpha = this.alpha;
+        };
+        this.clearAlphaLimits = () => {
+            this.maxAlpha = 0;
+            this.minAlpha = 0;
+            this.limitAlpha = false;
+        };
+        this.setBetaLimits = (min, max) => {
+            if (min > max) {
+                throw new Error("[Orbit Camera] Max beta must be >= min beta");
+            }
+            if (min < -180) {
+                throw new Error("[Orbit Camera] Min beta must be >= -180");
+            }
+            if (max > 180) {
+                throw new Error("[Orbit Camera] Max beta must be <= 180");
+            }
+            this.maxBeta = max;
+            this.minBeta = min;
+            this.limitBeta = true;
+            this.beta = this.beta;
+        };
+        this.clearBetaLimits = () => {
+            this.maxBeta = 0;
+            this.minBeta = 0;
+            this.limitBeta = false;
+        };
+        this.setTargetLimits = (min, max) => {
+            const minArray = min.asArray();
+            const maxArray = max.asArray();
+            for (let i = 0; i < 3; i++) {
+                if (minArray[i] > maxArray[i]) {
+                    throw new Error("[Orbit Camera] Min target must be less than the max target");
+                }
+            }
+            this.maxTargetPosition = max;
+            this.minTargetPosition = min;
+            this.limitTarget = true;
+            this.target = this.target;
+        };
+        this.clearTargetLimits = () => {
+            this.maxTargetPosition = _1.Vector3.Zero();
+            this.minTargetPosition = _1.Vector3.Zero();
+            this.limitTarget = false;
+        };
         this.registerLerp = (lerper) => {
             if (this.currentLerp) {
                 this.currentLerp.cancelLerp();
@@ -27,6 +124,52 @@ class OrbitCameraImp {
             (_a = this.currentLerp) === null || _a === void 0 ? void 0 : _a.cancelLerp();
             this.currentLerp = undefined;
         };
+        this.applyData = (data) => {
+            if (data.defaultAlpha !== undefined) {
+                this.defaultAlpha = data.defaultAlpha;
+            }
+            if (data.defaultBeta !== undefined) {
+                this.defaultBeta = data.defaultBeta;
+            }
+            if (data.defaultRadius !== undefined) {
+                this.defaultRadius = data.defaultRadius;
+            }
+            if (data.defaultTarget !== undefined) {
+                const { x, y, z } = data.defaultTarget;
+                this.defaultTarget = new _1.Vector3(x, y, z);
+            }
+            if (data.nearClip !== undefined) {
+                this.nearClip = data.nearClip;
+            }
+            if (data.farClip !== undefined) {
+                this.farClip = data.farClip;
+            }
+            if (data.alphaLimit !== undefined) {
+                this.setAlphaLimits(data.alphaLimit.min, data.alphaLimit.max);
+            }
+            if (data.betaLimit !== undefined) {
+                this.setBetaLimits(data.betaLimit.min, data.betaLimit.max);
+            }
+            if (data.radiusLimit !== undefined) {
+                this.setRadiusLimits(data.radiusLimit.min, data.radiusLimit.max);
+            }
+            if (data.targetLimit !== undefined) {
+                const { max, min } = data.targetLimit;
+                this.setTargetLimits(new _1.Vector3(min.x, min.y, min.z), new _1.Vector3(max.x, max.y, max.z));
+            }
+            if (data.dollyRollSensitivity !== undefined) {
+                this.dollyRollSensitivity = data.dollyRollSensitivity;
+            }
+            if (data.dollyPixelSensitivity !== undefined) {
+                this.dollyPixelSensitivity = data.dollyPixelSensitivity;
+            }
+            if (data.dollyPinchSensitivity !== undefined) {
+                this.dollyPinchSensitivity = data.dollyPinchSensitivity;
+            }
+            if (data.orbitPixelSensitivity !== undefined) {
+                this.orbitPixelSensitivity = data.orbitPixelSensitivity;
+            }
+        };
         this.addObserver = (observer) => {
             this.observers.add(observer);
         };
@@ -38,25 +181,51 @@ class OrbitCameraImp {
         return this.memoizedAlpha.val;
     }
     set alpha(val) {
-        this.memoizedAlpha.val = this.clampAngle(val);
+        let clampedVal = this.clampAngle(val);
+        if (this.limitAlpha) {
+            clampedVal = Math.min(clampedVal, this.maxAlpha);
+            clampedVal = Math.max(clampedVal, this.minAlpha);
+        }
+        this.memoizedAlpha.val = clampedVal;
     }
     get beta() {
         return this.memoizedBeta.val;
     }
     set beta(val) {
-        this.memoizedBeta.val = this.clampAngle(val);
+        let clampedVal = this.clampAngle(val);
+        if (this.limitBeta) {
+            clampedVal = Math.min(clampedVal, this.maxBeta);
+            clampedVal = Math.max(clampedVal, this.minBeta);
+        }
+        this.memoizedBeta.val = clampedVal;
     }
     get radius() {
         return this.memoizedRadius.val;
     }
     set radius(val) {
-        this.memoizedRadius.val = val < 0 ? 0 : val;
+        let clampedVal = Math.max(val, 0);
+        if (this.limitRadius) {
+            clampedVal = Math.min(clampedVal, this.maxRadius);
+            clampedVal = Math.max(clampedVal, this.minRadius);
+        }
+        this.memoizedRadius.val = clampedVal;
     }
     get target() {
         return this.memoizedTarget.getVector();
     }
     set target(val) {
-        this.memoizedTarget.setVector(val);
+        const targetVals = val.asArray();
+        if (this.limitTarget) {
+            const maxVals = this.maxTargetPosition.asArray();
+            const minVals = this.minTargetPosition.asArray();
+            for (let i = 0; i < 3; i++) {
+                let v = targetVals[i];
+                v = Math.min(v, maxVals[i]);
+                v = Math.max(v, minVals[i]);
+                targetVals[i] = v;
+            }
+        }
+        this.memoizedTarget.setVector(new _1.Vector3(targetVals[0], targetVals[1], targetVals[2]));
     }
     clampAngle(angle) {
         const isNegative = angle < 0 ? true : false;

package/lib/Entities/TouchInput.d.ts

@@ -1,3 +1,4 @@
+import { Vector2 } from ".";
 export interface TouchController {
     onTouchStart?: (e: TouchEvent) => void;
     onTouchMove?: (e: TouchEvent) => void;
@@ -6,8 +7,13 @@ export interface TouchController {
 }
 export interface TouchInput {
     eventElement: HTMLElement | undefined;
+    eventElementBounds?: DOMRect;
     setEventElement: (eventElement: HTMLElement) => void;
     clearInputElement: () => void;
+    updateInputElementBounds: () => void;
+    getTouchOffsetPosition: (touch: Touch) => Vector2;
+    getDistatnceBetweenTouches: (touch1: Touch, touch2: Touch) => number;
+    getTouchsCenter: (touches: TouchList) => Vector2;
     registerController: (controller: TouchController) => void;
     removeController: (controller: TouchController) => void;
 }

package/lib/Entities/TouchInput.js

@@ -1,6 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.makeTouchInput = void 0;
+const _1 = require(".");
 function makeTouchInput() {
     return new TouchInputImp();
 }
@@ -9,6 +10,40 @@ class TouchInputImp {
     constructor() {
         this.controllers = [];
         this._eventElement = undefined;
+        this.updateInputElementBounds = () => {
+            if (!this._eventElement)
+                return;
+            this.eventElementBounds = this._eventElement.getBoundingClientRect(); // Expensive so we cache
+        };
+        this.getTouchOffsetPosition = (touch) => {
+            if (!this.eventElementBounds) {
+                console.warn("No target bounds");
+                return _1.Vector2.Zero();
+            }
+            const x = touch.clientX - this.eventElementBounds.x;
+            const y = touch.clientY - this.eventElementBounds.y;
+            return new _1.Vector2(x, y);
+        };
+        this.getDistatnceBetweenTouches = (touch1, touch2) => {
+            const t1 = this.getTouchOffsetPosition(touch1);
+            const t2 = this.getTouchOffsetPosition(touch2);
+            const delta = t2.subtract(t1);
+            return delta.magnitued;
+        };
+        this.getTouchsCenter = (touches) => {
+            const touchCount = touches.length;
+            if (touchCount === 0)
+                return _1.Vector2.Zero();
+            let sumX = 0;
+            let sumY = 0;
+            for (let i = 0; i < touchCount; i++) {
+                const touch = touches[i];
+                const touchPos = this.getTouchOffsetPosition(touch);
+                sumX += touchPos.x;
+                sumY += touchPos.y;
+            }
+            return new _1.Vector2(sumX / touches.length, sumY / touches.length);
+        };
         this.setEventElement = (eventElement) => {
             if (this._eventElement)
                 this.clearInputElement();
@@ -16,6 +51,7 @@ class TouchInputImp {
             eventElement.addEventListener("touchmove", this.onTouchMove, false);
             eventElement.addEventListener("touchend", this.onTouchEnd, false);
             eventElement.addEventListener("touchcancel", this.onTouchCancel, false);
+            this.eventElementBounds = eventElement.getBoundingClientRect();
             this._eventElement = eventElement;
         };
         this.onTouchStart = (e) => {

package/lib/Entities/index.d.ts

@@ -10,7 +10,7 @@ export * from "./MemoizedString";
 export * from "./MemoizedVector2";
 export * from "./MemoizedVector3";
 export * from "./ObserverList";
-export * from "./OrbitCamera";
+export * from "./FocusCamera";
 export * from "./ParametricLine";
 export * from "./ParametricPlane";
 export * from "./StateMachine";

package/lib/Entities/index.js

@@ -22,7 +22,7 @@ __exportStar(require("./MemoizedString"), exports);
 __exportStar(require("./MemoizedVector2"), exports);
 __exportStar(require("./MemoizedVector3"), exports);
 __exportStar(require("./ObserverList"), exports);
-__exportStar(require("./OrbitCamera"), exports);
+__exportStar(require("./FocusCamera"), exports);
 __exportStar(require("./ParametricLine"), exports);
 __exportStar(require("./ParametricPlane"), exports);
 __exportStar(require("./StateMachine"), exports);

package/lib/Interface/Controllers/makeAppHandler.d.ts

@@ -9,4 +9,4 @@ export interface AppHandlerFunctions {
     setState: (finalState: string, duration?: number) => void;
     setDevicePreview: (x: number, y: number) => void;
 }
-export declare function makeAppHandler(functions: AppHandlerFunctions): Handler;
+export declare function makeAppHandler(functions: AppHandlerFunctions, verbose?: boolean): Handler;

package/lib/Interface/Controllers/makeAppHandler.js

@@ -2,7 +2,6 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.makeAppHandler = exports.appPayloadVersions = void 0;
 const app_host_boundary_1 = require("@vived/app-host-boundary");
-const verbose = false;
 exports.appPayloadVersions = {
     disposeApp: 1,
     setDevicePreview: 1,
@@ -12,10 +11,13 @@ exports.appPayloadVersions = {
     stopApp: 1,
     setState: 2,
 };
-function makeAppHandler(functions) {
+function makeAppHandler(functions, verbose = false) {
     const handler = (request) => {
+        if (verbose) {
+            console.log(request);
+        }
         switch (request.type) {
-            case app_host_boundary_1.SHOW_BABYLON_INSPECTOR:
+            case 'SHOW_BABYLON_INSPECTOR':
                 if (request.version === exports.appPayloadVersions.showBabylonInspector) {
                     const payload = request.payload;
                     functions.showBabylonInspector(payload.showBabylonInspector);
@@ -24,7 +26,7 @@ function makeAppHandler(functions) {
                     throw new app_host_boundary_1.UnsupportedRequestVerion(request.type, request.version);
                 }
                 break;
-            case app_host_boundary_1.SET_IS_AUTHORING:
+            case 'SET_IS_AUTHORING':
                 if (request.version === exports.appPayloadVersions.setIsAuthoring) {
                     const payload = request.payload;
                     functions.setIsAuthoring(payload.isAuthoring);
@@ -33,7 +35,7 @@ function makeAppHandler(functions) {
                     throw new app_host_boundary_1.UnsupportedRequestVerion(request.type, request.version);
                 }
                 break;
-            case app_host_boundary_1.DISPOSE_APP:
+            case 'DISPOSE_APP':
                 if (request.version === exports.appPayloadVersions.disposeApp) {
                     functions.disposeApp();
                 }
@@ -41,7 +43,7 @@ function makeAppHandler(functions) {
                     throw new app_host_boundary_1.UnsupportedRequestVerion(request.type, request.version);
                 }
                 break;
-            case app_host_boundary_1.STOP_APP:
+            case 'STOP_APP':
                 if (request.version === exports.appPayloadVersions.stopApp) {
                     functions.stopApp();
                 }
@@ -49,7 +51,7 @@ function makeAppHandler(functions) {
                     throw new app_host_boundary_1.UnsupportedRequestVerion(request.type, request.version);
                 }
                 break;
-            case app_host_boundary_1.SET_DEVICE_PREVIEW:
+            case 'SET_DEVICE_PREVIEW':
                 if (request.version === exports.appPayloadVersions.setDevicePreview) {
                     const payload = request.payload;
                     functions.setDevicePreview(payload.x, payload.y);
@@ -58,7 +60,7 @@ function makeAppHandler(functions) {
                     throw new app_host_boundary_1.UnsupportedRequestVerion(request.type, request.version);
                 }
                 break;
-            case app_host_boundary_1.START_APP:
+            case 'START_APP':
                 if (request.version === exports.appPayloadVersions.startApp) {
                     const payload = request.payload;
                     functions.startApp(payload.container);
@@ -67,7 +69,7 @@ function makeAppHandler(functions) {
                     throw new app_host_boundary_1.UnsupportedRequestVerion(request.type, request.version);
                 }
                 break;
-            case app_host_boundary_1.SET_APP_STATE:
+            case 'SET_APP_STATE':
                 if (request.version === exports.appPayloadVersions.setState) {
                     const payload = request.payload;
                     functions.setState(payload.finalState, payload.duration);
@@ -76,7 +78,7 @@ function makeAppHandler(functions) {
                     throw new app_host_boundary_1.UnsupportedRequestVerion(request.type, request.version);
                 }
                 break;
-            case app_host_boundary_1.GET_APP_PAYLOAD_VERSIONS:
+            case 'GET_APP_PAYLOAD_VERSION':
                 if (request.version === 1) {
                     const payload = request.payload;
                     payload.callback(exports.appPayloadVersions);

package/lib/PresentationManagers/FocusCameraPM.d.ts

@@ -0,0 +1,14 @@
+import { FocusCamera, Vector3 } from "../Entities";
+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 Entities_1 = require("../Entities");
+const Utilities_1 = require("../Utilities");
+class FocusCameraPM {
+    constructor(orbitCamera, view) {
+        this.doUpdateView = () => {
+            const { alpha, beta, radius, target } = this.orbitCam;
+            const alphaRadians = Utilities_1.degreesToRadians(alpha);
+            const alphaEuler = new Entities_1.Vector3(0, alphaRadians, 0);
+            const betaRadians = Utilities_1.degreesToRadians(beta);
+            const betaEuler = new Entities_1.Vector3(betaRadians, 0, 0);
+            const cameraLocalPosition = new Entities_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/index.d.ts

@@ -3,4 +3,4 @@ export * from "./IsAuthoringPM";
 export * from "./ShowBabylonInspectorPM";
 export * from "./HasRedoPM";
 export * from "./HasUndoPM";
-export * from "./OrbitCameraPM";
+export * from "./FocusCameraPM";

package/lib/PresentationManagers/index.js

@@ -15,4 +15,4 @@ __exportStar(require("./IsAuthoringPM"), exports);
 __exportStar(require("./ShowBabylonInspectorPM"), exports);
 __exportStar(require("./HasRedoPM"), exports);
 __exportStar(require("./HasUndoPM"), exports);
-__exportStar(require("./OrbitCameraPM"), exports);
+__exportStar(require("./FocusCameraPM"), exports);

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

@@ -0,0 +1,16 @@
+import { FocusCamera, Vector3 } from "../../Entities";
+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,63 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BumpDollyFocusCamera = void 0;
+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;
+                const pickToTarget = this.focusCamera.target.subtract(this.pickPoint);
+                const newLength = pickToTarget.magnitued * percentChange;
+                pickToTarget.setLength(newLength);
+                const newTargetPos = this.pickPoint.add(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 Entities_1 = require("../../Entities");
+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 Entities_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,10 @@
+import { FocusCamera, Vector3 } from "../../Entities";
+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);
+}