@shapediver/viewer.rendering-engine.camera-engine 2.11.0 → 2.12.1

package/src/implementation/controls/perspective/CameraControlsLogic.ts

@@ -1,9 +1,9 @@
-import { mat4, quat, vec2, vec3 } from 'gl-matrix'
-import { Box, Sphere, Spherical } from '@shapediver/viewer.shared.math'
+import { mat4, quat, vec2, vec3 } from 'gl-matrix';
+import { Box, Sphere, Spherical } from '@shapediver/viewer.shared.math';
 
-import { PerspectiveCameraControls } from '../PerspectiveCameraControls'
-import { ICameraControlsLogic } from '../../../interfaces/controls/ICameraControlsLogic'
-import { PerspectiveCamera } from '../../camera/PerspectiveCamera'
+import { PerspectiveCameraControls } from '../PerspectiveCameraControls';
+import { ICameraControlsLogic } from '../../../interfaces/controls/ICameraControlsLogic';
+import { PerspectiveCamera } from '../../camera/PerspectiveCamera';
 
 export class CameraControlsLogic implements ICameraControlsLogic {
     // #region Properties (15)
@@ -49,7 +49,7 @@ export class CameraControlsLogic implements ICameraControlsLogic {
         autoRotationSpeed: 2 * Math.PI / 60 / 60,
         damping: 1.0,
         movementSmoothness: 1.0,
-        panSpeed: 2.0,
+        panSpeed: 1.75,
         rotationSpeed: Math.PI,
         zoomSpeed: 0.025,
     };
@@ -57,8 +57,8 @@ export class CameraControlsLogic implements ICameraControlsLogic {
         autoRotationSpeed: 1.0,
         damping: 1.0,
         movementSmoothness: 1.0,
-        panSpeed: 1.5,
-        rotationSpeed: 2.0,
+        panSpeed: 1.0 / 1.75,
+        rotationSpeed: 1.5,
         zoomSpeed: 100.0,
     };
 
@@ -76,7 +76,7 @@ export class CameraControlsLogic implements ICameraControlsLogic {
     // #region Public Methods (7)
 
     public isWithinRestrictions(position: vec3, target: vec3): boolean {
-        let pBox = new Box(this._controls.cubePositionRestriction.min, this._controls.cubePositionRestriction.max),
+        const pBox = new Box(this._controls.cubePositionRestriction.min, this._controls.cubePositionRestriction.max),
             pSphere = new Sphere(this._controls.spherePositionRestriction.center, this._controls.spherePositionRestriction.radius),
             tBox = new Box(this._controls.cubeTargetRestriction.min, this._controls.cubeTargetRestriction.max),
             tSphere = new Sphere(this._controls.sphereTargetRestriction.center, this._controls.sphereTargetRestriction.radius);
@@ -84,10 +84,10 @@ export class CameraControlsLogic implements ICameraControlsLogic {
         if (!(pBox.containsPoint(position) && pSphere.containsPoint(position))) return false;
         if (!(tBox.containsPoint(target) && tSphere.containsPoint(target))) return false;
 
-        let currentDistance = vec3.distance(position, target);
+        const currentDistance = vec3.distance(position, target);
         if (currentDistance > this._controls.zoomRestriction.maxDistance || currentDistance < this._controls.zoomRestriction.minDistance) return false;
 
-        let minPolarAngle = this._controls.rotationRestriction.minPolarAngle * (Math.PI / 180),
+        const minPolarAngle = this._controls.rotationRestriction.minPolarAngle * (Math.PI / 180),
             maxPolarAngle = this._controls.rotationRestriction.maxPolarAngle * (Math.PI / 180),
             minAzimuthAngle = this._controls.rotationRestriction.minAzimuthAngle * (Math.PI / 180),
             maxAzimuthAngle = this._controls.rotationRestriction.maxAzimuthAngle * (Math.PI / 180);
@@ -96,7 +96,7 @@ export class CameraControlsLogic implements ICameraControlsLogic {
             maxAzimuthAngle !== Infinity ||
             minPolarAngle !== 0 ||
             maxPolarAngle !== 180) {
-            let offset = vec3.sub(vec3.create(), position, target);
+            const offset = vec3.sub(vec3.create(), position, target);
             vec3.transformQuat(offset, offset, this._quat);
             const spherical = new Spherical().fromVec3(offset);
 
@@ -112,10 +112,6 @@ export class CameraControlsLogic implements ICameraControlsLogic {
     }
 
     public pan(x: number, y: number, active: boolean, touch: boolean): void {
-        if (touch) {
-            x = x / window.devicePixelRatio;
-            y = y / window.devicePixelRatio;
-        }
 
         if (!active) {
             this._panStart = vec2.fromValues(x, y);
@@ -123,11 +119,10 @@ export class CameraControlsLogic implements ICameraControlsLogic {
             this._panEnd = vec2.fromValues(x, y);
             vec2.sub(this._panDelta, this._panEnd, this._panStart);
             if (this._panDelta[0] === 0 && this._panDelta[1] === 0) return;
-
             vec2.copy(this._panStart, this._panEnd);
 
             const adjustedPanSpeed = this._adjustedSettings.panSpeed() * (touch ? this._touchAdjustments.panSpeed : 1.0);
-            let offset = this.panDeltaToOffset(vec2.mul(vec2.create(), this._panDelta, vec2.fromValues(adjustedPanSpeed, adjustedPanSpeed)));
+            const offset = this.panDeltaToOffset(vec2.mul(vec2.create(), this._panDelta, vec2.fromValues(adjustedPanSpeed, adjustedPanSpeed)));
 
             if (this._damping.pan.duration > 0) {
                 if (offset[0] < 0) {
@@ -147,11 +142,11 @@ export class CameraControlsLogic implements ICameraControlsLogic {
                 }
             }
 
-            let damping = 1 - Math.max(0.01, Math.min(0.99, this._adjustedSettings.damping()));
+            const damping = 1 - Math.max(0.01, Math.min(0.99, this._adjustedSettings.damping()));
 
-            let framesOffsetX = (Math.log(1 / Math.abs(offset[0])) - 5 * Math.log(10)) / (Math.log(damping));
-            let framesOffsetY = (Math.log(1 / Math.abs(offset[1])) - 5 * Math.log(10)) / (Math.log(damping));
-            let framesOffsetZ = (Math.log(1 / Math.abs(offset[2])) - 5 * Math.log(10)) / (Math.log(damping));
+            const framesOffsetX = (Math.log(1 / Math.abs(offset[0])) - 5 * Math.log(10)) / (Math.log(damping));
+            const framesOffsetY = (Math.log(1 / Math.abs(offset[1])) - 5 * Math.log(10)) / (Math.log(damping));
+            const framesOffsetZ = (Math.log(1 / Math.abs(offset[2])) - 5 * Math.log(10)) / (Math.log(damping));
             this._damping.pan.time = 0;
             this._damping.pan.duration = Math.max(framesOffsetX, Math.max(framesOffsetY, framesOffsetZ)) * 16.6666;
             this._damping.pan.offset = vec3.clone(offset);
@@ -194,8 +189,8 @@ export class CameraControlsLogic implements ICameraControlsLogic {
         this._rotateStart = vec2.create();
     }
 
-    public restrict(position: vec3, target: vec3): { position: vec3, target: vec3 } {
-        let pBox = new Box(this._controls.cubePositionRestriction.min, this._controls.cubePositionRestriction.max),
+    public restrict(position: vec3, target: vec3, sceneRotation: vec2): { position: vec3, target: vec3, sceneRotation: vec2 } {
+        const pBox = new Box(this._controls.cubePositionRestriction.min, this._controls.cubePositionRestriction.max),
             pSphere = new Sphere(this._controls.spherePositionRestriction.center, this._controls.spherePositionRestriction.radius),
             tBox = new Box(this._controls.cubeTargetRestriction.min, this._controls.cubeTargetRestriction.max),
             tSphere = new Sphere(this._controls.sphereTargetRestriction.center, this._controls.sphereTargetRestriction.radius);
@@ -213,15 +208,15 @@ export class CameraControlsLogic implements ICameraControlsLogic {
             target = tSphere.clampPoint(target);
 
         // zoom restrictions
-        let currentDistance = vec3.distance(position, target);
+        const currentDistance = vec3.distance(position, target);
         if (currentDistance > this._controls.zoomRestriction.maxDistance || currentDistance < this._controls.zoomRestriction.minDistance) {
-            let direction = vec3.normalize(vec3.create(), vec3.subtract(vec3.create(), position, target))
-            let distance = Math.max(this._controls.zoomRestriction.minDistance, Math.min(this._controls.zoomRestriction.maxDistance, currentDistance));
+            const direction = vec3.normalize(vec3.create(), vec3.subtract(vec3.create(), position, target));
+            const distance = Math.max(this._controls.zoomRestriction.minDistance, Math.min(this._controls.zoomRestriction.maxDistance, currentDistance));
             vec3.add(position, vec3.multiply(position, direction, vec3.fromValues(distance, distance, distance)), target);
         }
 
         // angle restrictions
-        let minPolarAngle = this._controls.rotationRestriction.minPolarAngle * (Math.PI / 180),
+        const minPolarAngle = this._controls.rotationRestriction.minPolarAngle * (Math.PI / 180),
             maxPolarAngle = this._controls.rotationRestriction.maxPolarAngle * (Math.PI / 180),
             minAzimuthAngle = this._controls.rotationRestriction.minAzimuthAngle * (Math.PI / 180),
             maxAzimuthAngle = this._controls.rotationRestriction.maxAzimuthAngle * (Math.PI / 180);
@@ -229,7 +224,10 @@ export class CameraControlsLogic implements ICameraControlsLogic {
         if (minAzimuthAngle !== -Infinity ||
             maxAzimuthAngle !== Infinity ||
             minPolarAngle !== 0 ||
-            maxPolarAngle !== 180) {
+            maxPolarAngle !== 180 ||
+            this._controls.enableAzimuthRotation === false ||
+            this._controls.enablePolarRotation === false
+        ) {
             let offset = vec3.subtract(vec3.create(), position, target);
             vec3.transformQuat(offset, offset, this._quat);
 
@@ -238,53 +236,72 @@ export class CameraControlsLogic implements ICameraControlsLogic {
             if (spherical.theta < minAzimuthAngle ||
                 spherical.theta > maxAzimuthAngle ||
                 spherical.phi < minPolarAngle ||
-                spherical.phi > maxPolarAngle) {
+                spherical.phi > maxPolarAngle ||
+                this._controls.enableAzimuthRotation === false ||
+                this._controls.enablePolarRotation === false
+            ) {
                 spherical.theta = Math.max(minAzimuthAngle, Math.min(maxAzimuthAngle, spherical.theta));
                 spherical.phi = Math.max(minPolarAngle, Math.min(maxPolarAngle, spherical.phi));
+
+                if (this._controls.enableAzimuthRotation === false || this._controls.enablePolarRotation === false) {
+                    const defaultOffset = vec3.subtract(vec3.create(), this._controls.camera.defaultPosition, this._controls.camera.defaultTarget);
+                    vec3.transformQuat(defaultOffset, defaultOffset, this._quat);
+
+                    const defaultSpherical = new Spherical().fromVec3(defaultOffset);
+                    if (this._controls.enableAzimuthRotation === false) spherical.theta = defaultSpherical.theta;
+                    if (this._controls.enablePolarRotation === false) spherical.phi = defaultSpherical.phi;
+                }
+
                 spherical.makeSafe();
                 offset = spherical.toVec3();
                 vec3.transformQuat(offset, offset, this._quatInverse);
                 vec3.add(position, offset, target);
             }
+
+            if (sceneRotation[1] < minAzimuthAngle ||
+                sceneRotation[1] > maxAzimuthAngle ||
+                sceneRotation[0] < minPolarAngle ||
+                sceneRotation[0] > maxPolarAngle ||
+                this._controls.enableAzimuthRotation === false ||
+                this._controls.enablePolarRotation === false) {
+                sceneRotation[1] = this._controls.enableAzimuthRotation === false ? 0 : Math.max(minAzimuthAngle, Math.min(maxAzimuthAngle, sceneRotation[1]));
+                sceneRotation[0] = this._controls.enablePolarRotation === false ? 0 : Math.max(minPolarAngle, Math.min(maxPolarAngle, sceneRotation[0]));
+            }
         }
 
-        return { position, target };
+        return { position, target, sceneRotation };
     }
 
     public rotate(x: number, y: number, active: boolean, touch: boolean): void {
-        if (touch) {
-            x = x / window.devicePixelRatio;
-            y = y / window.devicePixelRatio;
-        }
 
         if (!active) {
-            this._rotateStart = vec2.fromValues(x, y)
+            this._rotateStart = vec2.fromValues(x, y);
         } else {
-            this._rotateEnd = vec2.fromValues(x, y)
-            vec2.subtract(this._rotateDelta, this._rotateEnd, this._rotateStart)
-            vec2.copy(this._rotateStart, this._rotateEnd)
+            this._rotateEnd = vec2.fromValues(x, y);
+            vec2.subtract(this._rotateDelta, this._rotateEnd, this._rotateStart);
+            vec2.copy(this._rotateStart, this._rotateEnd);
 
             if (!this._controls.canvas) return;
             if (this._controls.canvas.clientWidth == 0 || this._controls.canvas.clientHeight == 0) return;
 
             const spherical = new Spherical();
-            let rotationSpeed = this._adjustedSettings.rotationSpeed() * (touch ? this._touchAdjustments.rotationSpeed : 1.0);
-            spherical.theta -= rotationSpeed * this._rotateDelta[0];
-            spherical.phi -= rotationSpeed * this._rotateDelta[1];
+            const rotationSpeed = this._adjustedSettings.rotationSpeed() * (touch ? this._touchAdjustments.rotationSpeed : 1.0);
+            spherical.theta -= rotationSpeed * this._rotateDelta[0] / this._controls.canvas.clientHeight;
+            spherical.phi -= rotationSpeed * this._rotateDelta[1] / this._controls.canvas.clientHeight;
 
             if (this._damping.rotation.duration > 0) {
-                let thetaDelta = this._damping.rotation.theta - spherical.theta;
+                const thetaDelta = this._damping.rotation.theta - spherical.theta;
                 spherical.theta += thetaDelta * this._adjustedSettings.movementSmoothness();
 
-                let phiDelta = this._damping.rotation.phi - spherical.phi;
+                const phiDelta = this._damping.rotation.phi - spherical.phi;
                 spherical.phi += phiDelta * this._adjustedSettings.movementSmoothness();
             }
 
-            let offset = this.rotationSphericalToOffset(spherical);
+            const offset = this.rotationSphericalToOffset(this._controls.enableTurntableControls ? new Spherical(1.0, spherical.phi, 0) : spherical);
 
-            let damping = 1 - Math.max(0.01, Math.min(1, this._adjustedSettings.damping()));
-            let framesTheta = (Math.log(1 / Math.abs(spherical.theta)) - 5 * Math.log(10)) / (Math.log(damping));
-            let framesPhi = (Math.log(1 / Math.abs(spherical.phi)) - 5 * Math.log(10)) / (Math.log(damping));
+            const damping = 1 - Math.max(0.01, Math.min(1, this._adjustedSettings.damping()));
+            const framesTheta = (Math.log(1 / Math.abs(spherical.theta)) - 5 * Math.log(10)) / (Math.log(damping));
+            const framesPhi = (Math.log(1 / Math.abs(spherical.phi)) - 5 * Math.log(10)) / (Math.log(damping));
 
             this._damping.rotation.time = 0;
             this._damping.rotation.duration = Math.max(framesTheta, framesPhi) * 16.6666;
@@ -295,6 +312,7 @@ export class CameraControlsLogic implements ICameraControlsLogic {
             this._damping.zoom.duration = 0;
 
             this._controls.applyPositionVector(offset, true);
+            if (this._controls.enableTurntableControls) this._controls.applyRotation([0, spherical.theta], true);
         }
     }
 
@@ -305,7 +323,7 @@ export class CameraControlsLogic implements ICameraControlsLogic {
             this._damping.rotation.duration = 0;
         }
 
-        let damping = 1 - Math.max(0.01, Math.min(1, this._adjustedSettings.damping()));
+        const damping = 1 - Math.max(0.01, Math.min(1, this._adjustedSettings.damping()));
 
         if (this._damping.pan.duration > 0) {
             if (this._damping.pan.time + time > this._damping.pan.duration) {
@@ -314,9 +332,9 @@ export class CameraControlsLogic implements ICameraControlsLogic {
             } else {
                 this._damping.pan.time += time;
 
-                let frameSinceStart = this._damping.pan.time / 16.6666;
-                let dampingFrames = Math.pow(damping, frameSinceStart);
-                let offset = vec3.multiply(vec3.create(), this._damping.pan.offset, vec3.fromValues(dampingFrames, dampingFrames, dampingFrames));
+                const frameSinceStart = this._damping.pan.time / 16.6666;
+                const dampingFrames = Math.pow(damping, frameSinceStart);
+                const offset = vec3.multiply(vec3.create(), this._damping.pan.offset, vec3.fromValues(dampingFrames, dampingFrames, dampingFrames));
                 this._controls.applyTargetVector(offset);
                 this._controls.applyPositionVector(offset);
             }
@@ -331,12 +349,13 @@ export class CameraControlsLogic implements ICameraControlsLogic {
             } else {
                 this._damping.rotation.time += time;
 
-                let frameSinceStart = this._damping.rotation.time / 16.6666;
-                let spherical = new Spherical();
+                const frameSinceStart = this._damping.rotation.time / 16.6666;
+                const spherical = new Spherical();
                 spherical.theta = this._damping.rotation.theta * Math.pow(damping, frameSinceStart);
                 spherical.phi = this._damping.rotation.phi * Math.pow(damping, frameSinceStart);
-                let offset = this.rotationSphericalToOffset(spherical);
+                const offset = this.rotationSphericalToOffset(this._controls.enableTurntableControls ? new Spherical(1.0, spherical.phi, 0) : spherical);
                 this._controls.applyPositionVector(offset);
+                if (this._controls.enableTurntableControls) this._controls.applyRotation([0, spherical.theta]);
             }
         } else {
             this._damping.rotation.time = 0;
@@ -349,9 +368,9 @@ export class CameraControlsLogic implements ICameraControlsLogic {
             } else {
                 this._damping.zoom.time += time;
 
-                let frameSinceStart = this._damping.zoom.time / 16.6666;
-                let delta = this._damping.zoom.delta * Math.pow(damping, frameSinceStart);
-                let offset = this.zoomDistanceToOffset(delta);
+                const frameSinceStart = this._damping.zoom.time / 16.6666;
+                const delta = this._damping.zoom.delta * Math.pow(damping, frameSinceStart);
+                const offset = this.zoomDistanceToOffset(delta);
                 this._controls.applyPositionVector(offset);
             }
         } else {
@@ -359,17 +378,15 @@ export class CameraControlsLogic implements ICameraControlsLogic {
         }
 
         if (this._controls.enableAutoRotation) {
-            let spherical = new Spherical(1.0, 0.0, -this._adjustedSettings.autoRotationSpeed());
-            let offset = this.rotationSphericalToOffset(spherical);
+            const spherical = new Spherical(1.0, 0.0, -this._adjustedSettings.autoRotationSpeed());
+            const offset = this.rotationSphericalToOffset(this._controls.enableTurntableControls ? new Spherical(1.0, spherical.phi, 0) : spherical);
             this._controls.applyPositionVector(offset);
+            if (this._controls.enableTurntableControls) this._controls.applyRotation([0, spherical.theta]);
         }
     }
 
     public zoom(x: number, y: number, active: boolean, touch: boolean): void {
-        var distance = Math.sqrt(x * x + y * y);
-
-        if (touch)
-            distance = distance / window.devicePixelRatio;
+        const distance = Math.sqrt(x * x + y * y);
 
         if (!active) {
             this._dollyStart = distance;
@@ -386,10 +403,10 @@ export class CameraControlsLogic implements ICameraControlsLogic {
                 }
             }
 
-            let delta = - this._dollyDelta * this._adjustedSettings.zoomSpeed() * (touch ? this._touchAdjustments.zoomSpeed : 1.0);
+            const delta = - this._dollyDelta * this._adjustedSettings.zoomSpeed() * (touch ? this._touchAdjustments.zoomSpeed : 1.0);
 
-            let damping = 1 - Math.max(0.01, Math.min(1, this._adjustedSettings.damping()));
-            let framesDelta = (Math.log(1 / Math.abs(this._dollyDelta)) - 5 * Math.log(10)) / (Math.log(damping));
+            const damping = 1 - Math.max(0.01, Math.min(1, this._adjustedSettings.damping()));
+            const framesDelta = (Math.log(1 / Math.abs(this._dollyDelta)) - 5 * Math.log(10)) / (Math.log(damping));
             this._damping.zoom.time = 0;
             this._damping.zoom.duration = framesDelta * 16.6666;
             this._damping.zoom.delta = delta;
@@ -397,7 +414,7 @@ export class CameraControlsLogic implements ICameraControlsLogic {
             this._damping.rotation.duration = 0;
             this._damping.pan.duration = 0;
 
-            let offset = this.zoomDistanceToOffset(delta);
+            const offset = this.zoomDistanceToOffset(delta);
             this._controls.applyPositionVector(offset, true);
         }
     }
@@ -407,12 +424,15 @@ export class CameraControlsLogic implements ICameraControlsLogic {
     // #region Private Methods (3)
 
     private panDeltaToOffset(panDelta: vec2): vec3 {
-        let offset = vec3.create();
-        let panOffset = vec3.create();
+        const offset = vec3.create();
+        const panOffset = vec3.create();
+        
+        if (!this._controls.canvas) return offset;
+        if (this._controls.canvas.clientWidth == 0 || this._controls.canvas.clientHeight == 0) return offset;
 
         // perspective
         vec3.subtract(offset, this._controls.getPositionWithManualUpdates(), this._controls.getTargetWithManualUpdates());
-        var targetDistance = vec3.length(offset);
+        let targetDistance = vec3.length(offset);
 
         // half of the fov is center to top of screen
         targetDistance *= Math.tan((((<PerspectiveCamera>this._controls.camera).fov / 2) * Math.PI) / 180.0);
@@ -422,13 +442,13 @@ export class CameraControlsLogic implements ICameraControlsLogic {
         const mat = mat4.targetTo(mat4.create(), this._controls.camera.position, this._controls.camera.target, vec3.fromValues(0, 0, 1));
 
         const v1 = vec3.fromValues(mat[0], mat[1], mat[2]);
-        const scalar1 = -(2 * panDelta[0] * targetDistance);
+        const scalar1 = -(2 * panDelta[0] * targetDistance / this._controls.canvas?.clientHeight);
         vec3.multiply(v1, v1, vec3.fromValues(scalar1, scalar1, scalar1));
         vec3.add(panOffset, panOffset, v1);
 
         // // up
-        const v2 = vec3.fromValues(mat[4], mat[5], mat[6])
-        const scalar2 = 2 * panDelta[1] * targetDistance;
+        const v2 = vec3.fromValues(mat[4], mat[5], mat[6]);
+        const scalar2 = 2 * panDelta[1] * targetDistance / this._controls.canvas?.clientHeight;
         vec3.multiply(v2, v2, vec3.fromValues(scalar2, scalar2, scalar2));
         vec3.add(panOffset, panOffset, v2);
 
@@ -439,13 +459,13 @@ export class CameraControlsLogic implements ICameraControlsLogic {
         let offset = vec3.create();
         vec3.subtract(offset, this._controls.getPositionWithManualUpdates(), this._controls.getTargetWithManualUpdates());
         vec3.transformQuat(offset, offset, this._quat);
-        let spherical = new Spherical().fromVec3(offset);
+        const spherical = new Spherical().fromVec3(offset);
 
         spherical.theta += s.theta;
         spherical.phi += s.phi;
 
-        let minAzimuthAngle = this._controls.rotationRestriction.minAzimuthAngle * (Math.PI / 180),
-        maxAzimuthAngle = this._controls.rotationRestriction.maxAzimuthAngle * (Math.PI / 180);
+        const minAzimuthAngle = this._controls.rotationRestriction.minAzimuthAngle * (Math.PI / 180),
+            maxAzimuthAngle = this._controls.rotationRestriction.maxAzimuthAngle * (Math.PI / 180);
 
         if (spherical.theta > Math.PI) {
             spherical.theta -= 2 * Math.PI;
@@ -462,17 +482,16 @@ export class CameraControlsLogic implements ICameraControlsLogic {
         spherical.makeSafe();
         offset = spherical.toVec3();
         offset = vec3.transformQuat(vec3.create(), offset, this._quatInverse);
-        offset = vec3.add(vec3.create(), offset, this._controls.getTargetWithManualUpdates())
+        offset = vec3.add(vec3.create(), offset, this._controls.getTargetWithManualUpdates());
         offset = vec3.subtract(vec3.create(), offset, this._controls.getPositionWithManualUpdates());
         return vec3.clone(offset);
-
     }
 
     private zoomDistanceToOffset(distance: number): vec3 {
-        let offset = vec3.create();
+        const offset = vec3.create();
         vec3.subtract(offset, this._controls.getPositionWithManualUpdates(), this._controls.getTargetWithManualUpdates());
         return vec3.multiply(vec3.create(), offset, vec3.fromValues(distance, distance, distance));
     }
 
     // #endregion Private Methods (3)
-};
+}

package/src/interfaces/camera/ICamera.ts

@@ -1,16 +1,28 @@
-import { mat4, vec2, vec3 } from 'gl-matrix'
-import { ITreeNode, ITreeNodeData } from '@shapediver/viewer.shared.node-tree'
+/* 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 { SettingsEngine } from '@shapediver/viewer.shared.services'
+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 {
+    // #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' | 
+    easing?: 'Linear.None' |
     'Quadratic.In' | 'Quadratic.Out' | 'Quadratic.InOut' |
     'Cubic.In' | 'Cubic.Out' | 'Cubic.InOut' |
     'Quartic.In' | 'Quartic.Out' | 'Quartic.InOut' |
@@ -20,25 +32,17 @@ export interface ICameraOptions {
     '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'; 
+    'Bounce.In' | 'Bounce.Out' | 'Bounce.InOut' | Function;
     /**
      * The interpolation type of the camera interpolation. (default: 'CatmullRom')
      */
     interpolation?: 'Linear' | 'Bezier' | 'CatmullRom' | Function
+
+    // #endregion Properties (4)
 }
 
 export interface ICamera extends ITreeNodeData {
-    // #region Properties (13)
+    // #region Properties (20)
 
     readonly controls: ICameraControls;
     readonly id: string;
@@ -51,28 +55,29 @@ export interface ICamera extends ITreeNodeData {
     defaultPosition: vec3;
     defaultTarget: vec3;
     enableCameraControls: boolean;
-    position: vec3;
     name?: string;
     node?: ITreeNode;
     order?: number;
+    position: vec3;
     revertAtMouseUp: boolean;
     revertAtMouseUpDuration: number;
+    sceneRotation: vec2;
     target: vec3;
     useNodeData: boolean;
     zoomExtentsFactor: number;
 
-    // #endregion Properties (13)
+    // #endregion Properties (20)
 
-    // #region Public Methods (6)
+    // #region Public Methods (8)
 
     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;
+    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 (6)
+    // #endregion Public Methods (8)
 }

package/src/interfaces/controls/ICameraControls.ts

@@ -1,6 +1,6 @@
-import { mat4, vec3 } from "gl-matrix";
-import { ICamera, ICameraOptions } from "../camera/ICamera";
-import { ICameraControlsEventDistribution } from "./ICameraControlsEventDistribution";
+import { mat4, vec2, vec3 } from 'gl-matrix';
+import { ICamera, ICameraOptions } from '../camera/ICamera';
+import { ICameraControlsEventDistribution } from './ICameraControlsEventDistribution';
 
 export interface ICameraControls {
     // #region Properties (6)
@@ -23,7 +23,7 @@ export interface ICameraControls {
     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;
+    assignViewer(viewportId: string, canvas: HTMLCanvasElement): void;
     getPositionWithManualUpdates(): vec3;
     getPositionWithUpdates(): vec3;
     getTargetWithManualUpdates(): vec3;
@@ -31,7 +31,7 @@ export interface ICameraControls {
     isMoving(): boolean;
     isWithinRestrictions(position: vec3, target: vec3): boolean;
     reset(): void;
-    update(time: number): { position: vec3, target: vec3 };
+    update(time: number): { position: vec3, target: vec3, sceneRotation: vec2 };
 
     // #endregion Public Methods (15)
 }

package/src/interfaces/controls/ICameraControlsLogic.ts

@@ -1,8 +1,12 @@
-import { vec3 } from 'gl-matrix'
+import { vec2, vec3 } from 'gl-matrix';
 
 export interface ICameraControlsLogic {
+    // #region Public Methods (4)
+
     isWithinRestrictions(position: any, target: any): boolean;
     reset(): void;
-    restrict(p: vec3, t: vec3): { position: vec3, target: vec3 };
+    restrict(p: vec3, t: vec3, s?: vec2): { position: vec3, target: vec3, sceneRotation?: vec2 };
     update(time: number, manualInteraction: boolean): void
+
+    // #endregion Public Methods (4)
 }

package/src/interfaces/controls/IPerspectiveCameraControls.ts

@@ -1,16 +1,21 @@
-import { vec3 } from 'gl-matrix'
+import { vec3 } from 'gl-matrix';
 
-import { ICameraControls } from './ICameraControls'
+import { ICameraControls } from './ICameraControls';
 
 export interface IPerspectiveCameraControls extends ICameraControls {
+    // #region Properties (23)
+
     autoRotationSpeed: number;
     cubePositionRestriction: { min: vec3, max: vec3 };
     cubeTargetRestriction: { min: vec3, max: vec3 };
     damping: number;
     enableAutoRotation: boolean;
+    enableAzimuthRotation: boolean;
     enableKeyPan: boolean;
     enablePan: boolean;
+    enablePolarRotation: boolean;
     enableRotation: boolean;
+    enableTurntableControls: 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;
@@ -20,6 +25,9 @@ export interface IPerspectiveCameraControls extends ICameraControls {
     rotationSpeed: number;
     spherePositionRestriction: { center: vec3, radius: number };
     sphereTargetRestriction: { center: vec3, radius: number };
+    turntableCenter: vec3;
     zoomRestriction: { minDistance: number, maxDistance: number };
     zoomSpeed: number;
+
+    // #endregion Properties (23)
 }