@shapediver/viewer.rendering-engine.camera-engine 1.15.7 → 2.0.0

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

@@ -0,0 +1,86 @@
+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'
+
+export class CameraCylindricalInterpolation implements ICameraInterpolation {
+    // #region Properties (10)
+
+    private _dir_from: vec3;
+    private _dir_to: vec3;
+    private _from_position_heightAdjusted: vec3;
+    private _h_from: number;
+    private _h_to: number;
+    private _lorr: vec3;
+    private _r_from: number;
+    private _r_to: number;
+    private _shortest_angle: number;
+    private _to_position_heightAdjusted: vec3;
+
+    // #endregion Properties (10)
+
+    // #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 }) 
+    {
+        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);
+        this._dir_from = vec3.normalize(vec3.create(), vec3.subtract(vec3.create(), this._from_position_heightAdjusted, this._from.target));
+
+        this._h_to = this._to.position[2] - this._to.target[2];
+        this._to_position_heightAdjusted = vec3.fromValues(this._to.position[0], this._to.position[1], this._to.target[2]);
+        this._r_to = vec3.distance(this._to_position_heightAdjusted, this._to.target);
+        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);
+
+        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._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)))); 
+        this._shortest_angle = dot2 > 0 ? -Math.acos(dot1) : Math.acos(dot1);
+    }
+
+    // #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());
+        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());
+        this._cameraControls.applyTargetVector(targetOffset);
+    }
+
+    public onStop(value: { delta: number }): void {
+    }
+
+    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());
+        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));
+        
+
+        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)));
+        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());
+        this._cameraControls.applyPositionVector(positionOffset);
+    }
+
+    // #endregion Public Methods (3)
+}

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

@@ -0,0 +1,42 @@
+import { mat4, vec3 } from 'gl-matrix'
+
+import { ICamera } from '../../../interfaces/camera/ICamera'
+import { ICameraControlsUsage } from '../../../interfaces/controls/ICameraControlsUsage'
+import { ICameraInterpolation } from '../../../interfaces/interpolation/ICameraInterpolation'
+
+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 }) 
+    {
+    }
+    // #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());
+        this._cameraControls.applyPositionVector(positionOffset);
+        let targetOffset = vec3.subtract(vec3.create(), this._to.target, this._cameraControls.getTargetWithUpdates());
+        this._cameraControls.applyTargetVector(targetOffset);
+    }
+
+    public onStop(value: { delta: number }): void {
+    }
+
+    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());
+        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());
+        this._cameraControls.applyTargetVector(targetOffset);
+    }
+
+    // #endregion Public Methods (3)
+}

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

@@ -0,0 +1,63 @@
+import { mat4, vec3 } from 'gl-matrix'
+
+import { ICamera } from '../../../interfaces/camera/ICamera'
+import { ICameraControlsUsage } from '../../../interfaces/controls/ICameraControlsUsage'
+import { ICameraInterpolation } from '../../../interfaces/interpolation/ICameraInterpolation'
+
+export class CameraMultipleInterpolation implements ICameraInterpolation {
+    // #region Properties (1)
+
+    public end: {
+        position: { x: number[], y: number[], z: number[] },
+        target: { x: number[], y: number[], z: number[] }
+    } = {
+        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 _path: { position: vec3, target: vec3 }[],
+        private readonly _interpolationFunction: Function)
+    {
+        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]);
+            this.end.target.x.push(this._path[i].target[0]);
+            this.end.target.y.push(this._path[i].target[1]);
+            this.end.target.z.push(this._path[i].target[2]);
+        }
+    }
+
+    // #endregion Constructors (1)
+
+    // #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());
+        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());
+        this._cameraControls.applyTargetVector(targetOffset);
+    }
+
+    public onStop(value: { delta: number }): void {
+    }
+
+    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());
+        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());
+        this._cameraControls.applyTargetVector(targetOffset);
+    }
+
+    // #endregion Public Methods (3)
+}

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

