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

package/src/implementation/controls/PerspectiveCameraControls.ts

@@ -1,28 +1,34 @@
-import { IOrbitControlsSettingsV3 } from '@shapediver/viewer.settings'
-import { SettingsEngine, StateEngine, Converter } from '@shapediver/viewer.shared.services'
-import { vec3 } from 'gl-matrix'
+import { IOrbitControlsSettingsV3 } from '@shapediver/viewer.settings';
+import { SettingsEngine, StateEngine, Converter } from '@shapediver/viewer.shared.services';
+import { vec3 } from 'gl-matrix';
 
-import { CAMERA_TYPE, ICamera } from '../..'
-import { IPerspectiveCameraControls } from '../../interfaces/controls/IPerspectiveCameraControls'
-import { AbstractCameraControls } from './AbstractCameraControls'
+import { CAMERA_TYPE, ICamera } from '../..';
+import { IPerspectiveCameraControls } from '../../interfaces/controls/IPerspectiveCameraControls';
+import { AbstractCameraControls } from './AbstractCameraControls';
 import {
-  CameraControlsEventDistribution as OrbitCameraControlsEventDistribution,
-} from './perspective/CameraControlsEventDistribution'
-import { CameraControlsLogic as OrbitCameraControlsLogic } from './perspective/CameraControlsLogic'
+    CameraControlsEventDistribution as OrbitCameraControlsEventDistribution,
+} from './perspective/CameraControlsEventDistribution';
+import { CameraControlsLogic as OrbitCameraControlsLogic } from './perspective/CameraControlsLogic';
 
 export class PerspectiveCameraControls extends AbstractCameraControls implements IPerspectiveCameraControls {
-    // #region Properties (19)
+    // #region Properties (25)
+
+    private readonly _converter: Converter = Converter.instance;
+    private readonly _stateEngine: StateEngine = StateEngine.instance;
 
     private _autoRotationSpeed: number = 0;
     private _cubePositionRestriction: { min: vec3, max: vec3 } = { min: vec3.fromValues(-Infinity, -Infinity, -Infinity), max: vec3.fromValues(Infinity, Infinity, Infinity) };
     private _cubeTargetRestriction: { min: vec3, max: vec3 } = { min: vec3.fromValues(-Infinity, -Infinity, -Infinity), max: vec3.fromValues(Infinity, Infinity, Infinity) };
     private _damping: number = 0.1;
     private _enableAutoRotation: boolean = false;
+    private _enableAzimuthRotation: boolean = true;
     private _enableKeyPan: boolean = false;
     private _enablePan: boolean = true;
+    private _enablePolarRotation: boolean = true;
     private _enableRotation: boolean = true;
+    private _enableTurntableControls: boolean = false;
     private _enableZoom: boolean = true;
-    private _input: { keys: { up: number, down: number, left: number, right: number }, mouse: { rotate: number, zoom: number, pan: number }, touch: { rotate: number, zoom: number, pan: number } } = { keys: { up: 38, down: 40, left: 37, right: 39 }, mouse: { rotate: 0, zoom: 1, pan: 2 }, touch: { rotate: 1, zoom: 2, pan: 3 }, };
+    private _input: { keys: { up: number, down: number, left: number, right: number }, mouse: { rotate: number, zoom: number, pan: number }, touch: { rotate: number, zoom: number, pan: number } } = { keys: { up: 38, down: 40, left: 37, right: 39 }, mouse: { rotate: 0, zoom: 1, pan: 2 }, touch: { rotate: 1, zoom: 2, pan: 2 }, };
     private _keyPanSpeed: number = 0.5;
     private _movementSmoothness: number = 0.5;
     private _panSpeed: number = 0.5;
@@ -30,12 +36,11 @@ export class PerspectiveCameraControls extends AbstractCameraControls implements
     private _rotationSpeed: number = 0.5;
     private _spherePositionRestriction: { center: vec3, radius: number } = { center: vec3.create(), radius: Infinity };
     private _sphereTargetRestriction: { center: vec3, radius: number } = { center: vec3.create(), radius: Infinity };
+    private _turntableCenter: vec3 = vec3.create();
     private _zoomRestriction: { minDistance: number, maxDistance: number } = { minDistance: 0, maxDistance: Infinity };
     private _zoomSpeed: number = 0.5;
-    private readonly _converter: Converter = Converter.instance;
-    private readonly _stateEngine: StateEngine = StateEngine.instance;
 
-    // #endregion Properties (19)
+    // #endregion Properties (25)
 
     // #region Constructors (1)
 
@@ -45,66 +50,9 @@ export class PerspectiveCameraControls extends AbstractCameraControls implements
         this._cameraControlsEventDistribution = new OrbitCameraControlsEventDistribution(this, <OrbitCameraControlsLogic>this._cameraLogic);
     }
 
