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

package/src/implementation/CameraEngine.ts

@@ -1,40 +1,39 @@
+import { AbstractCamera } from './camera/AbstractCamera';
+import { Box } from '@shapediver/viewer.shared.math';
+import { CAMERA_TYPE, ICameraEngine } from '../interfaces/ICameraEngine';
+import { ICamera } from '../interfaces/camera/ICamera';
+import { IRenderingEngine } from '@shapediver/viewer.rendering-engine.rendering-engine';
+import { ISceneEvent } from '@shapediver/viewer.shared.types';
 import {
-  DomEventEngine,
-  EventEngine,
-  EVENTTYPE,
-  IEvent,
-  Logger,
-  SettingsEngine,
-  ShapeDiverViewerCameraError,
-  StateEngine,
-  UuidGenerator,
-} from '@shapediver/viewer.shared.services'
-import { Box } from '@shapediver/viewer.shared.math'
-import { vec3 } from 'gl-matrix'
-import { IOrthographicCameraSettingsV3, IPerspectiveCameraSettingsV3 } from '@shapediver/viewer.settings'
-import { ISceneEvent } from '@shapediver/viewer.shared.types'
-import { ITree, ITreeNode, Tree, TreeNode } from '@shapediver/viewer.shared.node-tree'
-
-import { CAMERA_TYPE, ICameraEngine } from '../interfaces/ICameraEngine'
-import { AbstractCamera } from './camera/AbstractCamera'
-import { OrthographicCameraControls } from './controls/OrthographicCameraControls'
-import { PerspectiveCamera } from './camera/PerspectiveCamera'
-import { OrthographicCamera } from './camera/OrthographicCamera'
-import { PerspectiveCameraControls } from './controls/PerspectiveCameraControls'
-import { ORTHOGRAPHIC_CAMERA_DIRECTION } from '../interfaces/camera/IOrthographicCamera'
-import { IRenderingEngine } from '@shapediver/viewer.rendering-engine.rendering-engine'
-import { ICamera } from '../interfaces/camera/ICamera'
+    ITree,
+    ITreeNode,
+    Tree,
+    TreeNode
+} from '@shapediver/viewer.shared.node-tree';
+import { ORTHOGRAPHIC_CAMERA_DIRECTION } from '../interfaces/camera/IOrthographicCamera';
+import { OrthographicCamera } from './camera/OrthographicCamera';
+import { OrthographicCameraControls } from './controls/OrthographicCameraControls';
+import { PerspectiveCamera } from './camera/PerspectiveCamera';
+import { PerspectiveCameraControls } from './controls/PerspectiveCameraControls';
+import { vec3 } from 'gl-matrix';
+import {
+    EventEngine,
+    EVENTTYPE,
+    IEvent,
+    Logger,
+    SettingsEngine,
+    ShapeDiverViewerCameraError,
+    StateEngine,
+    UuidGenerator,
+} from '@shapediver/viewer.shared.services';
 
 export class CameraEngine implements ICameraEngine {
-    // #region Properties (10)
+    // #region Properties (11)
 
+    private readonly _cameraNode: ITreeNode = new TreeNode('cameras');
     private readonly _cameras: {
         [key: string]: ICamera
     } = {};
-    private readonly _camerasDomEventListenerToken: {
-        [key: string]: string
-    } = {};
-    private readonly _cameraNode: ITreeNode = new TreeNode('cameras');
     private readonly _eventEngine: EventEngine = EventEngine.instance;
     private readonly _logger: Logger = Logger.instance;
     private readonly _stateEngine: StateEngine = StateEngine.instance;
@@ -43,25 +42,25 @@ export class CameraEngine implements ICameraEngine {
 
     private _camera: ICamera | null = null;
     private _settingsApplied: boolean = false;
+    private _update?: () => void;
 
     protected _boundingBox: Box = new Box();
-    private _update?: () => void;
 
-    // #endregion Properties (10)
+    // #endregion Properties (11)
 
     // #region Constructors (1)
 
-    constructor(private readonly _renderingEngine: IRenderingEngine, private readonly _canvas: HTMLCanvasElement) {
+    constructor(private readonly _renderingEngine: IRenderingEngine) {
         this._tree.root.addChild(this._cameraNode);
         this._cameraNode.restrictViewports = [this._renderingEngine.id];
-        
+
         this._eventEngine.addListener(EVENTTYPE.SCENE.SCENE_BOUNDING_BOX_CHANGE, (e: IEvent) => {
             const viewerEvent = <ISceneEvent>e;
             if (viewerEvent.viewportId === this._renderingEngine.id) {
                 this._boundingBox = new Box(viewerEvent.boundingBox!.min, viewerEvent.boundingBox!.max);
 
                 const cameras = this.cameras;
-                for (let c in cameras)
+                for (const c in cameras)
                     cameras[c].boundingBox = this._boundingBox.clone();
             }
         });
@@ -76,7 +75,7 @@ export class CameraEngine implements ICameraEngine {
 
     // #endregion Constructors (1)
 
-    // #region Public Accessors (2)
+    // #region Public Getters And Setters (4)
 
     public get camera(): ICamera | null {
         return this._camera;
@@ -87,7 +86,7 @@ export class CameraEngine implements ICameraEngine {
     } {
         return this._cameras;
     }
-    
+
     public get update(): (() => void) | undefined {
         return this._update;
     }
@@ -96,24 +95,24 @@ export class CameraEngine implements ICameraEngine {
         this._update = value;
     }
 
-    // #endregion Public Accessors (2)
+    // #endregion Public Getters And Setters (4)
 
-    // #region Public Methods (7)
+    // #region Public Methods (8)
 
     public activateCameraEvents(): void {
         const cameras = this.cameras;
-        for(let c in cameras)
+        for (const c in cameras)
             (<PerspectiveCameraControls | OrthographicCameraControls>cameras[c].controls).cameraControlsEventDistribution.activateCameraEvents();
     }
 
     public applySettings(settingsEngine: SettingsEngine) {
         const cameras = this.cameras;
-        for (let c in cameras)
+        for (const c in cameras)
             this.removeCamera(c);
 
-        for(let id in settingsEngine.settings.camera.cameras) {
+        for (const id in settingsEngine.settings.camera.cameras) {
             const cameraSetting = settingsEngine.settings.camera.cameras[id];
-            if(cameraSetting.type === 'perspective') {
+            if (cameraSetting.type === 'perspective') {
                 this.createCamera(CAMERA_TYPE.PERSPECTIVE, id);
             } else {
                 const camera = this.createCamera(CAMERA_TYPE.ORTHOGRAPHIC, id);
@@ -121,13 +120,13 @@ export class CameraEngine implements ICameraEngine {
             }
         }
 
-        for (let c in cameras)
+        for (const c in cameras)
             cameras[c].applySettings(settingsEngine);
 
         const cameraKeys = Object.keys(settingsEngine.settings.camera.cameras);
 
-        if(cameraKeys.length > 0) {
-            if(!settingsEngine.settings.camera.cameraId) {
+        if (cameraKeys.length > 0) {
+            if (!settingsEngine.settings.camera.cameraId) {
                 this.assignCamera(cameraKeys[0]);
             } else {
                 this.assignCamera(settingsEngine.settings.camera.cameraId);
@@ -138,14 +137,14 @@ export class CameraEngine implements ICameraEngine {
         }
 
         this._settingsApplied = true;
-        if(this._update) this._update();
+        if (this._update) this._update();
     }
 
     public assignCamera(id: string): boolean {
         const camera = this.cameras[id];
         if (!camera) return false;
 
-        for (let c in this.cameras)
+        for (const c in this.cameras)
             this.cameras[c].active = false;
 
         this._camera = camera;
@@ -156,10 +155,10 @@ export class CameraEngine implements ICameraEngine {
     public createCamera(type: CAMERA_TYPE, id?: string): ICamera {
         const cameras = this.cameras;
         const cameraId = id || this._uuidGenerator.create();
-        if (cameras[cameraId]) 
+        if (cameras[cameraId])
             throw new ShapeDiverViewerCameraError(`CameraEngine.createCamera: Camera (${type}) with this id (${cameraId}) already exists.`);
-        
-        const initialAspectRatio =  (<HTMLDivElement>this._renderingEngine.canvas.parentNode).clientWidth / (<HTMLDivElement>this._renderingEngine.canvas.parentNode).clientHeight;
+
+        const initialAspectRatio = (<HTMLDivElement>this._renderingEngine.canvas.parentNode).clientWidth / (<HTMLDivElement>this._renderingEngine.canvas.parentNode).clientHeight;
         const camera = CAMERA_TYPE.PERSPECTIVE === type ? new PerspectiveCamera(cameraId, undefined, initialAspectRatio) : new OrthographicCamera(cameraId);
         camera.assignViewer(this._renderingEngine);
 
@@ -171,7 +170,7 @@ export class CameraEngine implements ICameraEngine {
         }
 
         this._cameraNode.addData(camera);
-        if(this._update) this._update();
+        if (this._update) this._update();
         return camera;
     }
 
@@ -188,13 +187,14 @@ export class CameraEngine implements ICameraEngine {
         frontCamera.direction = ORTHOGRAPHIC_CAMERA_DIRECTION.FRONT;
         const backCamera = <OrthographicCamera>this.createCamera(CAMERA_TYPE.ORTHOGRAPHIC, 'back');
         backCamera.direction = ORTHOGRAPHIC_CAMERA_DIRECTION.BACK;
+        this.createCamera(CAMERA_TYPE.ORTHOGRAPHIC, 'orthographic');
         const camera = this.createCamera(CAMERA_TYPE.PERSPECTIVE, 'perspective');
         this.assignCamera(camera.id);
     }
 
     public deactivateCameraEvents(): void {
         const cameras = this.cameras;
-        for (let c in cameras)
+        for (const c in cameras)
             (<PerspectiveCameraControls | OrthographicCameraControls>cameras[c].controls).cameraControlsEventDistribution.deactivateCameraEvents();
     }
 
@@ -202,14 +202,13 @@ export class CameraEngine implements ICameraEngine {
         const cameras = this.cameras;
         const camera = cameras[id];
         if (!camera) return false;
-        this._renderingEngine.domEventEngine.removeDomEventListener(this._camerasDomEventListenerToken[id])
+        if (camera.domEventListenerToken) this._renderingEngine.domEventEngine.removeDomEventListener(camera.domEventListenerToken);
         if (this._camera && this._camera.id === id)
             this._camera = null;
 
         delete cameras[id];
-        delete this._camerasDomEventListenerToken[id];
         this._cameraNode.removeData(camera);
-        if(this._update) this._update();
+        if (this._update) this._update();
         return true;
     }
 
@@ -217,7 +216,7 @@ export class CameraEngine implements ICameraEngine {
         settingsEngine.settings.camera.cameraId = this._camera ? this._camera.id : 'perspective';
         settingsEngine.settings.camera.cameras = {};
 
-        for (let c in this.cameras) {
+        for (const c in this.cameras) {
             const camera = this.cameras[c];
 
             if (camera.type === CAMERA_TYPE.PERSPECTIVE) {
@@ -234,6 +233,7 @@ export class CameraEngine implements ICameraEngine {
                     target: { x: camera.defaultTarget[0], y: camera.defaultTarget[1], z: camera.defaultTarget[2] },
                     type: camera.type,
                     fov: (<PerspectiveCamera>camera).fov,
+                    sceneRotation: { x: (<PerspectiveCamera>camera).sceneRotation[0], y: (<PerspectiveCamera>camera).sceneRotation[1] },
                     controls: {
                         autoRotationSpeed: controls.autoRotationSpeed,
                         damping: controls.damping,
@@ -271,14 +271,20 @@ export class CameraEngine implements ICameraEngine {
                             },
                             rotation: controls.rotationRestriction,
                             zoom: controls.zoomRestriction,
-                        }
+                        },
+                        enableAzimuthRotation: controls.enableAzimuthRotation,
+                        enablePolarRotation: controls.enablePolarRotation,
+                        enableObjectControls: controls.enableObjectControls,
+                        enableTurntableControls: controls.enableTurntableControls,
+                        turntableCenter: { x: controls.turntableCenter[0], y: controls.turntableCenter[1], z: controls.turntableCenter[2] },
+                        objectControlsCenter: { x: controls.objectControlsCenter[0], y: controls.objectControlsCenter[1], z: controls.objectControlsCenter[2] },
                     }
-                }
-    
+                };
+
             } else {
                 if (settingsEngine.camera.cameras[camera.id]) {
                     const previousDirection = settingsEngine.camera.cameras[camera.id].type;
-    
+
                     // if the direction changed, but the default position & target did not, there is an issue
                     if (previousDirection !== camera.type && (
                         settingsEngine.camera.cameras[camera.id].position.x === camera.defaultPosition[0] &&
@@ -293,7 +299,7 @@ export class CameraEngine implements ICameraEngine {
                     }
                 }
                 const controls = <OrthographicCameraControls>(<OrthographicCamera>camera).controls;
-    
+
                 settingsEngine.camera.cameras[camera.id] = {
                     name: camera.name,
                     autoAdjust: camera.autoAdjust,
@@ -305,40 +311,75 @@ export class CameraEngine implements ICameraEngine {
                     position: { x: camera.defaultPosition[0], y: camera.defaultPosition[1], z: camera.defaultPosition[2] },
                     target: { x: camera.defaultTarget[0], y: camera.defaultTarget[1], z: camera.defaultTarget[2] },
                     type: (<OrthographicCamera>camera).direction,
+                    sceneRotation: { x: (<OrthographicCamera>camera).sceneRotation[0], y: (<OrthographicCamera>camera).sceneRotation[1] },
                     controls: {
+                        autoRotationSpeed: controls.autoRotationSpeed,
                         damping: controls.damping,
+                        enableAutoRotation: controls.enableAutoRotation,
                         enableKeyPan: controls.enableKeyPan,
                         enablePan: controls.enablePan,
+                        enableRotation: controls.enableRotation,
                         enableZoom: controls.enableZoom,
                         input: controls.input,
                         keyPanSpeed: controls.keyPanSpeed,
                         movementSmoothness: controls.movementSmoothness,
+                        rotationSpeed: controls.rotationSpeed,
                         panSpeed: controls.panSpeed,
                         zoomSpeed: controls.zoomSpeed,
+                        restrictions: {
+                            position: {
+                                cube: {
+                                    min: { x: controls.cubePositionRestriction.min[0], y: controls.cubePositionRestriction.min[1], z: controls.cubePositionRestriction.min[2] },
+                                    max: { x: controls.cubePositionRestriction.max[0], y: controls.cubePositionRestriction.max[1], z: controls.cubePositionRestriction.max[2] },
+                                },
+                                sphere: {
+                                    center: { x: controls.spherePositionRestriction.center[0], y: controls.spherePositionRestriction.center[1], z: controls.spherePositionRestriction.center[2] },
+                                    radius: controls.spherePositionRestriction.radius,
+                                },
+                            },
+                            target: {
+                                cube: {
+                                    min: { x: controls.cubeTargetRestriction.min[0], y: controls.cubeTargetRestriction.min[1], z: controls.cubeTargetRestriction.min[2] },
+                                    max: { x: controls.cubeTargetRestriction.max[0], y: controls.cubeTargetRestriction.max[1], z: controls.cubeTargetRestriction.max[2] },
+                                },
+                                sphere: {
+                                    center: { x: controls.sphereTargetRestriction.center[0], y: controls.sphereTargetRestriction.center[1], z: controls.sphereTargetRestriction.center[2] },
+                                    radius: controls.sphereTargetRestriction.radius,
+                                },
+                            },
+                            rotation: controls.rotationRestriction,
+                            zoom: controls.zoomRestriction,
+                        },
+                        enableAzimuthRotation: controls.enableAzimuthRotation,
+                        enablePolarRotation: controls.enablePolarRotation,
+                        enableObjectControls: controls.enableObjectControls,
+                        enableTurntableControls: controls.enableTurntableControls,
+                        turntableCenter: { x: controls.turntableCenter[0], y: controls.turntableCenter[1], z: controls.turntableCenter[2] },
+                        objectControlsCenter: { x: controls.objectControlsCenter[0], y: controls.objectControlsCenter[1], z: controls.objectControlsCenter[2] },
                     }
-                }
+                };
             }
         }
     }
 
-    // #endregion Public Methods (7)
-    
+    // #endregion Public Methods (8)
+
     // #region Private Methods (1)
 
     private searchForNewCameras() {
         const getCameraData = (node: ITreeNode) => {
-            for(let i = 0; i < node.data.length; i++)
-                if((node.data[i] instanceof AbstractCamera) && !this._cameras[node.data[i].id]) {
+            for (let i = 0; i < node.data.length; i++)
+                if ((node.data[i] instanceof AbstractCamera) && !this._cameras[node.data[i].id]) {
                     const camera = <AbstractCamera>node.data[i];
-                    if(camera.viewportId === this._renderingEngine.id)
+                    if (camera.viewportId === this._renderingEngine.id)
                         this._cameras[camera.id] = camera;
                 }
 
-            for(let i = 0; i < node.children.length; i++)
+            for (let i = 0; i < node.children.length; i++)
                 getCameraData(node.children[i]);
         };
         getCameraData(this._tree.root);
-        if(this._update) this._update();
+        if (this._update) this._update();
     }
 
     // #endregion Private Methods (1)

package/src/implementation/camera/AbstractCamera.ts

@@ -1,4 +1,10 @@
 import * as detectIt from 'detect-it';
+import { AbstractTreeNodeData, ITreeNode } from '@shapediver/viewer.shared.node-tree';
+import { Box, IBox } from '@shapediver/viewer.shared.math';
+import { CAMERA_TYPE } from '../../interfaces/ICameraEngine';
+import { ICamera, ICameraOptions } from '../../interfaces/camera/ICamera';
+import { ICameraControls } from '../../interfaces/controls/ICameraControls';
+import { IRenderingEngine } from '@shapediver/viewer.rendering-engine.rendering-engine';
 import { vec2, vec3 } from 'gl-matrix';
 import {
     EventEngine,
@@ -6,22 +12,16 @@ import {
     SettingsEngine,
     StateEngine,
 } from '@shapediver/viewer.shared.services';
-import { Box, IBox } from '@shapediver/viewer.shared.math';
-import { AbstractTreeNodeData, ITreeNode } from '@shapediver/viewer.shared.node-tree';
-
-import { ICameraControls } from '../../interfaces/controls/ICameraControls';
-import { ICamera, ICameraOptions } from '../../interfaces/camera/ICamera';
-import { CAMERA_TYPE } from '../../interfaces/ICameraEngine';
-import { IRenderingEngine } from '@shapediver/viewer.rendering-engine.rendering-engine';
 
 export abstract class AbstractCamera extends AbstractTreeNodeData implements ICamera {
-    // #region Properties (23)
+    // #region Properties (24)
 
     #active: boolean = false;
     #autoAdjust: boolean = false;
     #cameraMovementDuration: number = 800;
     #defaultPosition: vec3 = vec3.create();
     #defaultTarget: vec3 = vec3.create();
+    #domEventListenerToken: string | undefined;
     #enableCameraControls: boolean = true;
     #far: number = 1000;
     #name?: string;
@@ -43,7 +43,7 @@ export abstract class AbstractCamera extends AbstractTreeNodeData implements ICa
     protected _target: vec3 = vec3.create();
     protected _viewportId?: string;
 
-    // #endregion Properties (23)
+    // #endregion Properties (24)
 
     // #region Constructors (1)
 
@@ -53,7 +53,7 @@ export abstract class AbstractCamera extends AbstractTreeNodeData implements ICa
 
     // #endregion Constructors (1)
 
-    // #region Public Accessors (41)
+    // #region Public Getters And Setters (43)
 
     public get active(): boolean {
         return this.#active;
@@ -103,6 +103,14 @@ export abstract class AbstractCamera extends AbstractTreeNodeData implements ICa
         this.#defaultTarget = value;
     }
 
+    public get domEventListenerToken(): string | undefined {
+        return this.#domEventListenerToken;
+    }
+
+    public set domEventListenerToken(value: string | undefined) {
+        this.#domEventListenerToken = value;
+    }
+
     public get enableCameraControls(): boolean {
         return this.#enableCameraControls;
     }
@@ -221,7 +229,7 @@ export abstract class AbstractCamera extends AbstractTreeNodeData implements ICa
         this.#zoomExtentsFactor = value;
     }
 
-    // #endregion Public Accessors (41)
+    // #endregion Public Getters And Setters (43)
 
     // #region Public Methods (5)
 
@@ -286,11 +294,11 @@ export abstract class AbstractCamera extends AbstractTreeNodeData implements ICa
 
     // #region Public Abstract Methods (5)
 
-    abstract applySettings(settingsEngine?: SettingsEngine): void;
-    abstract assignViewer(renderingEngine: IRenderingEngine): void;
-    abstract calculateZoomTo(zoomTarget?: Box, startingPosition?: vec3, startingTarget?: vec3): { position: vec3; target: vec3; };
-    abstract project(p: vec3): vec2;
-    abstract unproject(p: vec3): vec3;
+    public abstract applySettings(settingsEngine?: SettingsEngine): void;
+    public abstract assignViewer(renderingEngine: IRenderingEngine): void;
+    public abstract calculateZoomTo(zoomTarget?: Box, startingPosition?: vec3, startingTarget?: vec3): { position: vec3; target: vec3; };
+    public abstract project(p: vec3): vec2;
+    public abstract unproject(p: vec3): vec3;
 
     // #endregion Public Abstract Methods (5)