@@ -0,0 +1,43 @@
+import { mat4, vec3 } from 'gl-matrix'
+
+import { ICamera } from '../../../interfaces/camera/ICamera'
+import { ICameraControlsUsage } from '../../../interfaces/controls/ICameraControlsUsage'
+import { ICameraInterpolation } from '../../../interfaces/interpolation/ICameraInterpolation'
+
+export class CameraOrthographicInterpolation 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 }) 
+    {
+    }
+
+    // #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());
+        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());
+        this._cameraControls.applyTargetVector(targetOffset);
+    }
+
+    public onStop(value: { delta: number }): void {
+    }
+
+    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());
+        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());
+        this._cameraControls.applyPositionVector(positionOffset);
+    }
+
+    // #endregion Public Methods (3)
+}

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

@@ -0,0 +1,67 @@
+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'
+
+export class CameraSphericalInterpolation implements ICameraInterpolation {
+    // #region Properties (6)
+
+    private _axis: vec3;
+    private _c_angle: number;
+    private _direction_from: vec3;
+    private _direction_to: vec3;
+    private _radius_from: number;
+    private _radius_to: number;
+
+    // #endregion Properties (6)
+
+    // #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 })
+    {
+        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));
+
+        this._axis = vec3.normalize(vec3.create(), vec3.cross(vec3.create(), this._direction_to, this._direction_from));
+        this._c_angle = -Math.acos(Math.min(1, Math.max(-1, vec3.dot(this._direction_to, this._direction_from))));
+    }
+
+    // #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());
+        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());
+        this._cameraControls.applyTargetVector(targetOffset);
+    }
+
+    public onStop(value: { delta: number }): void {
+    }
+
+    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());
+        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)));
+
+        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());
+        this._cameraControls.applyPositionVector(positionOffset);
+    }
+
+    // #endregion Public Methods (3)
+}

package/src/index.ts

@@ -0,0 +1,31 @@
+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'
+
+export {
+  ICameraEngine, ICamera, ICameraControls
+}
+
+export {
+  CameraEngine, AbstractCamera, CAMERA_TYPE, ORTHOGRAPHIC_CAMERA_DIRECTION, ICameraOptions
+}
+
+export { 
+  PerspectiveCamera, OrthographicCamera,
+  IPerspectiveCamera, IOrthographicCamera
+}
+
+export { 
+  PerspectiveCameraControls, OrthographicCameraControls,
+  IPerspectiveCameraControls, IOrthographicCameraControls
+}

package/src/interfaces/ICameraEngine.ts

@@ -0,0 +1,19 @@
+import { vec3 } from 'gl-matrix'
+
+import { ICamera } from './camera/ICamera'
+
+export enum CAMERA_TYPE {
+    PERSPECTIVE = 'perspective',
+    ORTHOGRAPHIC = 'orthographic'
+}
+
+export interface ICameraEngine {
+    update?: () => void;
+
+    assignCamera(id: string): boolean;
+    createCamera(type: CAMERA_TYPE, id?: string): ICamera;
+    removeCamera(id: string): boolean;
+
+    activateCameraEvents(): void;
+    deactivateCameraEvents(): void;
+}

package/src/interfaces/camera/ICamera.ts

