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

package/src/implementation/interpolation/interpolationMethods/CameraCylindricalInterpolation.ts

@@ -1,8 +1,7 @@
-import { mat4, quat, vec3 } from 'gl-matrix'
-
-import { ICamera } from '../../../interfaces/camera/ICamera'
-import { ICameraControlsUsage } from '../../../interfaces/controls/ICameraControlsUsage'
-import { ICameraInterpolation } from '../../../interfaces/interpolation/ICameraInterpolation'
+import { ICamera } from '../../../interfaces/camera/ICamera';
+import { ICameraControls } from '../../../interfaces/controls/ICameraControls';
+import { ICameraInterpolation } from '../../../interfaces/interpolation/ICameraInterpolation';
+import { quat, vec3 } from 'gl-matrix';
 
 export class CameraCylindricalInterpolation implements ICameraInterpolation {
     // #region Properties (10)
@@ -24,10 +23,9 @@ export class CameraCylindricalInterpolation implements ICameraInterpolation {
 
     constructor(
         private readonly _camera: ICamera,
-        private readonly _cameraControls: ICameraControlsUsage,
+        private readonly _cameraControls: ICameraControls,
         private readonly _from: { position: vec3, target: vec3 },
-        private readonly _to: { position: vec3, target: vec3 }) 
-    {
+        private readonly _to: { position: vec3, target: vec3 }) {
         this._h_from = this._from.position[2] - this._from.target[2];
         this._from_position_heightAdjusted = vec3.fromValues(this._from.position[0], this._from.position[1], this._from.target[2]);
         this._r_from = vec3.distance(this._from_position_heightAdjusted, this._from.target);
@@ -39,15 +37,15 @@ export class CameraCylindricalInterpolation implements ICameraInterpolation {
         this._dir_to = vec3.normalize(vec3.create(), vec3.subtract(vec3.create(), this._to_position_heightAdjusted, this._to.target));
 
         if (this._dir_from[0] === 0 && this._dir_from[1] === 0 && this._dir_from[2] === 0)
-            this._dir_from = vec3.fromValues(1,0,0);
+            this._dir_from = vec3.fromValues(1, 0, 0);
 
         if (this._dir_to[0] === 0 && this._dir_to[1] === 0 && this._dir_to[2] === 0)
-            this._dir_to = vec3.fromValues(1,0,0);
+            this._dir_to = vec3.fromValues(1, 0, 0);
 
         this._lorr = vec3.cross(vec3.create(), this._dir_to, this._dir_from);
         // This is why people hate JavaScript. The dot product of two normalized vector is larger than 1 on occasion due to precision errors...
-        let dot1 = Math.min(1, Math.max(-1, vec3.dot(this._dir_to, this._dir_from))); 
-        let dot2 = Math.min(1, Math.max(-1, vec3.dot(this._lorr, vec3.fromValues(0, 0, 1)))); 
+        const dot1 = Math.min(1, Math.max(-1, vec3.dot(this._dir_to, this._dir_from)));
+        const dot2 = Math.min(1, Math.max(-1, vec3.dot(this._lorr, vec3.fromValues(0, 0, 1))));
         this._shortest_angle = dot2 > 0 ? -Math.acos(dot1) : Math.acos(dot1);
     }
 
@@ -56,9 +54,9 @@ export class CameraCylindricalInterpolation implements ICameraInterpolation {
     // #region Public Methods (3)
 
     public onComplete(value: { delta: number }): void {
-        let positionOffset = vec3.subtract(vec3.create(), vec3.fromValues(this._to.position[0], this._to.position[1], this._to.position[2]), this._cameraControls.getPositionWithUpdates());
+        const positionOffset = vec3.subtract(vec3.create(), vec3.fromValues(this._to.position[0], this._to.position[1], this._to.position[2]), this._cameraControls.getPositionWithUpdates());
         this._cameraControls.applyPositionVector(positionOffset);
-        let targetOffset = vec3.subtract(vec3.create(), vec3.fromValues(this._to.target[0], this._to.target[1], this._to.target[2]), this._cameraControls.getTargetWithUpdates());
+        const targetOffset = vec3.subtract(vec3.create(), vec3.fromValues(this._to.target[0], this._to.target[1], this._to.target[2]), this._cameraControls.getTargetWithUpdates());
         this._cameraControls.applyTargetVector(targetOffset);
     }
 
@@ -66,19 +64,18 @@ export class CameraCylindricalInterpolation implements ICameraInterpolation {
     }
 
     public onUpdate(value: { delta: number }): void {
-        let t = vec3.add(vec3.create(), vec3.multiply(vec3.create(), this._from.target, vec3.fromValues(1 - value.delta, 1 - value.delta, 1 - value.delta)), vec3.multiply(vec3.create(), this._to.target, vec3.fromValues(value.delta, value.delta, value.delta)));
-        let targetOffset = vec3.subtract(vec3.create(), t, this._cameraControls.getTargetWithUpdates());
+        const t = vec3.add(vec3.create(), vec3.multiply(vec3.create(), this._from.target, vec3.fromValues(1 - value.delta, 1 - value.delta, 1 - value.delta)), vec3.multiply(vec3.create(), this._to.target, vec3.fromValues(value.delta, value.delta, value.delta)));
+        const targetOffset = vec3.subtract(vec3.create(), t, this._cameraControls.getTargetWithUpdates());
         this._cameraControls.applyTargetVector(targetOffset);
 
-        let angle = this._shortest_angle * value.delta;
-        let dir = vec3.transformQuat(vec3.create(), this._dir_from, quat.setAxisAngle(quat.create(), vec3.fromValues(0, 0, 1), angle));
-        
+        const angle = this._shortest_angle * value.delta;
+        const dir = vec3.transformQuat(vec3.create(), this._dir_from, quat.setAxisAngle(quat.create(), vec3.fromValues(0, 0, 1), angle));
 
-        let scalar = this._r_from * (1 - value.delta) + this._r_to * value.delta;
-        let p = vec3.add(vec3.create(), t, vec3.multiply(vec3.create(), dir, vec3.fromValues(scalar, scalar, scalar)));
+        const scalar = this._r_from * (1 - value.delta) + this._r_to * value.delta;
+        const p = vec3.add(vec3.create(), t, vec3.multiply(vec3.create(), dir, vec3.fromValues(scalar, scalar, scalar)));
         vec3.add(p, p, vec3.fromValues(0, 0, (this._h_from * (1 - value.delta) + this._h_to * value.delta)));
 
-        let positionOffset = vec3.subtract(vec3.create(), p, this._cameraControls.getPositionWithUpdates());
+        const positionOffset = vec3.subtract(vec3.create(), p, this._cameraControls.getPositionWithUpdates());
         this._cameraControls.applyPositionVector(positionOffset);
     }
 

package/src/implementation/interpolation/interpolationMethods/CameraLinearInterpolation.ts

@@ -1,27 +1,26 @@
-import { mat4, vec3 } from 'gl-matrix'
-
-import { ICamera } from '../../../interfaces/camera/ICamera'
-import { ICameraControlsUsage } from '../../../interfaces/controls/ICameraControlsUsage'
-import { ICameraInterpolation } from '../../../interfaces/interpolation/ICameraInterpolation'
+import { ICamera } from '../../../interfaces/camera/ICamera';
+import { ICameraControls } from '../../../interfaces/controls/ICameraControls';
+import { ICameraInterpolation } from '../../../interfaces/interpolation/ICameraInterpolation';
+import { vec3 } from 'gl-matrix';
 
 export class CameraLinearInterpolation implements ICameraInterpolation {
     // #region Constructors (1)
 
     constructor(
-        private readonly _camera: ICamera, 
-        private readonly _cameraControls: ICameraControlsUsage, 
-        private readonly _from: { position: vec3, target: vec3 }, 
-        private readonly _to: { position: vec3, target: vec3 }) 
-    {
+        private readonly _camera: ICamera,
+        private readonly _cameraControls: ICameraControls,
+        private readonly _from: { position: vec3, target: vec3 },
+        private readonly _to: { position: vec3, target: vec3 }) {
     }
+
     // #endregion Constructors (1)
 
     // #region Public Methods (3)
 
     public onComplete(value: { delta: number }): void {
-        let positionOffset = vec3.subtract(vec3.create(), this._to.position, this._cameraControls.getPositionWithUpdates());
+        const positionOffset = vec3.subtract(vec3.create(), this._to.position, this._cameraControls.getPositionWithUpdates());
         this._cameraControls.applyPositionVector(positionOffset);
-        let targetOffset = vec3.subtract(vec3.create(), this._to.target, this._cameraControls.getTargetWithUpdates());
+        const targetOffset = vec3.subtract(vec3.create(), this._to.target, this._cameraControls.getTargetWithUpdates());
         this._cameraControls.applyTargetVector(targetOffset);
     }
 
@@ -29,12 +28,12 @@ export class CameraLinearInterpolation implements ICameraInterpolation {
     }
 
     public onUpdate(value: { delta: number }): void {
-        let p = vec3.add(vec3.create(), vec3.multiply(vec3.create(), this._from.position, vec3.fromValues(1 - value.delta, 1 - value.delta, 1 - value.delta)), vec3.multiply(vec3.create(), this._to.position, vec3.fromValues(value.delta, value.delta, value.delta)));
-        let positionOffset = vec3.subtract(vec3.create(), p, this._cameraControls.getPositionWithUpdates());
+        const p = vec3.add(vec3.create(), vec3.multiply(vec3.create(), this._from.position, vec3.fromValues(1 - value.delta, 1 - value.delta, 1 - value.delta)), vec3.multiply(vec3.create(), this._to.position, vec3.fromValues(value.delta, value.delta, value.delta)));
+        const positionOffset = vec3.subtract(vec3.create(), p, this._cameraControls.getPositionWithUpdates());
         this._cameraControls.applyPositionVector(positionOffset);
 
-        let t = vec3.add(vec3.create(), vec3.multiply(vec3.create(), this._from.target, vec3.fromValues(1 - value.delta, 1 - value.delta, 1 - value.delta)), vec3.multiply(vec3.create(), this._to.target, vec3.fromValues(value.delta, value.delta, value.delta)));
-        let targetOffset = vec3.subtract(vec3.create(), t, this._cameraControls.getTargetWithUpdates());
+        const t = vec3.add(vec3.create(), vec3.multiply(vec3.create(), this._from.target, vec3.fromValues(1 - value.delta, 1 - value.delta, 1 - value.delta)), vec3.multiply(vec3.create(), this._to.target, vec3.fromValues(value.delta, value.delta, value.delta)));
+        const targetOffset = vec3.subtract(vec3.create(), t, this._cameraControls.getTargetWithUpdates());
         this._cameraControls.applyTargetVector(targetOffset);
     }
 

package/src/implementation/interpolation/interpolationMethods/CameraMultipleInterpolation.ts

@@ -1,8 +1,7 @@
-import { mat4, vec3 } from 'gl-matrix'
-
-import { ICamera } from '../../../interfaces/camera/ICamera'
-import { ICameraControlsUsage } from '../../../interfaces/controls/ICameraControlsUsage'
-import { ICameraInterpolation } from '../../../interfaces/interpolation/ICameraInterpolation'
+import { ICamera } from '../../../interfaces/camera/ICamera';
+import { ICameraControls } from '../../../interfaces/controls/ICameraControls';
+import { ICameraInterpolation } from '../../../interfaces/interpolation/ICameraInterpolation';
+import { vec3 } from 'gl-matrix';
 
 export class CameraMultipleInterpolation implements ICameraInterpolation {
     // #region Properties (1)
@@ -11,21 +10,20 @@ export class CameraMultipleInterpolation implements ICameraInterpolation {
         position: { x: number[], y: number[], z: number[] },
         target: { x: number[], y: number[], z: number[] }
     } = {
-        position: { x: [], y: [], z: [] },
-        target: { x: [], y: [], z: [] }
-    };
+            position: { x: [], y: [], z: [] },
+            target: { x: [], y: [], z: [] }
+        };
 
     // #endregion Properties (1)
 
     // #region Constructors (1)
 
     constructor(
-        private readonly _camera: ICamera, 
-        private readonly _cameraControls: ICameraControlsUsage, 
+        private readonly _camera: ICamera,
+        private readonly _cameraControls: ICameraControls,
         private readonly _path: { position: vec3, target: vec3 }[],
-        private readonly _interpolationFunction: Function)
-    {
-        for(let i = 0; i < this._path.length; i++) {
+        private readonly _interpolationFunction: (v: number[], k: number) => number) {
+        for (let i = 0; i < this._path.length; i++) {
             this.end.position.x.push(this._path[i].position[0]);
             this.end.position.y.push(this._path[i].position[1]);
             this.end.position.z.push(this._path[i].position[2]);
@@ -40,9 +38,9 @@ export class CameraMultipleInterpolation implements ICameraInterpolation {
     // #region Public Methods (3)
 
     public onComplete(value: { delta: number }): void {
-        let positionOffset = vec3.subtract(vec3.create(), vec3.fromValues(this._path[this._path.length-1].position[0], this._path[this._path.length-1].position[1], this._path[this._path.length-1].position[2]), this._cameraControls.getPositionWithUpdates());
+        const positionOffset = vec3.subtract(vec3.create(), vec3.fromValues(this._path[this._path.length - 1].position[0], this._path[this._path.length - 1].position[1], this._path[this._path.length - 1].position[2]), this._cameraControls.getPositionWithUpdates());
         this._cameraControls.applyPositionVector(positionOffset);
-        let targetOffset = vec3.subtract(vec3.create(), vec3.fromValues(this._path[this._path.length-1].target[0], this._path[this._path.length-1].target[1], this._path[this._path.length-1].target[2]), this._cameraControls.getTargetWithUpdates());
+        const targetOffset = vec3.subtract(vec3.create(), vec3.fromValues(this._path[this._path.length - 1].target[0], this._path[this._path.length - 1].target[1], this._path[this._path.length - 1].target[2]), this._cameraControls.getTargetWithUpdates());
         this._cameraControls.applyTargetVector(targetOffset);
     }
 
@@ -50,12 +48,12 @@ export class CameraMultipleInterpolation implements ICameraInterpolation {
     }
 
     public onUpdate(value: { delta: number }): void {
-        let p: vec3 = vec3.fromValues(this._interpolationFunction(this.end.position.x, value.delta), this._interpolationFunction(this.end.position.y, value.delta), this._interpolationFunction(this.end.position.z, value.delta));
-        let positionOffset = vec3.subtract(vec3.create(), p, this._cameraControls.getPositionWithUpdates());
+        const p: vec3 = vec3.fromValues(this._interpolationFunction(this.end.position.x, value.delta), this._interpolationFunction(this.end.position.y, value.delta), this._interpolationFunction(this.end.position.z, value.delta));
+        const positionOffset = vec3.subtract(vec3.create(), p, this._cameraControls.getPositionWithUpdates());
         this._cameraControls.applyPositionVector(positionOffset);
 
-        let t: vec3 = vec3.fromValues(this._interpolationFunction(this.end.target.x, value.delta), this._interpolationFunction(this.end.target.y, value.delta), this._interpolationFunction(this.end.target.z, value.delta));
-        let targetOffset = vec3.subtract(vec3.create(), t, this._cameraControls.getTargetWithUpdates());
+        const t: vec3 = vec3.fromValues(this._interpolationFunction(this.end.target.x, value.delta), this._interpolationFunction(this.end.target.y, value.delta), this._interpolationFunction(this.end.target.z, value.delta));
+        const targetOffset = vec3.subtract(vec3.create(), t, this._cameraControls.getTargetWithUpdates());
         this._cameraControls.applyTargetVector(targetOffset);
     }
 

package/src/implementation/interpolation/interpolationMethods/CameraOrthographicInterpolation.ts

@@ -1,18 +1,16 @@
-import { mat4, vec3 } from 'gl-matrix'
-
-import { ICamera } from '../../../interfaces/camera/ICamera'
-import { ICameraControlsUsage } from '../../../interfaces/controls/ICameraControlsUsage'
-import { ICameraInterpolation } from '../../../interfaces/interpolation/ICameraInterpolation'
+import { ICamera } from '../../../interfaces/camera/ICamera';
+import { ICameraControls } from '../../../interfaces/controls/ICameraControls';
+import { ICameraInterpolation } from '../../../interfaces/interpolation/ICameraInterpolation';
+import { vec3 } from 'gl-matrix';
 
 export class CameraOrthographicInterpolation implements ICameraInterpolation {
     // #region Constructors (1)
 
     constructor(
         private readonly _camera: ICamera,
-        private readonly _cameraControls: ICameraControlsUsage,
+        private readonly _cameraControls: ICameraControls,
         private readonly _from: { position: vec3, target: vec3 },
-        private readonly _to: { position: vec3, target: vec3 }) 
-    {
+        private readonly _to: { position: vec3, target: vec3 }) {
     }
 
     // #endregion Constructors (1)
@@ -20,9 +18,9 @@ export class CameraOrthographicInterpolation implements ICameraInterpolation {
     // #region Public Methods (3)
 
     public onComplete(value: { delta: number }): void {
-        let positionOffset = vec3.subtract(vec3.create(), vec3.fromValues(this._to.position[0], this._to.position[1], this._to.position[2]), this._cameraControls.getPositionWithUpdates());
+        const positionOffset = vec3.subtract(vec3.create(), vec3.fromValues(this._to.position[0], this._to.position[1], this._to.position[2]), this._cameraControls.getPositionWithUpdates());
         this._cameraControls.applyPositionVector(positionOffset);
-        let targetOffset = vec3.subtract(vec3.create(), vec3.fromValues(this._to.target[0], this._to.target[1], this._to.target[2]), this._cameraControls.getTargetWithUpdates());
+        const targetOffset = vec3.subtract(vec3.create(), vec3.fromValues(this._to.target[0], this._to.target[1], this._to.target[2]), this._cameraControls.getTargetWithUpdates());
         this._cameraControls.applyTargetVector(targetOffset);
     }
 
@@ -30,12 +28,12 @@ export class CameraOrthographicInterpolation implements ICameraInterpolation {
     }
 
     public onUpdate(value: { delta: number }): void {
-        let t: vec3 = vec3.add(vec3.create(), vec3.multiply(vec3.create(), this._from.target, vec3.fromValues(1 - value.delta, 1 - value.delta, 1 - value.delta)), vec3.multiply(vec3.create(), this._to.target, vec3.fromValues(value.delta, value.delta, value.delta)));
-        let targetOffset = vec3.subtract(vec3.create(), t, this._cameraControls.getTargetWithUpdates());
+        const t: vec3 = vec3.add(vec3.create(), vec3.multiply(vec3.create(), this._from.target, vec3.fromValues(1 - value.delta, 1 - value.delta, 1 - value.delta)), vec3.multiply(vec3.create(), this._to.target, vec3.fromValues(value.delta, value.delta, value.delta)));
+        const targetOffset = vec3.subtract(vec3.create(), t, this._cameraControls.getTargetWithUpdates());
         this._cameraControls.applyTargetVector(targetOffset);
 
-        let p: vec3 = vec3.add(vec3.create(), vec3.multiply(vec3.create(), this._from.position, vec3.fromValues(1 - value.delta, 1 - value.delta, 1 - value.delta)), vec3.multiply(vec3.create(), this._to.position, vec3.fromValues(value.delta, value.delta, value.delta)));
-        let positionOffset = vec3.subtract(vec3.create(), p, this._cameraControls.getPositionWithUpdates());
+        const p: vec3 = vec3.add(vec3.create(), vec3.multiply(vec3.create(), this._from.position, vec3.fromValues(1 - value.delta, 1 - value.delta, 1 - value.delta)), vec3.multiply(vec3.create(), this._to.position, vec3.fromValues(value.delta, value.delta, value.delta)));
+        const positionOffset = vec3.subtract(vec3.create(), p, this._cameraControls.getPositionWithUpdates());
         this._cameraControls.applyPositionVector(positionOffset);
     }
 

package/src/implementation/interpolation/interpolationMethods/CameraSphericalInterpolation.ts

@@ -1,8 +1,7 @@
-import { mat4, quat, vec3 } from 'gl-matrix'
-
-import { ICamera } from '../../../interfaces/camera/ICamera'
-import { ICameraControlsUsage } from '../../../interfaces/controls/ICameraControlsUsage'
-import { ICameraInterpolation } from '../../../interfaces/interpolation/ICameraInterpolation'
+import { ICamera } from '../../../interfaces/camera/ICamera';
+import { ICameraControls } from '../../../interfaces/controls/ICameraControls';
+import { ICameraInterpolation } from '../../../interfaces/interpolation/ICameraInterpolation';
+import { quat, vec3 } from 'gl-matrix';
 
 export class CameraSphericalInterpolation implements ICameraInterpolation {
     // #region Properties (6)
@@ -20,13 +19,12 @@ export class CameraSphericalInterpolation implements ICameraInterpolation {
 
     constructor(
         private readonly _camera: ICamera,
-        private readonly _cameraControls: ICameraControlsUsage,
+        private readonly _cameraControls: ICameraControls,
         private readonly _from: { position: vec3, target: vec3 },
-        private readonly _to: { position: vec3, target: vec3 })
-    {
+        private readonly _to: { position: vec3, target: vec3 }) {
         this._radius_from = vec3.distance(this._from.position, this._from.target);
         this._direction_from = vec3.normalize(vec3.create(), vec3.subtract(vec3.create(), this._from.position, this._from.target));
-        
+
         this._radius_to = vec3.distance(this._to.position, this._to.target);
         this._direction_to = vec3.normalize(vec3.create(), vec3.subtract(vec3.create(), this._to.position, this._to.target));
 
@@ -35,14 +33,14 @@ export class CameraSphericalInterpolation implements ICameraInterpolation {
     }
 
     // #endregion Constructors (1)
-        
+
     // #region Public Methods (3)
 
     public onComplete(value: { delta: number }): void {
-        let positionOffset = vec3.subtract(vec3.create(), vec3.fromValues(this._to.position[0], this._to.position[1], this._to.position[2]), this._cameraControls.getPositionWithUpdates());
+        const positionOffset = vec3.subtract(vec3.create(), vec3.fromValues(this._to.position[0], this._to.position[1], this._to.position[2]), this._cameraControls.getPositionWithUpdates());
         this._cameraControls.applyPositionVector(positionOffset);
-        
-        let targetOffset = vec3.subtract(vec3.create(), vec3.fromValues(this._to.target[0], this._to.target[1], this._to.target[2]), this._cameraControls.getTargetWithUpdates());
+
+        const targetOffset = vec3.subtract(vec3.create(), vec3.fromValues(this._to.target[0], this._to.target[1], this._to.target[2]), this._cameraControls.getTargetWithUpdates());
         this._cameraControls.applyTargetVector(targetOffset);
     }
 
@@ -50,16 +48,16 @@ export class CameraSphericalInterpolation implements ICameraInterpolation {
     }
 
     public onUpdate(value: { delta: number }): void {
-        let t: vec3 = vec3.add(vec3.create(), vec3.multiply(vec3.create(), this._from.target, vec3.fromValues(1 - value.delta, 1 - value.delta, 1 - value.delta)), vec3.multiply(vec3.create(), this._to.target, vec3.fromValues(value.delta, value.delta, value.delta)));
-        let targetOffset = vec3.subtract(vec3.create(), t, this._cameraControls.getTargetWithUpdates());
+        const t: vec3 = vec3.add(vec3.create(), vec3.multiply(vec3.create(), this._from.target, vec3.fromValues(1 - value.delta, 1 - value.delta, 1 - value.delta)), vec3.multiply(vec3.create(), this._to.target, vec3.fromValues(value.delta, value.delta, value.delta)));
+        const targetOffset = vec3.subtract(vec3.create(), t, this._cameraControls.getTargetWithUpdates());
         this._cameraControls.applyTargetVector(targetOffset);
 
-        let angle = this._c_angle * value.delta;
-        let dir = vec3.normalize(vec3.create(), vec3.transformQuat(vec3.create(), this._direction_from, quat.setAxisAngle(quat.create(), this._axis, angle)));
+        const angle = this._c_angle * value.delta;
+        const dir = vec3.normalize(vec3.create(), vec3.transformQuat(vec3.create(), this._direction_from, quat.setAxisAngle(quat.create(), this._axis, angle)));
 
-        let scalar = (this._radius_from * (1 - value.delta) + this._radius_to * value.delta);
-        let p: vec3 = vec3.add(vec3.create(), t, vec3.multiply(vec3.create(), dir, vec3.fromValues(scalar, scalar, scalar)));
-        let positionOffset = vec3.subtract(vec3.create(), p, this._cameraControls.getPositionWithUpdates());
+        const scalar = (this._radius_from * (1 - value.delta) + this._radius_to * value.delta);
+        const p: vec3 = vec3.add(vec3.create(), t, vec3.multiply(vec3.create(), dir, vec3.fromValues(scalar, scalar, scalar)));
+        const positionOffset = vec3.subtract(vec3.create(), p, this._cameraControls.getPositionWithUpdates());
         this._cameraControls.applyPositionVector(positionOffset);
     }
 

package/src/index.ts

@@ -1,31 +1,28 @@
-import { ICameraControls } from './interfaces/controls/ICameraControls'
-import { AbstractCamera } from './implementation/camera/AbstractCamera'
-import { CameraEngine } from './implementation/CameraEngine'
-import { ICamera, ICameraOptions } from './interfaces/camera/ICamera'
-import { CAMERA_TYPE, ICameraEngine } from './interfaces/ICameraEngine'
-import { OrthographicCamera } from './implementation/camera/OrthographicCamera'
-import { PerspectiveCamera } from './implementation/camera/PerspectiveCamera'
-import { OrthographicCameraControls } from './implementation/controls/OrthographicCameraControls'
-import { PerspectiveCameraControls } from './implementation/controls/PerspectiveCameraControls'
-import { IPerspectiveCameraControls } from './interfaces/controls/IPerspectiveCameraControls'
-import { IOrthographicCameraControls } from './interfaces/controls/IOrthographicCameraControls'
-import { IOrthographicCamera, ORTHOGRAPHIC_CAMERA_DIRECTION } from './interfaces/camera/IOrthographicCamera'
-import { IPerspectiveCamera } from './interfaces/camera/IPerspectiveCamera'
+import { AbstractCamera } from './implementation/camera/AbstractCamera';
+import { CAMERA_TYPE, ICameraEngine } from './interfaces/ICameraEngine';
+import { CameraEngine } from './implementation/CameraEngine';
+import { ICamera, ICameraOptions } from './interfaces/camera/ICamera';
+import { ICameraControls } from './interfaces/controls/ICameraControls';
+import { IOrthographicCamera, ORTHOGRAPHIC_CAMERA_DIRECTION } from './interfaces/camera/IOrthographicCamera';
+import { IPerspectiveCamera } from './interfaces/camera/IPerspectiveCamera';
+import { OrthographicCamera } from './implementation/camera/OrthographicCamera';
+import { OrthographicCameraControls } from './implementation/controls/OrthographicCameraControls';
+import { PerspectiveCamera } from './implementation/camera/PerspectiveCamera';
+import { PerspectiveCameraControls } from './implementation/controls/PerspectiveCameraControls';
 
 export {
   ICameraEngine, ICamera, ICameraControls
-}
+};
 
 export {
   CameraEngine, AbstractCamera, CAMERA_TYPE, ORTHOGRAPHIC_CAMERA_DIRECTION, ICameraOptions
-}
+};
 
-export { 
+export {
   PerspectiveCamera, OrthographicCamera,
   IPerspectiveCamera, IOrthographicCamera
-}
+};
 
-export { 
-  PerspectiveCameraControls, OrthographicCameraControls,
-  IPerspectiveCameraControls, IOrthographicCameraControls
-}
+export {
+  PerspectiveCameraControls, OrthographicCameraControls
+};

package/src/interfaces/ICameraEngine.ts

@@ -1,20 +1,33 @@
-import { vec3 } from 'gl-matrix'
+import { ICamera } from './camera/ICamera';
 
-import { ICamera } from './camera/ICamera'
-
-export enum CAMERA_TYPE {
-    PERSPECTIVE = 'perspective',
-    ORTHOGRAPHIC = 'orthographic'
-}
+// #region Interfaces (1)
 
 export interface ICameraEngine {
+    // #region Properties (1)
+
     update?: () => void;
 
+    // #endregion Properties (1)
+
+    // #region Public Methods (6)
+
+    activateCameraEvents(): void;
     assignCamera(id: string): boolean;
     createCamera(type: CAMERA_TYPE, id?: string): ICamera;
+    createDefaultCameras(): void;
+    deactivateCameraEvents(): void;
     removeCamera(id: string): boolean;
 
-    activateCameraEvents(): void;
-    deactivateCameraEvents(): void;
-    createDefaultCameras(): void;
-}
+    // #endregion Public Methods (6)
+}
+
+// #endregion Interfaces (1)
+
+// #region Enums (1)
+
+export enum CAMERA_TYPE {
+    PERSPECTIVE = 'perspective',
+    ORTHOGRAPHIC = 'orthographic'
+}
+
+// #endregion Enums (1)

package/src/interfaces/camera/ICamera.ts

@@ -1,48 +1,14 @@
-/* eslint-disable @typescript-eslint/ban-types */
-import { vec2, vec3 } from 'gl-matrix';
-import { ITreeNode, ITreeNodeData } from '@shapediver/viewer.shared.node-tree';
-
-import { ICameraControls } from '../controls/ICameraControls';
 import { CAMERA_TYPE } from '../ICameraEngine';
 import { IBox } from '@shapediver/viewer.shared.math';
+import { ICameraControls } from '../controls/ICameraControls';
+import { ITreeNode, ITreeNodeData } from '@shapediver/viewer.shared.node-tree';
 import { SettingsEngine } from '@shapediver/viewer.shared.services';
+import { vec2, vec3 } from 'gl-matrix';
 
-export interface ICameraOptions {
-    // #region Properties (4)
-
-    /**
-     * The coordinate type of the camera interpolation. (default: 'cylindrical')
-     */
-    coordinates?: 'spherical' | 'linear' | 'cylindrical';
-    /**
-     * The duration of the camera movement. (default: cameraMovementDuration set in the settings)
-     * When set to 0, the camera is immediately updated to the specified position and target.
-     */
-    duration?: number;
-    /**
-     * The easing type of the camera interpolation. (default: 'Quadratic.InOut')
-     */
-    easing?: 'Linear.None' |
-    'Quadratic.In' | 'Quadratic.Out' | 'Quadratic.InOut' |
-    'Cubic.In' | 'Cubic.Out' | 'Cubic.InOut' |
-    'Quartic.In' | 'Quartic.Out' | 'Quartic.InOut' |
-    'Quintic.In' | 'Quintic.Out' | 'Quintic.InOut' |
-    'Sinusoidal.In' | 'Sinusoidal.Out' | 'Sinusoidal.InOut' |
-    'Exponential.In' | 'Exponential.Out' | 'Exponential.InOut' |
-    'Circular.In' | 'Circular.Out' | 'Circular.InOut' |
-    'Elastic.In' | 'Elastic.Out' | 'Elastic.InOut' |
-    'Back.In' | 'Back.Out' | 'Back.InOut' |
-    'Bounce.In' | 'Bounce.Out' | 'Bounce.InOut' | Function;
-    /**
-     * The interpolation type of the camera interpolation. (default: 'CatmullRom')
-     */
-    interpolation?: 'Linear' | 'Bezier' | 'CatmullRom' | Function
-
-    // #endregion Properties (4)
-}
+// #region Interfaces (2)
 
 export interface ICamera extends ITreeNodeData {
-    // #region Properties (20)
+    // #region Properties (21)
 
     readonly controls: ICameraControls;
     readonly id: string;
@@ -54,6 +20,7 @@ export interface ICamera extends ITreeNodeData {
     cameraMovementDuration: number;
     defaultPosition: vec3;
     defaultTarget: vec3;
+    domEventListenerToken?: string;
     enableCameraControls: boolean;
     name?: string;
     node?: ITreeNode;
@@ -66,7 +33,7 @@ export interface ICamera extends ITreeNodeData {
     useNodeData: boolean;
     zoomExtentsFactor: number;
 
-    // #endregion Properties (20)
+    // #endregion Properties (21)
 
     // #region Public Methods (8)
 
@@ -80,4 +47,41 @@ export interface ICamera extends ITreeNodeData {
     zoomTo(zoomTarget?: IBox, options?: ICameraOptions): Promise<boolean>;
 
     // #endregion Public Methods (8)
-}
+}
+
+/* eslint-disable @typescript-eslint/ban-types */
+export interface ICameraOptions {
+    // #region Properties (4)
+
+    /**
+     * The coordinate type of the camera interpolation. (default: 'cylindrical')
+     */
+    coordinates?: 'spherical' | 'linear' | 'cylindrical';
+    /**
+     * The duration of the camera movement. (default: cameraMovementDuration set in the settings)
+     * When set to 0, the camera is immediately updated to the specified position and target.
+     */
+    duration?: number;
+    /**
+     * The easing type of the camera interpolation. (default: 'Quadratic.InOut')
+     */
+    easing?: 'Linear.None' |
+    'Quadratic.In' | 'Quadratic.Out' | 'Quadratic.InOut' |
+    'Cubic.In' | 'Cubic.Out' | 'Cubic.InOut' |
+    'Quartic.In' | 'Quartic.Out' | 'Quartic.InOut' |
+    'Quintic.In' | 'Quintic.Out' | 'Quintic.InOut' |
+    'Sinusoidal.In' | 'Sinusoidal.Out' | 'Sinusoidal.InOut' |
+    'Exponential.In' | 'Exponential.Out' | 'Exponential.InOut' |
+    'Circular.In' | 'Circular.Out' | 'Circular.InOut' |
+    'Elastic.In' | 'Elastic.Out' | 'Elastic.InOut' |
+    'Back.In' | 'Back.Out' | 'Back.InOut' |
+    'Bounce.In' | 'Bounce.Out' | 'Bounce.InOut' | Function;
+    /**
+     * The interpolation type of the camera interpolation. (default: 'CatmullRom')
+     */
+    interpolation?: 'Linear' | 'Bezier' | 'CatmullRom' | Function
+
+    // #endregion Properties (4)
+}
+
+// #endregion Interfaces (2)

package/src/interfaces/camera/IOrthographicCamera.ts

@@ -1,5 +1,27 @@
-import { IOrthographicCameraControls } from '../controls/IOrthographicCameraControls';
-import { ICamera } from './ICamera'
+import { ICamera } from './ICamera';
+import { ICameraControls } from '../controls/ICameraControls';
+
+// #region Interfaces (1)
+
+export interface IOrthographicCamera extends ICamera {
+    // #region Properties (2)
+
+    readonly controls: ICameraControls;
+
+    direction: ORTHOGRAPHIC_CAMERA_DIRECTION;
+
+    // #endregion Properties (2)
+
+    // #region Public Methods (1)
+
+    clone(): IOrthographicCamera;
+
+    // #endregion Public Methods (1)
+}
+
+// #endregion Interfaces (1)
+
+// #region Enums (1)
 
 export enum ORTHOGRAPHIC_CAMERA_DIRECTION {
     TOP = 'top',
@@ -8,11 +30,7 @@ export enum ORTHOGRAPHIC_CAMERA_DIRECTION {
     RIGHT = 'right',
     FRONT = 'front',
     BACK = 'back',
- }
-export interface IOrthographicCamera extends ICamera {
-    readonly controls: IOrthographicCameraControls;
-    
-    direction: ORTHOGRAPHIC_CAMERA_DIRECTION;
+    CUSTOM = 'custom'
+}
 
-    clone(): IOrthographicCamera;
-}
+// #endregion Enums (1)

package/src/interfaces/camera/IPerspectiveCamera.ts

@@ -1,10 +1,18 @@
-import { IPerspectiveCameraControls } from '../controls/IPerspectiveCameraControls';
-import { ICamera } from './ICamera'
+import { ICamera } from './ICamera';
+import { ICameraControls } from '../controls/ICameraControls';
+
+export interface IPerspectiveCamera extends ICamera {
+    // #region Properties (2)
+
+    readonly controls: ICameraControls;
 
-export interface IPerspectiveCamera extends ICamera {  
-    readonly controls: IPerspectiveCameraControls;
-    
     fov: number;
 
+    // #endregion Properties (2)
+
+    // #region Public Methods (1)
+
     clone(): IPerspectiveCamera;
+
+    // #endregion Public Methods (1)
 }