@shapediver/viewer.rendering-engine.camera-engine 3.3.3 → 3.3.6

package/src/implementation/interpolation/CameraInterpolationManager.ts

@@ -1,149 +0,0 @@
-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 (2)
-
-    private TweenWrapper = class {
-        private _properties: { delta: 0 } = { delta: 0 };
-        private _tween!: TWEEN.Tween<{ delta: number }>;
-        private _resolve!: (value: boolean | PromiseLike<boolean>) => void;
-
-        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.to({ delta: 1.0 }, options.duration);
-
-            this._tween.onUpdate((v) => {
-                cb.onUpdate(v);
-            });
-
-            this._tween.onStop((v) => {
-                if (cb.onStop) cb.onStop(v);
-                this._resolve(true);
-            });
-            this._tween.onComplete((v) => {
-                if (cb.onComplete) cb.onComplete(v);
-                onComplete();
-                this._resolve(true);
-            });
-        }
-
-        public start(): Promise<boolean> {
-            return new Promise((resolve) => {
-                this._resolve = resolve;
-                this._tween.start();
-            });
-        }
-
-        public stop(): void {
-            this._tween.stop();
-        }
-    };
-    private _tween: any;
-
-    // #endregion Properties (2)
-
-    // #region Constructors (1)
-
-    constructor(
-        private readonly _camera: ICamera,
-        private readonly _cameraControls: ICameraControls
-    ) {
-    }
-
-    // #endregion Constructors (1)
-
-    // #region Public Methods (3)
-
-    public active(): boolean {
-        return this._tween ? true : false;
-    }
-
-    /**
-     * cameraTween
-     */
-    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++)
-            newPath.push({
-                position: path[i].position,
-                target: path[i].target,
-            });
-
-        if (this._tween) {
-            this._tween.stop();
-            this._tween = null;
-        }
-        const parsedOptions = this.optionsParser(options);
-
-        this._tween = new this.TweenWrapper(
-            parsedOptions,
-            newPath.length === 2 ?
-                this.getCameraInterpolation(newPath[0], newPath[1], parsedOptions.coordinates) :
-                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();
-        this._tween = null;
-    }
-
-    // #endregion Public Methods (3)
-
-    // #region Private Methods (2)
-
-    private getCameraInterpolation(from: { position: vec3, target: vec3 }, to: { position: vec3, target: vec3 }, type: string) {
-        switch (type) {
-            case 'linear':
-                return new CameraLinearInterpolation(this._camera, this._cameraControls, from, to);
-            case 'spherical':
-                return new CameraSphericalInterpolation(this._camera, this._cameraControls, from, to);
-            case 'cylindrical':
-                return new CameraCylindricalInterpolation(this._camera, this._cameraControls, from, to);
-            default:
-                return new CameraMultipleInterpolation(this._camera, this._cameraControls, [from, to], TWEEN.Interpolation.CatmullRom);
-        }
-    }
-
-    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') {
-            const keys = options.easing.split('.');
-            const easingFamily = TWEEN.Easing[<keyof typeof TWEEN.Easing>keys[0]];
-            if (easingFamily) {
-                const easingFunction = easingFamily[<keyof typeof easingFamily>keys[1]];
-                if (easingFunction) easing = easingFunction;
-            }
-        } else if (typeof options.easing === 'function') {
-            easing = <(amount: number) => number>options.easing;
-        }
-
-        let interpolation = TWEEN.Interpolation.CatmullRom;
-        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') {
-            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,
-            interpolation
-        };
-    }
-
-    // #endregion Private Methods (2)
-}

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

@@ -1,83 +0,0 @@
-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)
-
-    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: ICameraControls,
-        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...
-        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);
-    }
-
-    // #endregion Constructors (1)
-
-    // #region Public Methods (3)
-
-    public onComplete(value: { delta: number }): void {
-        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);
-        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);
-    }
-
-    public onStop(value: { delta: number }): void {
-    }
-
-    public onUpdate(value: { delta: number }): void {
-        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);
-
-        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));
-
-        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)));
-
-        const positionOffset = vec3.subtract(vec3.create(), p, this._cameraControls.getPositionWithUpdates());
-        this._cameraControls.applyPositionVector(positionOffset);
-    }
-
-    // #endregion Public Methods (3)
-}

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