-    public applySettings(settingsEngine: SettingsEngine) {
-        const cameraSetting = settingsEngine.camera.cameras[this.camera.id];
-        if(!cameraSetting) return;
-        this.reset();
-        const controlsSettings = <IOrbitControlsSettingsV3>cameraSetting.controls;
-        this.autoRotationSpeed = controlsSettings.autoRotationSpeed;
-        this.damping = controlsSettings.damping;
-        this.enableAutoRotation = controlsSettings.enableAutoRotation;
-        this.enableKeyPan = controlsSettings.enableKeyPan;
-        this.enablePan = controlsSettings.enablePan;
-        this.enableRotation = controlsSettings.enableRotation;
-        this.enableZoom = controlsSettings.enableZoom;
-        this.input = controlsSettings.input;
-        this.keyPanSpeed = controlsSettings.keyPanSpeed;
-        this.movementSmoothness = controlsSettings.movementSmoothness;
-        this.rotationSpeed = controlsSettings.rotationSpeed;
-        this.panSpeed = controlsSettings.panSpeed;
-        this.zoomSpeed = controlsSettings.zoomSpeed;
-
-        if(controlsSettings.restrictions.position.cube.min.x === null) controlsSettings.restrictions.position.cube.min.x = -Infinity;
-        if(controlsSettings.restrictions.position.cube.min.y === null) controlsSettings.restrictions.position.cube.min.y = -Infinity;
-        if(controlsSettings.restrictions.position.cube.min.z === null) controlsSettings.restrictions.position.cube.min.z = -Infinity;
-        if(controlsSettings.restrictions.position.cube.max.x === null) controlsSettings.restrictions.position.cube.max.x = Infinity;
-        if(controlsSettings.restrictions.position.cube.max.y === null) controlsSettings.restrictions.position.cube.max.y = Infinity;
-        if(controlsSettings.restrictions.position.cube.max.z === null) controlsSettings.restrictions.position.cube.max.z = Infinity;
-        if(controlsSettings.restrictions.position.sphere.radius === null) controlsSettings.restrictions.position.sphere.radius = Infinity;
-        if(controlsSettings.restrictions.target.cube.min.x === null) controlsSettings.restrictions.target.cube.min.x = -Infinity;
-        if(controlsSettings.restrictions.target.cube.min.y === null) controlsSettings.restrictions.target.cube.min.y = -Infinity;
-        if(controlsSettings.restrictions.target.cube.min.z === null) controlsSettings.restrictions.target.cube.min.z = -Infinity;
-        if(controlsSettings.restrictions.target.cube.max.x === null) controlsSettings.restrictions.target.cube.max.x = Infinity;
-        if(controlsSettings.restrictions.target.cube.max.y === null) controlsSettings.restrictions.target.cube.max.y = Infinity;
-        if(controlsSettings.restrictions.target.cube.max.z === null) controlsSettings.restrictions.target.cube.max.z = Infinity;
-        if(controlsSettings.restrictions.target.sphere.radius === null) controlsSettings.restrictions.target.sphere.radius = Infinity;
-        if(controlsSettings.restrictions.rotation.minAzimuthAngle === null) controlsSettings.restrictions.rotation.minAzimuthAngle = -Infinity;
-        if(controlsSettings.restrictions.rotation.maxAzimuthAngle === null) controlsSettings.restrictions.rotation.maxAzimuthAngle = Infinity;
-        if(controlsSettings.restrictions.zoom.maxDistance === null) controlsSettings.restrictions.zoom.maxDistance = Infinity;
-
-        this.cubePositionRestriction = { 
-            min: this._converter.toVec3(controlsSettings.restrictions.position.cube.min),
-            max: this._converter.toVec3(controlsSettings.restrictions.position.cube.max)
-        };
-        this.spherePositionRestriction = { 
-            center: this._converter.toVec3(controlsSettings.restrictions.position.sphere.center),
-            radius: controlsSettings.restrictions.position.sphere.radius
-        };
-        this.cubeTargetRestriction = { 
-            min: this._converter.toVec3(controlsSettings.restrictions.target.cube.min),
-            max: this._converter.toVec3(controlsSettings.restrictions.target.cube.max)
-        };
-        this.sphereTargetRestriction = { 
-            center: this._converter.toVec3(controlsSettings.restrictions.target.sphere.center),
-            radius: controlsSettings.restrictions.target.sphere.radius
-        };
-        this.rotationRestriction = controlsSettings.restrictions.rotation;
-        this.zoomRestriction = controlsSettings.restrictions.zoom;
-    }
-
     // #endregion Constructors (1)
 
