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

package/src/implementation/controls/AbstractCameraControls.ts

@@ -1,20 +1,35 @@
-import { mat4, vec2, vec3 } from 'gl-matrix';
-import { EventEngine, EVENTTYPE } from '@shapediver/viewer.shared.services';
-
-import { CAMERA_TYPE } from '../../interfaces/ICameraEngine';
-import { ICamera, ICameraOptions } from '../../interfaces/camera/ICamera';
-import { ICameraControlsUsage } from '../../interfaces/controls/ICameraControlsUsage';
 import { CameraInterpolationManager } from '../interpolation/CameraInterpolationManager';
+import { Converter, EventEngine, EVENTTYPE, SettingsEngine } from '@shapediver/viewer.shared.services';
+import { ICamera, ICameraOptions } from '../../interfaces/camera/ICamera';
+import { ICameraControls } from '../../interfaces/controls/ICameraControls';
 import { ICameraControlsEventDistribution } from '../../interfaces/controls/ICameraControlsEventDistribution';
 import { ICameraControlsLogic } from '../../interfaces/controls/ICameraControlsLogic';
+import { mat4, vec2, vec3 } from 'gl-matrix';
+import { ICameraControlsSettings } from '@shapediver/viewer.settings';
 
-export class AbstractCameraControls implements ICameraControlsUsage {
-    // #region Properties (15)
+export abstract class AbstractCameraControls implements ICameraControls {
+    // #region Properties (38)
 
     private readonly _cameraInterpolationManager: CameraInterpolationManager;
+    private readonly _converter: Converter = Converter.instance;
     private readonly _eventEngine: EventEngine = EventEngine.instance;
 
+    private _autoRotationSpeed: number = 0;
     private _canvas?: HTMLCanvasElement;
+    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 _enableObjectControls: 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: 2 }, };
+    private _keyPanSpeed: number = 0.5;
     private _manualInteraction: boolean = false;
     private _manualInteractionTransformations: {
         position: {
@@ -30,6 +45,7 @@ export class AbstractCameraControls implements ICameraControlsUsage {
             phi: number
         }[]
     };
+    private _movementSmoothness: number = 0.5;
     private _moving: boolean = false;
     private _movingDuration: number = 0;
     private _nonmanualInteraction: boolean = false;
@@ -47,22 +63,30 @@ export class AbstractCameraControls implements ICameraControlsUsage {
             phi: number
         }[]
     };
+    private _objectControlsCenter: vec3 = vec3.create();
+    private _panSpeed: number = 0.5;
     private _position: vec3 = vec3.create();
+    private _rotationRestriction: { minPolarAngle: number, maxPolarAngle: number, minAzimuthAngle: number, maxAzimuthAngle: number } = { minPolarAngle: 0, maxPolarAngle: 180, minAzimuthAngle: -Infinity, maxAzimuthAngle: Infinity };
+    private _rotationSpeed: number = 0.5;
     private _sceneRotation: vec2 = vec2.create();
+    private _spherePositionRestriction: { center: vec3, radius: number } = { center: vec3.create(), radius: Infinity };
+    private _sphereTargetRestriction: { center: vec3, radius: number } = { center: vec3.create(), radius: Infinity };
     private _target: vec3 = vec3.create();
+    private _turntableCenter: vec3 = vec3.create();
     private _viewportId?: string;
+    private _zoomRestriction: { minDistance: number, maxDistance: number } = { minDistance: 0, maxDistance: Infinity };
+    private _zoomSpeed: number = 0.5;
 
     protected _cameraControlsEventDistribution!: ICameraControlsEventDistribution;
     protected _cameraLogic!: ICameraControlsLogic;
 