@@ -1,41 +0,0 @@
-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: 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 {
-        const positionOffset = vec3.subtract(vec3.create(), this._to.position, this._cameraControls.getPositionWithUpdates());
-        this._cameraControls.applyPositionVector(positionOffset);
-        const 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 {
-        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);
-
-        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);
-    }
-
-    // #endregion Public Methods (3)
-}

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

@@ -1,61 +0,0 @@
-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)
-
-    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: ICameraControls,
-        private readonly _path: { position: vec3, target: vec3 }[],
-        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]);
-            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 {
-        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);
-        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);
-    }
-
-    public onStop(value: { delta: number }): void {
-    }
-
-    public onUpdate(value: { delta: number }): void {
-        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);
-
-        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);
-    }
-
-    // #endregion Public Methods (3)
-}

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

@@ -1,41 +0,0 @@
-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: 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 {
-        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);
-        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);
-    }
-
-    public onStop(value: { delta: number }): void {
-    }
-
-    public onUpdate(value: { delta: number }): void {
-        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);
-
-        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);
-    }
-
-    // #endregion Public Methods (3)
-}

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

@@ -1,65 +0,0 @@
-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)
-
-    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: ICameraControls,
-        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 {
-        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);
-
-        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);
-    }
-
-    public onStop(value: { delta: number }): void {
-    }
-
-    public onUpdate(value: { delta: number }): void {
-        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);
-
-        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)));
-
-        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);
-    }
-
-    // #endregion Public Methods (3)
-}

package/src/index.ts

@@ -1,28 +0,0 @@
-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 {
-  PerspectiveCamera, OrthographicCamera,
-  IPerspectiveCamera, IOrthographicCamera
-};
-
-export {
-  PerspectiveCameraControls, OrthographicCameraControls
-};

package/src/interfaces/ICameraEngine.ts

@@ -1,33 +0,0 @@
-import { ICamera } from './camera/ICamera';
-
-// #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;
-
-    // #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,88 +0,0 @@
-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';
-
-// #region Interfaces (2)
-
-export interface ICamera extends ITreeNodeData {
-    // #region Properties (21)
-
-    readonly controls: ICameraControls;
-    readonly id: string;
-    readonly type: CAMERA_TYPE;
-    readonly isDefault: boolean;
-
-    active: boolean;
-    autoAdjust: boolean;
-    boundingBox: IBox;
-    cameraMovementDuration: number;
-    defaultPosition: vec3;
-    defaultTarget: vec3;
-    domEventListenerToken?: string;
-    enableCameraControls: boolean;
-    name?: string;
-    node?: ITreeNode;
-    order?: number;
-    position: vec3;
-    revertAtMouseUp: boolean;
-    revertAtMouseUpDuration: number;
-    sceneRotation: vec2;
-    target: vec3;
-    useNodeData: boolean;
-    zoomExtentsFactor: number;
-
-    // #endregion Properties (21)
-
-    // #region Public Methods (8)
-
-    animate(path: { position: vec3, target: vec3 }[], options?: ICameraOptions): Promise<boolean>;
-    applySettings(settingsEngine: SettingsEngine): void;
-    calculateZoomTo(zoomTarget?: IBox, startingPosition?: vec3, startingTarget?: vec3): { position: vec3; target: vec3; };
-    project(p: vec3): vec2;
-    reset(options?: ICameraOptions): Promise<boolean>;
-    set(position: vec3, target: vec3, options?: ICameraOptions): Promise<boolean>;
-    unproject(p: vec3): vec3;
-    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,36 +0,0 @@
-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',
-    BOTTOM = 'bottom',
-    LEFT = 'left',
-    RIGHT = 'right',
-    FRONT = 'front',
-    BACK = 'back',
-    CUSTOM = 'custom'
-}
-
-// #endregion Enums (1)

package/src/interfaces/camera/IPerspectiveCamera.ts

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