-    // #region Public Accessors (38)
+    // #region Public Accessors (46)
 
     public get autoRotationSpeed(): number {
         return this._autoRotationSpeed;
@@ -146,6 +94,14 @@ export class PerspectiveCameraControls extends AbstractCameraControls implements
         this._enableAutoRotation = value;
     }
 
+    public get enableAzimuthRotation(): boolean {
+        return this._enableAzimuthRotation;
+    }
+
+    public set enableAzimuthRotation(value: boolean) {
+        this._enableAzimuthRotation = value;
+    }
+
     public get enableKeyPan(): boolean {
         return this._enableKeyPan;
     }
@@ -162,6 +118,14 @@ export class PerspectiveCameraControls extends AbstractCameraControls implements
         this._enablePan = value;
     }
 
+    public get enablePolarRotation(): boolean {
+        return this._enablePolarRotation;
+    }
+
+    public set enablePolarRotation(value: boolean) {
+        this._enablePolarRotation = value;
+    }
+
     public get enableRotation(): boolean {
         return this._enableRotation;
     }
@@ -170,6 +134,14 @@ export class PerspectiveCameraControls extends AbstractCameraControls implements
         this._enableRotation = value;
     }
 
+    public get enableTurntableControls(): boolean {
+        return this._enableTurntableControls;
+    }
+
+    public set enableTurntableControls(value: boolean) {
+        this._enableTurntableControls = value;
+    }
+
     public get enableZoom(): boolean {
         return this._enableZoom;
     }
@@ -242,6 +214,14 @@ export class PerspectiveCameraControls extends AbstractCameraControls implements
         this._sphereTargetRestriction = value;
     }
 
+    public get turntableCenter(): vec3 {
+        return this._turntableCenter;
+    }
+
+    public set turntableCenter(value: vec3) {
+        this._turntableCenter = value;
+    }
+
     public get zoomRestriction(): { minDistance: number, maxDistance: number } {
         return this._zoomRestriction;
     }
@@ -258,5 +238,66 @@ export class PerspectiveCameraControls extends AbstractCameraControls implements
         this._zoomSpeed = value;
     }
 