@@ -0,0 +1,77 @@
+import { mat4, 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 { SettingsEngine } from '@shapediver/viewer.shared.services'
+
+export interface ICameraOptions {
+    /**
+     * 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 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 coordinate type of the camera interpolation. (default: 'cylindrical')
+     */
+    coordinates?: 'spherical' | 'linear' | 'cylindrical'; 
+    /**
+     * The interpolation type of the camera interpolation. (default: 'CatmullRom')
+     */
+    interpolation?: 'Linear' | 'Bezier' | 'CatmullRom' | Function
+}
+
+export interface ICamera extends ITreeNodeData {
+    // #region Properties (13)
+
+    readonly controls: ICameraControls;
+    readonly id: string;
+    readonly type: CAMERA_TYPE;
+
+    autoAdjust: boolean;
+    boundingBox: IBox;
+    cameraMovementDuration: number;
+    defaultPosition: vec3;
+    defaultTarget: vec3;
+    enableCameraControls: boolean;
+    position: vec3;
+    name?: string;
+    node?: ITreeNode;
+    order?: number;
+    revertAtMouseUp: boolean;
+    revertAtMouseUpDuration: number;
+    target: vec3;
+    useNodeData: boolean;
+    zoomExtentsFactor: number;
+
+    // #endregion Properties (13)
+
+    // #region Public Methods (6)
+
+    animate(path: { position: vec3, target: vec3 }[], options?: ICameraOptions): Promise<boolean>;
+    applySettings(settingsEngine: SettingsEngine): void;
+    reset(options?: ICameraOptions): Promise<boolean>;
+    set(position: vec3, target: vec3, options?: ICameraOptions): Promise<boolean>;
+    zoomTo(zoomTarget?: IBox, options?: ICameraOptions): Promise<boolean>;
+    calculateZoomTo(zoomTarget?: IBox, startingPosition?: vec3, startingTarget?: vec3): { position: vec3; target: vec3; };
+    project(p: vec3): vec2;
+    unproject(p: vec3): vec3;
+
+    // #endregion Public Methods (6)
+}

package/src/interfaces/camera/IOrthographicCamera.ts

@@ -0,0 +1,18 @@
+import { IOrthographicCameraControls } from '../controls/IOrthographicCameraControls';
+import { ICamera } from './ICamera'
+
+export enum ORTHOGRAPHIC_CAMERA_DIRECTION {
+    TOP = 'top',
+    BOTTOM = 'bottom',
+    LEFT = 'left',
+    RIGHT = 'right',
+    FRONT = 'front',
+    BACK = 'back',
+ }
+export interface IOrthographicCamera extends ICamera {
+    readonly controls: IOrthographicCameraControls;
+    
+    direction: ORTHOGRAPHIC_CAMERA_DIRECTION;
+
+    clone(): IOrthographicCamera;
+}

package/src/interfaces/camera/IPerspectiveCamera.ts

@@ -0,0 +1,10 @@
+import { IPerspectiveCameraControls } from '../controls/IPerspectiveCameraControls';
+import { ICamera } from './ICamera'
+
+export interface IPerspectiveCamera extends ICamera {  
+    readonly controls: IPerspectiveCameraControls;
+    
+    fov: number;
+
+    clone(): IPerspectiveCamera;
+}

package/src/interfaces/controls/ICameraControls.ts

@@ -0,0 +1,37 @@
+import { mat4, vec3 } from "gl-matrix";
+import { ICamera, ICameraOptions } from "../camera/ICamera";
+import { ICameraControlsEventDistribution } from "./ICameraControlsEventDistribution";
+
+export interface ICameraControls {
+    // #region Properties (6)
+
+    readonly cameraControlsEventDistribution: ICameraControlsEventDistribution;
+
+    camera: ICamera;
+    canvas?: HTMLCanvasElement;
+    enabled: boolean;
+    position: vec3;
+    target: vec3;
+
+    // #endregion Properties (6)
+
+    // #region Public Methods (15)
+
+    animate(path: { position: vec3, target: vec3 }[], options: ICameraOptions): Promise<boolean>;
+    applyPositionMatrix(matrix: mat4, manualInteraction?: boolean | undefined): void;
+    applyPositionVector(vector: vec3, manualInteraction?: boolean | undefined): void;
+    applyTargetMatrix(matrix: mat4, manualInteraction?: boolean | undefined): void;
+    applyTargetVector(vector: vec3, manualInteraction?: boolean | undefined): void;
+    applyUpMatrix(matrix: mat4, manualInteraction?: boolean | undefined): void;
+    assignViewer(viewportId: string, canvas: HTMLCanvasElement):void;
+    getPositionWithManualUpdates(): vec3;
+    getPositionWithUpdates(): vec3;
+    getTargetWithManualUpdates(): vec3;
+    getTargetWithUpdates(): vec3;
+    isMoving(): boolean;
+    isWithinRestrictions(position: vec3, target: vec3): boolean;
+    reset(): void;
+    update(time: number): { position: vec3, target: vec3 };
+
+    // #endregion Public Methods (15)
+}

package/src/interfaces/controls/ICameraControlsEventDistribution.ts

@@ -0,0 +1,8 @@
+import { IDomEventListener } from '@shapediver/viewer.shared.services'
+
+export interface ICameraControlsEventDistribution extends IDomEventListener {
+    reset(): void;
+
+    activateCameraEvents(): void;
+    deactivateCameraEvents(): void;
+}

package/src/interfaces/controls/ICameraControlsLogic.ts

@@ -0,0 +1,8 @@
+import { vec3 } from 'gl-matrix'
+
+export interface ICameraControlsLogic {
+    isWithinRestrictions(position: any, target: any): boolean;
+    reset(): void;
+    restrict(p: vec3, t: vec3): { position: vec3, target: vec3 };
+    update(time: number, manualInteraction: boolean): void
+}

package/src/interfaces/controls/ICameraControlsUsage.ts

@@ -0,0 +1,30 @@
+import { IDomEventListener } from '@shapediver/viewer.shared.services'
+import { mat4, vec3 } from 'gl-matrix'
+import { ICameraOptions } from '../camera/ICamera'
+
+import { ICameraControls } from './ICameraControls'
+
+export interface ICameraControlsUsage extends ICameraControls {
+    // #region Properties (4)
+
+    readonly canvas?: HTMLCanvasElement;
+
+    // #endregion Properties (4)
+
+    // #region Public Methods (12)
+
+    animate(path: { position: vec3, target: vec3 }[], options: ICameraOptions) : Promise<boolean>
+    applyPositionMatrix(matrix: mat4, manualInteraction?: boolean): void;
+    applyTargetMatrix(matrix: mat4, manualInteraction?: boolean): void;
+    applyPositionVector(vector: vec3, manualInteraction?: boolean): void;
+    applyTargetVector(vector: vec3, manualInteraction?: boolean): void;
+    applyUpMatrix(matrix: mat4, manualInteraction?: boolean): void;
+    getPositionWithManualUpdates(): vec3;
+    getTargetWithManualUpdates(): vec3;
+    getPositionWithUpdates(): vec3;
+    getTargetWithUpdates(): vec3;
+    isMoving(): boolean;
+    isWithinRestrictions(position: vec3, target: vec3): boolean;
+
+    // #endregion Public Methods (12)
+}

package/src/interfaces/controls/IOrthographicCameraControls.ts

@@ -0,0 +1,13 @@
+import { ICameraControls } from './ICameraControls'
+
+export interface IOrthographicCameraControls extends ICameraControls {
+    damping: number;
+    enableKeyPan: boolean;
+    enablePan: boolean;
+    enableZoom: boolean;
+    input: { keys: { up: number, down: number, left: number, right: number }, mouse: { rotate: number, zoom: number, pan: number }, touch: { rotate: number, zoom: number, pan: number } };
+    keyPanSpeed: number;
+    movementSmoothness: number;
+    panSpeed: number;
+    zoomSpeed: number;
+}

package/src/interfaces/controls/IPerspectiveCameraControls.ts

@@ -0,0 +1,25 @@
+import { vec3 } from 'gl-matrix'
+
+import { ICameraControls } from './ICameraControls'
+
+export interface IPerspectiveCameraControls extends ICameraControls {
+    autoRotationSpeed: number;
+    cubePositionRestriction: { min: vec3, max: vec3 };
+    cubeTargetRestriction: { min: vec3, max: vec3 };
+    damping: number;
+    enableAutoRotation: boolean;
+    enableKeyPan: boolean;
+    enablePan: boolean;
+    enableRotation: boolean;
+    enableZoom: boolean;
+    input: { keys: { up: number, down: number, left: number, right: number }, mouse: { rotate: number, zoom: number, pan: number }, touch: { rotate: number, zoom: number, pan: number } };
+    keyPanSpeed: number;
+    movementSmoothness: number;
+    panSpeed: number;
+    rotationRestriction: { minPolarAngle: number, maxPolarAngle: number, minAzimuthAngle: number, maxAzimuthAngle: number };
+    rotationSpeed: number;
+    spherePositionRestriction: { center: vec3, radius: number };
+    sphereTargetRestriction: { center: vec3, radius: number };
+    zoomRestriction: { minDistance: number, maxDistance: number };
+    zoomSpeed: number;
+}

package/src/interfaces/interpolation/ICameraInterpolation.ts

@@ -0,0 +1,5 @@
+export interface ICameraInterpolation {
+    onUpdate(value: { delta: number }): void;
+    onStop(value: { delta: number }): void;
+    onComplete(value: { delta: number }): void;
+}

package/tsconfig.json

@@ -0,0 +1,17 @@
+{
+    "extends": "../../tsconfig.json",
+    "include": [
+        "./**/*.ts"
+    ],
+    "compilerOptions": {
+        "rootDir": "src",
+        "outDir": "dist"
+    },
+    "exclude": [
+        "__tests__",
+        "node_modules",
+        "dist",
+        "dist-dev",
+        "dist-prod"
+    ]
+}