-    // #endregion Properties (15)
+    // #endregion Properties (38)
 
     // #region Constructors (1)
 
     constructor(
         private _camera: ICamera,
-        private _enabled: boolean,
-        type: CAMERA_TYPE
+        private _enabled: boolean
     ) {
         this._cameraInterpolationManager = new CameraInterpolationManager(this._camera, this);
         this._manualInteractionTransformations = { position: [], target: [], sceneRotation: [] };
@@ -71,7 +95,15 @@ export class AbstractCameraControls implements ICameraControlsUsage {
 
     // #endregion Constructors (1)
 
-    // #region Public Accessors (13)
+    // #region Public Getters And Setters (59)
+
+    public get autoRotationSpeed(): number {
+        return this._autoRotationSpeed;
+    }
+
+    public set autoRotationSpeed(value: number) {
+        this._autoRotationSpeed = value;
+    }
 
     public get camera(): ICamera {
         return this._camera;
@@ -93,6 +125,102 @@ export class AbstractCameraControls implements ICameraControlsUsage {
         this._canvas = value;
     }
 
+    public get cubePositionRestriction(): { min: vec3, max: vec3 } {
+        return this._cubePositionRestriction;
+    }
+
+    public set cubePositionRestriction(value: { min: vec3, max: vec3 }) {
+        this._cubePositionRestriction = value;
+    }
+
+    public get cubeTargetRestriction(): { min: vec3, max: vec3 } {
+        return this._cubeTargetRestriction;
+    }
+
+    public set cubeTargetRestriction(value: { min: vec3, max: vec3 }) {
+        this._cubeTargetRestriction = value;
+    }
+
+    public get damping(): number {
+        return this._damping;
+    }
+
+    public set damping(value: number) {
+        this._damping = value;
+    }
+
+    public get enableAutoRotation(): boolean {
+        return this._enableAutoRotation;
+    }
+
+    public set enableAutoRotation(value: boolean) {
+        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;
+    }
+
+    public set enableKeyPan(value: boolean) {
+        this._enableKeyPan = value;
+    }
+
+    public get enableObjectControls(): boolean {
+        return this._enableObjectControls;
+    }
+
+    public set enableObjectControls(value: boolean) {
+        this._enableObjectControls = value;
+    }
+
+    public get enablePan(): boolean {
+        return this._enablePan;
+    }
+
+    public set enablePan(value: boolean) {
+        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;
+    }
+
+    public set enableRotation(value: boolean) {
+        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;
+    }
+
+    public set enableZoom(value: boolean) {
+        this._enableZoom = value;
+    }
+
     public get enabled(): boolean {
         return this._enabled;
     }
@@ -110,6 +238,46 @@ export class AbstractCameraControls implements ICameraControlsUsage {
         this._enabled = value;
     }
 
+    public get input(): { keys: { up: number, down: number, left: number, right: number }, mouse: { rotate: number, zoom: number, pan: number }, touch: { rotate: number, zoom: number, pan: number } } {
+        return this._input;
+    }
+
+    public set input(value: { keys: { up: number, down: number, left: number, right: number }, mouse: { rotate: number, zoom: number, pan: number }, touch: { rotate: number, zoom: number, pan: number } }) {
+        this._input = value;
+    }
+
+    public get keyPanSpeed(): number {
+        return this._keyPanSpeed;
+    }
+
+    public set keyPanSpeed(value: number) {
+        this._keyPanSpeed = value;
+    }
+
+    public get movementSmoothness(): number {
+        return this._movementSmoothness;
+    }
+
+    public set movementSmoothness(value: number) {
+        this._movementSmoothness = value;
+    }
+
+    public get objectControlsCenter(): vec3 {
+        return this._objectControlsCenter;
+    }
+
+    public set objectControlsCenter(value: vec3) {
+        this._objectControlsCenter = value;
+    }
+
+    public get panSpeed(): number {
+        return this._panSpeed;
+    }
+
+    public set panSpeed(value: number) {
+        this._panSpeed = value;
+    }
+
     public get position(): vec3 {
         return this._position;
     }
@@ -118,6 +286,22 @@ export class AbstractCameraControls implements ICameraControlsUsage {
         this._position = value;
     }
 
+    public get rotationRestriction(): { minPolarAngle: number, maxPolarAngle: number, minAzimuthAngle: number, maxAzimuthAngle: number } {
+        return this._rotationRestriction;
+    }
+
+    public set rotationRestriction(value: { minPolarAngle: number, maxPolarAngle: number, minAzimuthAngle: number, maxAzimuthAngle: number }) {
+        this._rotationRestriction = value;
+    }
+
+    public get rotationSpeed(): number {
+        return this._rotationSpeed;
+    }
+
+    public set rotationSpeed(value: number) {
+        this._rotationSpeed = value;
+    }
+
     public get sceneRotation(): vec2 {
         return this._sceneRotation;
     }
@@ -126,6 +310,22 @@ export class AbstractCameraControls implements ICameraControlsUsage {
         this._sceneRotation = value;
     }
 
+    public get spherePositionRestriction(): { center: vec3, radius: number } {
+        return this._spherePositionRestriction;
+    }
+
+    public set spherePositionRestriction(value: { center: vec3, radius: number }) {
+        this._spherePositionRestriction = value;
+    }
+
+    public get sphereTargetRestriction(): { center: vec3, radius: number } {
+        return this._sphereTargetRestriction;
+    }
+
+    public set sphereTargetRestriction(value: { center: vec3, radius: number }) {
+        this._sphereTargetRestriction = value;
+    }
+
     public get target(): vec3 {
         return this._target;
     }
@@ -134,7 +334,31 @@ export class AbstractCameraControls implements ICameraControlsUsage {
         this._target = value;
     }
 
-    // #endregion Public Accessors (13)
+    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;
+    }
+
+    public set zoomRestriction(value: { minDistance: number, maxDistance: number }) {
+        this._zoomRestriction = value;
+    }
+
+    public get zoomSpeed(): number {
+        return this._zoomSpeed;
+    }
+
+    public set zoomSpeed(value: number) {
+        this._zoomSpeed = value;
+    }
+
+    // #endregion Public Getters And Setters (59)
 
     // #region Public Methods (16)
 
@@ -180,6 +404,71 @@ export class AbstractCameraControls implements ICameraControlsUsage {
         }
     }
 
+    
+    public applySettings(settingsEngine: SettingsEngine) {
+        const cameraSetting = settingsEngine.camera.cameras[this.camera.id];
+        if (!cameraSetting) return;
+        this.reset();
+        const controlsSettings = <ICameraControlsSettings>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;
+
+        this.enableAzimuthRotation = controlsSettings.enableAzimuthRotation;
+        this.enablePolarRotation = controlsSettings.enablePolarRotation;
+        this.enableTurntableControls = controlsSettings.enableTurntableControls;
+        this.enableObjectControls = controlsSettings.enableObjectControls;
+        this.turntableCenter = this._converter.toVec3(controlsSettings.turntableCenter);
+        this.objectControlsCenter = this._converter.toVec3(controlsSettings.objectControlsCenter);
+
+        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;
+    }
+
     public applyTargetMatrix(matrix: mat4, manualInteraction?: boolean | undefined): void {
         if (this._manualInteraction || manualInteraction) {
             this._manualInteraction = true;
@@ -267,7 +556,7 @@ export class AbstractCameraControls implements ICameraControlsUsage {
         if (this._manualInteraction === true && this._cameraInterpolationManager.active())
             this._cameraInterpolationManager.stop();
 
-        const { position, target, sceneRotation } = this._cameraLogic.restrict(this.getPosition(), this.getTarget(), this.getSceneRotation());
+        const { position , target, sceneRotation } = this._cameraLogic.restrict(this.getPosition(), this.getTarget(), this.getSceneRotation());
         this._position = vec3.clone(position);
         this._target = vec3.clone(target);
         this._sceneRotation = sceneRotation ? vec2.clone(sceneRotation) : vec2.create();