-    // #endregion Public Accessors (38)
+    // #endregion Public Accessors (46)
+
+    // #region Public Methods (1)
+
+    public applySettings(settingsEngine: SettingsEngine) {
+        const cameraSetting = settingsEngine.camera.cameras[this.camera.id];
+        if (!cameraSetting) return;
+        this.reset();
+        const controlsSettings = <IOrbitControlsSettingsV3>cameraSetting.controls;
+        this.autoRotationSpeed = controlsSettings.autoRotationSpeed;
+        this.damping = controlsSettings.damping;
+        this.enableAutoRotation = controlsSettings.enableAutoRotation;
+        this.enableKeyPan = controlsSettings.enableKeyPan;
+        this.enablePan = controlsSettings.enablePan;
+        this.enableRotation = controlsSettings.enableRotation;
+        this.enableZoom = controlsSettings.enableZoom;
+        // this.input = controlsSettings.input;
+        this.keyPanSpeed = controlsSettings.keyPanSpeed;
+        this.movementSmoothness = controlsSettings.movementSmoothness;
+        this.rotationSpeed = controlsSettings.rotationSpeed;
+        this.panSpeed = controlsSettings.panSpeed;
+        this.zoomSpeed = controlsSettings.zoomSpeed;
+
+        if (controlsSettings.restrictions.position.cube.min.x === null) controlsSettings.restrictions.position.cube.min.x = -Infinity;
+        if (controlsSettings.restrictions.position.cube.min.y === null) controlsSettings.restrictions.position.cube.min.y = -Infinity;
+        if (controlsSettings.restrictions.position.cube.min.z === null) controlsSettings.restrictions.position.cube.min.z = -Infinity;
+        if (controlsSettings.restrictions.position.cube.max.x === null) controlsSettings.restrictions.position.cube.max.x = Infinity;
+        if (controlsSettings.restrictions.position.cube.max.y === null) controlsSettings.restrictions.position.cube.max.y = Infinity;
+        if (controlsSettings.restrictions.position.cube.max.z === null) controlsSettings.restrictions.position.cube.max.z = Infinity;
+        if (controlsSettings.restrictions.position.sphere.radius === null) controlsSettings.restrictions.position.sphere.radius = Infinity;
+        if (controlsSettings.restrictions.target.cube.min.x === null) controlsSettings.restrictions.target.cube.min.x = -Infinity;
+        if (controlsSettings.restrictions.target.cube.min.y === null) controlsSettings.restrictions.target.cube.min.y = -Infinity;
+        if (controlsSettings.restrictions.target.cube.min.z === null) controlsSettings.restrictions.target.cube.min.z = -Infinity;
+        if (controlsSettings.restrictions.target.cube.max.x === null) controlsSettings.restrictions.target.cube.max.x = Infinity;
+        if (controlsSettings.restrictions.target.cube.max.y === null) controlsSettings.restrictions.target.cube.max.y = Infinity;
+        if (controlsSettings.restrictions.target.cube.max.z === null) controlsSettings.restrictions.target.cube.max.z = Infinity;
+        if (controlsSettings.restrictions.target.sphere.radius === null) controlsSettings.restrictions.target.sphere.radius = Infinity;
+        if (controlsSettings.restrictions.rotation.minAzimuthAngle === null) controlsSettings.restrictions.rotation.minAzimuthAngle = -Infinity;
+        if (controlsSettings.restrictions.rotation.maxAzimuthAngle === null) controlsSettings.restrictions.rotation.maxAzimuthAngle = Infinity;
+        if (controlsSettings.restrictions.zoom.maxDistance === null) controlsSettings.restrictions.zoom.maxDistance = Infinity;
+
+        this.cubePositionRestriction = {
+            min: this._converter.toVec3(controlsSettings.restrictions.position.cube.min),
+            max: this._converter.toVec3(controlsSettings.restrictions.position.cube.max)
+        };
+        this.spherePositionRestriction = {
+            center: this._converter.toVec3(controlsSettings.restrictions.position.sphere.center),
+            radius: controlsSettings.restrictions.position.sphere.radius
+        };
+        this.cubeTargetRestriction = {
+            min: this._converter.toVec3(controlsSettings.restrictions.target.cube.min),
+            max: this._converter.toVec3(controlsSettings.restrictions.target.cube.max)
+        };
+        this.sphereTargetRestriction = {
+            center: this._converter.toVec3(controlsSettings.restrictions.target.sphere.center),
+            radius: controlsSettings.restrictions.target.sphere.radius
+        };
+        this.rotationRestriction = controlsSettings.restrictions.rotation;
+        this.zoomRestriction = controlsSettings.restrictions.zoom;
+    }
+
+    // #endregion Public Methods (1)
 }

package/src/implementation/controls/orthographic/CameraControlsEventDistribution.ts

