@shapediver/viewer.rendering-engine.camera-engine 2.12.8 → 3.0.0

package/src/implementation/controls/OrthographicCameraControls.ts

@@ -1,130 +1,36 @@
-import { IOrthographicControlsSettingsV3 } from '@shapediver/viewer.settings';
-import { SettingsEngine, StateEngine } from '@shapediver/viewer.shared.services';
-
-import { CAMERA_TYPE, ICamera } from '../..';
-import { IOrthographicCameraControls } from '../../interfaces/controls/IOrthographicCameraControls';
 import { AbstractCameraControls } from './AbstractCameraControls';
-import {
-  CameraControlsEventDistribution as OrthographicCameraControlsEventDistribution,
-} from './orthographic/CameraControlsEventDistribution';
-import { CameraControlsLogic as OrthographicCameraControlsLogic } from './orthographic/CameraControlsLogic';
-
-export class OrthographicCameraControls extends AbstractCameraControls implements IOrthographicCameraControls {
-    // #region Properties (9)
-
-    private _damping: number = 0.1;
-    private _enableKeyPan: boolean = false;
-    private _enablePan: boolean = true;
-    private _enableZoom: boolean = true;
-    private _input: { keys: { up: number, down: number, left: number, right: number }, mouse: { rotate: number, zoom: number, pan: number }, touch: { rotate: number, zoom: number, pan: number } } = { keys: { up: 38, down: 40, left: 37, right: 39 }, mouse: { rotate: 0, zoom: 1, pan: 2 }, touch: { rotate: 1, zoom: 2, pan: 2 }, };
-    private _keyPanSpeed: number = 0.5;
-    private _movementSmoothness: number = 0.5;
-    private _panSpeed: number = 0.5;
-    private _zoomSpeed: number = 0.5;
-
-    private readonly _stateEngine: StateEngine = StateEngine.instance;
-
-    // #endregion Properties (9)
+import { ICamera } from '../..';
+import { CameraControlsLogic } from './CameraControlsLogic';
+import { CameraControlsEventDistribution, } from './CameraControlsEventDistribution';
+export class OrthographicCameraControls extends AbstractCameraControls {
+    // #region Properties (2)
+
+    private _settingsAdjustments = {
+        autoRotationSpeed: 2 * Math.PI / 60 / 60,
+        damping: 1.0,
+        movementSmoothness: 1.0,
+        panSpeed: 1.75,
+        rotationSpeed: Math.PI,
+        zoomSpeed: 0.025,
+    };
+    private _touchAdjustments = {
+        autoRotationSpeed: 1.0,
+        damping: 1.0,
+        movementSmoothness: 1.0,
+        panSpeed: 4.0 / 1.75,
+        rotationSpeed: 1.5,
+        zoomSpeed: 100.0,
+    };
+
+    // #endregion Properties (2)
 
     // #region Constructors (1)
 
     constructor(camera: ICamera, enabled: boolean) {
-        super(camera, enabled, CAMERA_TYPE.ORTHOGRAPHIC);
-        this._cameraLogic = new OrthographicCameraControlsLogic(this);
-        this._cameraControlsEventDistribution = new OrthographicCameraControlsEventDistribution(this, <OrthographicCameraControlsLogic>this._cameraLogic);
-    }
-
-    public applySettings(settingsEngine: SettingsEngine) {
-        const cameraSetting = settingsEngine.camera.cameras[this.camera.id];
-        if(!cameraSetting) return;
-        this.reset();
-        const controlsSettings = <IOrthographicControlsSettingsV3>cameraSetting.controls;
-        this.damping = controlsSettings.damping;
-        this.enableKeyPan = controlsSettings.enableKeyPan;
-        this.enablePan = controlsSettings.enablePan;
-        this.enableZoom = controlsSettings.enableZoom;
-        // this.input = controlsSettings.input;
-        this.keyPanSpeed = controlsSettings.keyPanSpeed;
-        this.movementSmoothness = controlsSettings.movementSmoothness;
-        this.panSpeed = controlsSettings.panSpeed;
-        this.zoomSpeed = controlsSettings.zoomSpeed;
+        super(camera, enabled);
+        this._cameraLogic = new CameraControlsLogic(this, this._settingsAdjustments, this._touchAdjustments);
+        this._cameraControlsEventDistribution = new CameraControlsEventDistribution(this, this._cameraLogic);
     }
 
     // #endregion Constructors (1)
-
-    // #region Public Accessors (18)
-
-    public get damping(): number {
-        return this._damping;
-    }
-
-    public set damping(value: number) {
-        this._damping = value;
-    }
-
-    public get enableKeyPan(): boolean {
-        return this._enableKeyPan;
-    }
-
-    public set enableKeyPan(value: boolean) {
-        this._enableKeyPan = value;
-    }
-
-    public get enablePan(): boolean {
-        return this._enablePan;
-    }
-
-    public set enablePan(value: boolean) {
-        this._enablePan = value;
-    }
-
-    public get enableZoom(): boolean {
-        return this._enableZoom;
-    }
-
-    public set enableZoom(value: boolean) {
-        this._enableZoom = value;
-    }
-
-    public get input(): { keys: { up: number, down: number, left: number, right: number }, mouse: { rotate: number, zoom: number, pan: number }, touch: { rotate: number, zoom: number, pan: number } } {
-        return this._input;
-    }
-
-    public set input(value: { keys: { up: number, down: number, left: number, right: number }, mouse: { rotate: number, zoom: number, pan: number }, touch: { rotate: number, zoom: number, pan: number } }) {
-        this._input = value;
-    }
-
-    public get keyPanSpeed(): number {
-        return this._keyPanSpeed;
-    }
-
-    public set keyPanSpeed(value: number) {
-        this._keyPanSpeed = value;
-    }
-
-    public get movementSmoothness(): number {
-        return this._movementSmoothness;
-    }
-
-    public set movementSmoothness(value: number) {
-        this._movementSmoothness = value;
-    }
-
-    public get panSpeed(): number {
-        return this._panSpeed;
-    }
-
-    public set panSpeed(value: number) {
-        this._panSpeed = value;
-    }
-
-    public get zoomSpeed(): number {
-        return this._zoomSpeed;
-    }
-
-    public set zoomSpeed(value: number) {
-        this._zoomSpeed = value;
-    }
-
-    // #endregion Public Accessors (18)
 }

package/src/implementation/controls/PerspectiveCameraControls.ts

@@ -1,303 +1,37 @@
-import { IOrbitControlsSettingsV3 } from '@shapediver/viewer.settings';
-import { SettingsEngine, StateEngine, Converter } from '@shapediver/viewer.shared.services';
-import { vec3 } from 'gl-matrix';
-
-import { CAMERA_TYPE, ICamera } from '../..';
-import { IPerspectiveCameraControls } from '../../interfaces/controls/IPerspectiveCameraControls';
 import { AbstractCameraControls } from './AbstractCameraControls';
-import {
-    CameraControlsEventDistribution as OrbitCameraControlsEventDistribution,
-} from './perspective/CameraControlsEventDistribution';
-import { CameraControlsLogic as OrbitCameraControlsLogic } from './perspective/CameraControlsLogic';
-
-export class PerspectiveCameraControls extends AbstractCameraControls implements IPerspectiveCameraControls {
-    // #region Properties (25)
-
-    private readonly _converter: Converter = Converter.instance;
-    private readonly _stateEngine: StateEngine = StateEngine.instance;
-
-    private _autoRotationSpeed: number = 0;
-    private _cubePositionRestriction: { min: vec3, max: vec3 } = { min: vec3.fromValues(-Infinity, -Infinity, -Infinity), max: vec3.fromValues(Infinity, Infinity, Infinity) };
-    private _cubeTargetRestriction: { min: vec3, max: vec3 } = { min: vec3.fromValues(-Infinity, -Infinity, -Infinity), max: vec3.fromValues(Infinity, Infinity, Infinity) };
-    private _damping: number = 0.1;
-    private _enableAutoRotation: boolean = false;
-    private _enableAzimuthRotation: boolean = true;
-    private _enableKeyPan: boolean = false;
-    private _enablePan: boolean = true;
-    private _enablePolarRotation: boolean = true;
-    private _enableRotation: boolean = true;
-    private _enableTurntableControls: boolean = false;
-    private _enableZoom: boolean = true;
-    private _input: { keys: { up: number, down: number, left: number, right: number }, mouse: { rotate: number, zoom: number, pan: number }, touch: { rotate: number, zoom: number, pan: number } } = { keys: { up: 38, down: 40, left: 37, right: 39 }, mouse: { rotate: 0, zoom: 1, pan: 2 }, touch: { rotate: 1, zoom: 2, pan: 2 }, };
-    private _keyPanSpeed: number = 0.5;
-    private _movementSmoothness: number = 0.5;
-    private _panSpeed: number = 0.5;
-    private _rotationRestriction: { minPolarAngle: number, maxPolarAngle: number, minAzimuthAngle: number, maxAzimuthAngle: number } = { minPolarAngle: 0, maxPolarAngle: 180, minAzimuthAngle: -Infinity, maxAzimuthAngle: Infinity };
-    private _rotationSpeed: number = 0.5;
-    private _spherePositionRestriction: { center: vec3, radius: number } = { center: vec3.create(), radius: Infinity };
-    private _sphereTargetRestriction: { center: vec3, radius: number } = { center: vec3.create(), radius: Infinity };
-    private _turntableCenter: vec3 = vec3.create();
-    private _zoomRestriction: { minDistance: number, maxDistance: number } = { minDistance: 0, maxDistance: Infinity };
-    private _zoomSpeed: number = 0.5;
-
-    // #endregion Properties (25)
+import { CameraControlsLogic } from './CameraControlsLogic';
+import { ICamera } from '../..';
+import { CameraControlsEventDistribution, } from './CameraControlsEventDistribution';
+
+export class PerspectiveCameraControls extends AbstractCameraControls {
+    // #region Properties (3)
+
+    private _settingsAdjustments = {
+        autoRotationSpeed: 2 * Math.PI / 60 / 60,
+        damping: 1.0,
+        movementSmoothness: 1.0,
+        panSpeed: 1.75,
+        rotationSpeed: Math.PI,
+        zoomSpeed: 0.025,
+    };
+    private _touchAdjustments = {
+        autoRotationSpeed: 1.0,
+        damping: 1.0,
+        movementSmoothness: 1.0,
+        panSpeed: 1.0 / 1.75,
+        rotationSpeed: 1.5,
+        zoomSpeed: 100.0,
+    };
+
+    // #endregion Properties (3)
 
     // #region Constructors (1)
 
     constructor(camera: ICamera, enabled: boolean) {
-        super(camera, enabled, CAMERA_TYPE.PERSPECTIVE);
-        this._cameraLogic = new OrbitCameraControlsLogic(this);
-        this._cameraControlsEventDistribution = new OrbitCameraControlsEventDistribution(this, <OrbitCameraControlsLogic>this._cameraLogic);
+        super(camera, enabled);
+        this._cameraLogic = new CameraControlsLogic(this, this._settingsAdjustments, this._touchAdjustments);
+        this._cameraControlsEventDistribution = new CameraControlsEventDistribution(this, this._cameraLogic);
     }
 
     // #endregion Constructors (1)
-
-    // #region Public Accessors (46)
-
-    public get autoRotationSpeed(): number {
-        return this._autoRotationSpeed;
-    }
-
-    public set autoRotationSpeed(value: number) {
-        this._autoRotationSpeed = value;
-    }
-
-    public get cubePositionRestriction(): { min: vec3, max: vec3 } {
-        return this._cubePositionRestriction;
-    }
-
-    public set cubePositionRestriction(value: { min: vec3, max: vec3 }) {
-        this._cubePositionRestriction = value;
-    }
-
-    public get cubeTargetRestriction(): { min: vec3, max: vec3 } {
-        return this._cubeTargetRestriction;
-    }
-
-    public set cubeTargetRestriction(value: { min: vec3, max: vec3 }) {
-        this._cubeTargetRestriction = value;
-    }
-
-    public get damping(): number {
-        return this._damping;
-    }
-
-    public set damping(value: number) {
-        this._damping = value;
-    }
-
-    public get enableAutoRotation(): boolean {
-        return this._enableAutoRotation;
-    }
-
-    public set enableAutoRotation(value: boolean) {
-        this._enableAutoRotation = value;
-    }
-
-    public get enableAzimuthRotation(): boolean {
-        return this._enableAzimuthRotation;
-    }
-
-    public set enableAzimuthRotation(value: boolean) {
-        this._enableAzimuthRotation = value;
-    }
-
-    public get enableKeyPan(): boolean {
-        return this._enableKeyPan;
-    }
-
-    public set enableKeyPan(value: boolean) {
-        this._enableKeyPan = value;
-    }
-
-    public get enablePan(): boolean {
-        return this._enablePan;
-    }
-
-    public set enablePan(value: boolean) {
-        this._enablePan = value;
-    }
-
-    public get enablePolarRotation(): boolean {
-        return this._enablePolarRotation;
-    }
-
-    public set enablePolarRotation(value: boolean) {
-        this._enablePolarRotation = value;
-    }
-
-    public get enableRotation(): boolean {
-        return this._enableRotation;
-    }
-
-    public set enableRotation(value: boolean) {
-        this._enableRotation = value;
-    }
-
-    public get enableTurntableControls(): boolean {
-        return this._enableTurntableControls;
-    }
-
-    public set enableTurntableControls(value: boolean) {
-        this._enableTurntableControls = value;
-    }
-
-    public get enableZoom(): boolean {
-        return this._enableZoom;
-    }
-
-    public set enableZoom(value: boolean) {
-        this._enableZoom = value;
-    }
-
-    public get input(): { keys: { up: number, down: number, left: number, right: number }, mouse: { rotate: number, zoom: number, pan: number }, touch: { rotate: number, zoom: number, pan: number } } {
-        return this._input;
-    }
-
-    public set input(value: { keys: { up: number, down: number, left: number, right: number }, mouse: { rotate: number, zoom: number, pan: number }, touch: { rotate: number, zoom: number, pan: number } }) {
-        this._input = value;
-    }
-
-    public get keyPanSpeed(): number {
-        return this._keyPanSpeed;
-    }
-
-    public set keyPanSpeed(value: number) {
-        this._keyPanSpeed = value;
-    }
-
-    public get movementSmoothness(): number {
-        return this._movementSmoothness;
-    }
-
-    public set movementSmoothness(value: number) {
-        this._movementSmoothness = value;
-    }
-
-    public get panSpeed(): number {
-        return this._panSpeed;
-    }
-
-    public set panSpeed(value: number) {
-        this._panSpeed = value;
-    }
-
-    public get rotationRestriction(): { minPolarAngle: number, maxPolarAngle: number, minAzimuthAngle: number, maxAzimuthAngle: number } {
-        return this._rotationRestriction;
-    }
-
-    public set rotationRestriction(value: { minPolarAngle: number, maxPolarAngle: number, minAzimuthAngle: number, maxAzimuthAngle: number }) {
-        this._rotationRestriction = value;
-    }
-
-    public get rotationSpeed(): number {
-        return this._rotationSpeed;
-    }
-
-    public set rotationSpeed(value: number) {
-        this._rotationSpeed = value;
-    }
-
-    public get spherePositionRestriction(): { center: vec3, radius: number } {
-        return this._spherePositionRestriction;
-    }
-
-    public set spherePositionRestriction(value: { center: vec3, radius: number }) {
-        this._spherePositionRestriction = value;
-    }
-
-    public get sphereTargetRestriction(): { center: vec3, radius: number } {
-        return this._sphereTargetRestriction;
-    }
-
-    public set sphereTargetRestriction(value: { center: vec3, radius: number }) {
-        this._sphereTargetRestriction = value;
-    }
-
-    public get turntableCenter(): vec3 {
-        return this._turntableCenter;
-    }
-
-    public set turntableCenter(value: vec3) {
-        this._turntableCenter = value;
-    }
-
-    public get zoomRestriction(): { minDistance: number, maxDistance: number } {
-        return this._zoomRestriction;
-    }
-
-    public set zoomRestriction(value: { minDistance: number, maxDistance: number }) {
-        this._zoomRestriction = value;
-    }
-
-    public get zoomSpeed(): number {
-        return this._zoomSpeed;
-    }
-
-    public set zoomSpeed(value: number) {
-        this._zoomSpeed = value;
-    }
-
-    // #endregion Public Accessors (46)
-
-    // #region Public Methods (1)
-
-    public applySettings(settingsEngine: SettingsEngine) {
-        const cameraSetting = settingsEngine.camera.cameras[this.camera.id];
-        if (!cameraSetting) return;
-        this.reset();
-        const controlsSettings = <IOrbitControlsSettingsV3>cameraSetting.controls;
-        this.autoRotationSpeed = controlsSettings.autoRotationSpeed;
-        this.damping = controlsSettings.damping;
-        this.enableAutoRotation = controlsSettings.enableAutoRotation;
-        this.enableKeyPan = controlsSettings.enableKeyPan;
-        this.enablePan = controlsSettings.enablePan;
-        this.enableRotation = controlsSettings.enableRotation;
-        this.enableZoom = controlsSettings.enableZoom;
-        // this.input = controlsSettings.input;
-        this.keyPanSpeed = controlsSettings.keyPanSpeed;
-        this.movementSmoothness = controlsSettings.movementSmoothness;
-        this.rotationSpeed = controlsSettings.rotationSpeed;
-        this.panSpeed = controlsSettings.panSpeed;
-        this.zoomSpeed = controlsSettings.zoomSpeed;
-
-        if (controlsSettings.restrictions.position.cube.min.x === null) controlsSettings.restrictions.position.cube.min.x = -Infinity;
-        if (controlsSettings.restrictions.position.cube.min.y === null) controlsSettings.restrictions.position.cube.min.y = -Infinity;
-        if (controlsSettings.restrictions.position.cube.min.z === null) controlsSettings.restrictions.position.cube.min.z = -Infinity;
-        if (controlsSettings.restrictions.position.cube.max.x === null) controlsSettings.restrictions.position.cube.max.x = Infinity;
-        if (controlsSettings.restrictions.position.cube.max.y === null) controlsSettings.restrictions.position.cube.max.y = Infinity;
-        if (controlsSettings.restrictions.position.cube.max.z === null) controlsSettings.restrictions.position.cube.max.z = Infinity;
-        if (controlsSettings.restrictions.position.sphere.radius === null) controlsSettings.restrictions.position.sphere.radius = Infinity;
-        if (controlsSettings.restrictions.target.cube.min.x === null) controlsSettings.restrictions.target.cube.min.x = -Infinity;
-        if (controlsSettings.restrictions.target.cube.min.y === null) controlsSettings.restrictions.target.cube.min.y = -Infinity;
-        if (controlsSettings.restrictions.target.cube.min.z === null) controlsSettings.restrictions.target.cube.min.z = -Infinity;
-        if (controlsSettings.restrictions.target.cube.max.x === null) controlsSettings.restrictions.target.cube.max.x = Infinity;
-        if (controlsSettings.restrictions.target.cube.max.y === null) controlsSettings.restrictions.target.cube.max.y = Infinity;
-        if (controlsSettings.restrictions.target.cube.max.z === null) controlsSettings.restrictions.target.cube.max.z = Infinity;
-        if (controlsSettings.restrictions.target.sphere.radius === null) controlsSettings.restrictions.target.sphere.radius = Infinity;
-        if (controlsSettings.restrictions.rotation.minAzimuthAngle === null) controlsSettings.restrictions.rotation.minAzimuthAngle = -Infinity;
-        if (controlsSettings.restrictions.rotation.maxAzimuthAngle === null) controlsSettings.restrictions.rotation.maxAzimuthAngle = Infinity;
-        if (controlsSettings.restrictions.zoom.maxDistance === null) controlsSettings.restrictions.zoom.maxDistance = Infinity;
-
-        this.cubePositionRestriction = {
-            min: this._converter.toVec3(controlsSettings.restrictions.position.cube.min),
-            max: this._converter.toVec3(controlsSettings.restrictions.position.cube.max)
-        };
-        this.spherePositionRestriction = {
-            center: this._converter.toVec3(controlsSettings.restrictions.position.sphere.center),
-            radius: controlsSettings.restrictions.position.sphere.radius
-        };
-        this.cubeTargetRestriction = {
-            min: this._converter.toVec3(controlsSettings.restrictions.target.cube.min),
-            max: this._converter.toVec3(controlsSettings.restrictions.target.cube.max)
-        };
-        this.sphereTargetRestriction = {
-            center: this._converter.toVec3(controlsSettings.restrictions.target.sphere.center),
-            radius: controlsSettings.restrictions.target.sphere.radius
-        };
-        this.rotationRestriction = controlsSettings.restrictions.rotation;
-        this.zoomRestriction = controlsSettings.restrictions.zoom;
-    }
-
-    // #endregion Public Methods (1)
 }

package/src/implementation/interpolation/CameraInterpolationManager.ts

@@ -1,38 +1,36 @@
-import * as TWEEN from '@tweenjs/tween.js'
-import { vec3 } from 'gl-matrix'
-
-import { CameraMultipleInterpolation } from './interpolationMethods/CameraMultipleInterpolation'
-import { CameraSphericalInterpolation } from './interpolationMethods/CameraSphericalInterpolation'
-import { ICameraControlsUsage } from '../../interfaces/controls/ICameraControlsUsage'
-import { ICamera, ICameraOptions } from '../../interfaces/camera/ICamera'
-import { CameraLinearInterpolation } from './interpolationMethods/CameraLinearInterpolation'
-import { CameraCylindricalInterpolation } from './interpolationMethods/CameraCylindricalInterpolation'
-import { ICameraInterpolation } from '../../interfaces/interpolation/ICameraInterpolation'
+import * as TWEEN from '@tweenjs/tween.js';
+import { CameraCylindricalInterpolation } from './interpolationMethods/CameraCylindricalInterpolation';
+import { CameraLinearInterpolation } from './interpolationMethods/CameraLinearInterpolation';
+import { CameraMultipleInterpolation } from './interpolationMethods/CameraMultipleInterpolation';
+import { CameraSphericalInterpolation } from './interpolationMethods/CameraSphericalInterpolation';
+import { ICamera, ICameraOptions } from '../../interfaces/camera/ICamera';
+import { ICameraControls } from '../../interfaces/controls/ICameraControls';
+import { ICameraInterpolation } from '../../interfaces/interpolation/ICameraInterpolation';
+import { vec3 } from 'gl-matrix';
 
 export class CameraInterpolationManager {
-    // #region Properties (3)
-
+    // #region Properties (2)
 
     private TweenWrapper = class {
         private _properties: { delta: 0 } = { delta: 0 };
-        private _tween!: TWEEN.Tween<{  delta: number }>;
-        private _resolve!: Function;
+        private _tween!: TWEEN.Tween<{ delta: number }>;
+        private _resolve!: (value: boolean | PromiseLike<boolean>) => void;
 
-        constructor(options: {duration: number, easing: (amount: number) => number, coordinates: string, interpolation: Function }, cb: ICameraInterpolation, onComplete: Function) {
+        constructor(options: { duration: number, easing: (amount: number) => number, coordinates: string, interpolation: (v: number[], k: number) => number }, cb: ICameraInterpolation, onComplete: () => void) {
             this._tween = new TWEEN.Tween(this._properties);
-            this._tween.easing(options.easing);            
+            this._tween.easing(options.easing);
             this._tween.to({ delta: 1.0 }, options.duration);
 
             this._tween.onUpdate((v) => {
                 cb.onUpdate(v);
             });
-            
+
             this._tween.onStop((v) => {
-                if(cb.onStop) cb.onStop(v);
+                if (cb.onStop) cb.onStop(v);
                 this._resolve(true);
             });
             this._tween.onComplete((v) => {
-                if(cb.onComplete) cb.onComplete(v);
+                if (cb.onComplete) cb.onComplete(v);
                 onComplete();
                 this._resolve(true);
             });
@@ -51,14 +49,14 @@ export class CameraInterpolationManager {
     };
     private _tween: any;
 
-    // #endregion Properties (3)
+    // #endregion Properties (2)
 
     // #region Constructors (1)
 
     constructor(
         private readonly _camera: ICamera,
-        private readonly _cameraControls: ICameraControlsUsage
-        ) {
+        private readonly _cameraControls: ICameraControls
+    ) {
     }
 
     // #endregion Constructors (1)
@@ -68,38 +66,36 @@ export class CameraInterpolationManager {
     public active(): boolean {
         return this._tween ? true : false;
     }
+
     /**
      * cameraTween
      */
-    public interpolate(path: { position: vec3, target: vec3 }[], options: ICameraOptions = {}) : Promise<boolean> 
-    {
-
+    public interpolate(path: { position: vec3, target: vec3 }[], options: ICameraOptions = {}): Promise<boolean> {
         const newPath: { position: vec3, target: vec3 }[] = [];
-        for(let i = 0; i < path.length; i++)
+        for (let i = 0; i < path.length; i++)
             newPath.push({
                 position: path[i].position,
                 target: path[i].target,
             });
-                
 
-        if(this._tween) {
+        if (this._tween) {
             this._tween.stop();
             this._tween = null;
         }
-        let parsedOptions = this.optionsParser(options);
-        
+        const parsedOptions = this.optionsParser(options);
+
         this._tween = new this.TweenWrapper(
-            parsedOptions, 
-            newPath.length === 2 ? 
+            parsedOptions,
+            newPath.length === 2 ?
                 this.getCameraInterpolation(newPath[0], newPath[1], parsedOptions.coordinates) :
-                new CameraMultipleInterpolation(this._camera, this._cameraControls, newPath, parsedOptions.interpolation), 
+                new CameraMultipleInterpolation(this._camera, this._cameraControls, newPath, parsedOptions.interpolation),
             () => { this._tween = null; }
         );
         return this._tween.start();
     }
 
     public stop(): void {
-        if(this._tween) this._tween.stop();
+        if (this._tween) this._tween.stop();
         this._tween = null;
     }
 
@@ -108,7 +104,7 @@ export class CameraInterpolationManager {
     // #region Private Methods (2)
 
     private getCameraInterpolation(from: { position: vec3, target: vec3 }, to: { position: vec3, target: vec3 }, type: string) {
-        switch(type) {
+        switch (type) {
             case 'linear':
                 return new CameraLinearInterpolation(this._camera, this._cameraControls, from, to);
             case 'spherical':
@@ -120,32 +116,31 @@ export class CameraInterpolationManager {
         }
     }
 
-    private optionsParser(options: ICameraOptions): {duration: number, easing: (amount: number) => number, coordinates: string, interpolation: (v: number[], k: number) => number }
-    {
+    private optionsParser(options: ICameraOptions): { duration: number, easing: (amount: number) => number, coordinates: string, interpolation: (v: number[], k: number) => number } {
         let easing = TWEEN.Easing.Quartic.InOut;
-        if(typeof options.easing === 'string') {
+        if (typeof options.easing === 'string') {
             const keys = options.easing.split('.');
             const easingFamily = TWEEN.Easing[<keyof typeof TWEEN.Easing>keys[0]];
-            if(easingFamily) {
+            if (easingFamily) {
                 const easingFunction = easingFamily[<keyof typeof easingFamily>keys[1]];
-                if(easingFunction) easing = easingFunction;
+                if (easingFunction) easing = easingFunction;
             }
-        } else if(typeof options.easing === 'function') {
+        } else if (typeof options.easing === 'function') {
             easing = <(amount: number) => number>options.easing;
         }
 
         let interpolation = TWEEN.Interpolation.CatmullRom;
-        if(typeof options.interpolation === 'string') {
+        if (typeof options.interpolation === 'string') {
             const interpolationFunction = TWEEN.Interpolation[<keyof typeof TWEEN.Interpolation>options.interpolation];
-            if(interpolationFunction && interpolationFunction !== TWEEN.Interpolation.Utils) interpolation = <(v: number[], k: number) => number>interpolationFunction;
-        } else if(typeof options.interpolation === 'function') {
+            if (interpolationFunction && interpolationFunction !== TWEEN.Interpolation.Utils) interpolation = <(v: number[], k: number) => number>interpolationFunction;
+        } else if (typeof options.interpolation === 'function') {
             interpolation = <(v: number[], k: number) => number>options.interpolation;
         }
 
         return {
             duration: options.duration && options.duration >= 0 ? options.duration : 0,
             easing,
-            coordinates: options.coordinates !== 'spherical' && options.coordinates !== 'linear' && options.coordinates !== 'cylindrical' ? 'cylindrical' : options.coordinates, 
+            coordinates: options.coordinates !== 'spherical' && options.coordinates !== 'linear' && options.coordinates !== 'cylindrical' ? 'cylindrical' : options.coordinates,
             interpolation
         };
     }