@@ -1,6 +1,6 @@
-import { CameraControlsLogic } from './CameraControlsLogic'
-import { ICameraControlsEventDistribution } from '../../../interfaces/controls/ICameraControlsEventDistribution'
-import { OrthographicCameraControls } from '../OrthographicCameraControls'
+import { CameraControlsLogic } from './CameraControlsLogic';
+import { ICameraControlsEventDistribution } from '../../../interfaces/controls/ICameraControlsEventDistribution';
+import { OrthographicCameraControls } from '../OrthographicCameraControls';
 
 export class CameraControlsEventDistribution implements ICameraControlsEventDistribution {
     // #region Properties (2)
@@ -9,7 +9,6 @@ export class CameraControlsEventDistribution implements ICameraControlsEventDist
         zoom: false,
         pan: false
     };
-
     private _activeEvents = true;
 
     // #endregion Properties (2)
@@ -20,8 +19,8 @@ export class CameraControlsEventDistribution implements ICameraControlsEventDist
 
     // #endregion Constructors (1)
 
-    // #region Public Methods (14)
-        
+    // #region Public Methods (20)
+
     public activateCameraEvents(): void {
         this._activeEvents = true;
     }
@@ -31,16 +30,17 @@ export class CameraControlsEventDistribution implements ICameraControlsEventDist
     }
 
     public onDown(event: MouseEvent | TouchEvent): void {
-        if(this._controls.camera.active === false) return;
-        let { x, y } = this.convertInput(event);
+        if (this._controls.camera.active === false) return;
+        const { x, y } = this.convertInput(event);
 
-        let input = window.TouchEvent && event instanceof TouchEvent ? (event as TouchEvent).touches.length : (event as MouseEvent).button;
-        let mapping = window.TouchEvent && event instanceof TouchEvent ? this._controls.input.touch : this._controls.input.mouse;
+        const input = window.TouchEvent && event instanceof TouchEvent ? (event as TouchEvent).touches.length : (event as MouseEvent).button;
+        const mapping = window.TouchEvent && event instanceof TouchEvent ? this._controls.input.touch : this._controls.input.mouse;
 
         if (input === mapping.pan && this._controls.enablePan) {
             this._cameraLogic.pan(x, y, this._active.pan, window.TouchEvent && event instanceof TouchEvent);
             this._active.pan = true;
-            this._active.zoom = false;
+        } else {
+            this._active.pan = false;
         }
 
         if (input === mapping.zoom && this._controls.enableZoom) {
@@ -50,13 +50,14 @@ export class CameraControlsEventDistribution implements ICameraControlsEventDist
                 y1 = (event.touches[0].pageY - event.touches[1].pageY) / window.innerHeight;
             }
             this._cameraLogic.zoom(x1, y1, this._active.zoom, window.TouchEvent && event instanceof TouchEvent);
-            this._active.pan = false;
             this._active.zoom = true;
+        } else {
+            this._active.zoom = false;
         }
     }
 
     public onKey(event: KeyboardEvent): void {
-        if(this._controls.camera.active === false) return;
+        if (this._controls.camera.active === false) return;
         if (this._controls.enableKeyPan) {
             switch (event.keyCode) {
                 case this._controls.input.keys.up:
@@ -91,46 +92,46 @@ export class CameraControlsEventDistribution implements ICameraControlsEventDist
     }
 
     public onKeyDown(event: KeyboardEvent): void {
-        if(this._controls.camera.active === false) return;
-        if(!this._activeEvents) return;
-        this.onKey(event)
+        if (this._controls.camera.active === false) return;
+        if (!this._activeEvents) return;
+        this.onKey(event);
     }
 
     public onMouseDown(event: MouseEvent): void {
-        if(this._controls.camera.active === false) return;
-        if(!this._activeEvents) return;
+        if (this._controls.camera.active === false) return;
+        if (!this._activeEvents) return;
         this.onDown(event);
     }
 
-    public onMouseMove(event: MouseEvent): void {
-        if(this._controls.camera.active === false) return;
-        if(!this._activeEvents) return;
-        this.onMove(event);
-    }
-
     public onMouseEnd(event: MouseEvent): void {
-        if(this._controls.camera.active === false) return;
-        if(!this._activeEvents) return;
+        if (this._controls.camera.active === false) return;
+        if (!this._activeEvents) return;
         this.onUp(event);
     }
-    
-    public onMouseUp(event: WheelEvent): void {
-        if(this._controls.camera.active === false) return;
+
+    public onMouseMove(event: MouseEvent): void {
+        if (this._controls.camera.active === false) return;
+        if (!this._activeEvents) return;
+        this.onMove(event);
     }
 
     public onMouseOut(event: WheelEvent): void {
-        if(this._controls.camera.active === false) return;
+        if (this._controls.camera.active === false) return;
+    }
+
+    public onMouseUp(event: WheelEvent): void {
+        if (this._controls.camera.active === false) return;
     }
 
     public onMouseWheel(event: WheelEvent): void {
-        if(this._controls.camera.active === false) return;
-        if(!this._activeEvents) return;
+        if (this._controls.camera.active === false) return;
+        if (!this._activeEvents) return;
         this.onWheel(event);
     }
 
     public onMove(event: MouseEvent | TouchEvent): void {
-        if(this._controls.camera.active === false) return;
-        let { x, y } = this.convertInput(event);
+        if (this._controls.camera.active === false) return;
+        const { x, y } = this.convertInput(event);
 
         if (this._controls.enablePan && this._active.pan)
             this._cameraLogic.pan(x, y, this._active.pan, window.TouchEvent && event instanceof TouchEvent);
@@ -145,40 +146,40 @@ export class CameraControlsEventDistribution implements ICameraControlsEventDist
         }
     }
 
+    public onTouchCancel(event: TouchEvent): void {
+        if (this._controls.camera.active === false) return;
+    }
+
     public onTouchEnd(event: TouchEvent): void {
-        if(this._controls.camera.active === false) return;
-        if(!this._activeEvents) return;
+        if (this._controls.camera.active === false) return;
+        if (!this._activeEvents) return;
         this.onUp(event);
     }
 
     public onTouchMove(event: TouchEvent): void {
-        if(this._controls.camera.active === false) return;
-        if(!this._activeEvents) return;
+        if (this._controls.camera.active === false) return;
+        if (!this._activeEvents) return;
         this.onMove(event);
     }
 
     public onTouchStart(event: TouchEvent): void {
-        if(this._controls.camera.active === false) return;
-        if(!this._activeEvents) return;
+        if (this._controls.camera.active === false) return;
+        if (!this._activeEvents) return;
         this.onDown(event);
     }
 
-    public onTouchCancel(event: TouchEvent): void {
-        if(this._controls.camera.active === false) return;
-    }
-
     public onTouchUp(event: TouchEvent): void {
-        if(this._controls.camera.active === false) return;
+        if (this._controls.camera.active === false) return;
     }
 
     public onUp(event: MouseEvent | TouchEvent): void {
-        if(this._controls.camera.active === false) return;
+        if (this._controls.camera.active === false) return;
         this._active.zoom = false;
         this._active.pan = false;
     }
 
     public onWheel(event: WheelEvent): void {
-        if(this._controls.camera.active === false) return;
+        if (this._controls.camera.active === false) return;
         if (!this._controls.enableZoom) return;
         let delta = 0;
         if (event.deltaY !== undefined) {
@@ -205,23 +206,27 @@ export class CameraControlsEventDistribution implements ICameraControlsEventDist
         };
     }
 
-    // #endregion Public Methods (14)
+    // #endregion Public Methods (20)
 
     // #region Private Methods (1)
 
     private convertInput(event: MouseEvent | TouchEvent): { x: number, y: number } {
-        let aspect = window.innerWidth / window.innerHeight;
         if (event instanceof MouseEvent) {
             return {
-                x: event.clientX / window.innerWidth * aspect,
-                y: event.clientY / window.innerHeight
-            }
+                x: event.clientX,
+                y: event.clientY
+            };
         } else {
-            if(event.touches.length < 1) return { x: 0, y: 0 };
+            if (event.touches.length < 1) return { x: 0, y: 0 };
+            if (event.touches.length === 1)
+                return {
+                    x: event.touches[0].pageX,
+                    y: event.touches[0].pageY
+                };
             return {
-                x: event.touches[0].pageX / window.innerWidth * aspect,
-                y: event.touches[0].pageY / window.innerHeight
-            }
+                x: (event.touches[0].pageX + event.touches[1].pageX) / 2,
+                y: (event.touches[0].pageY + event.touches[1].pageY) / 2
+            };
         }
     }