@cognite/reveal 4.9.1 → 4.10.0

package/dist/packages/api/src/public/migration/Cognite3DViewer.d.ts

@@ -279,7 +279,7 @@ export declare class Cognite3DViewer {
      * @param datasource The data data source which holds the references to the 360 image sets.
      * @param dataModelIdentifier The search parameters to apply when querying Cognite Datamodels that contains the 360 images.
      */
-    add360ImageSet(datasource: 'datamodels', dataModelIdentifier: Image360DataModelIdentifier): Promise<Image360Collection>;
+    add360ImageSet(datasource: 'datamodels', dataModelIdentifier: Image360DataModelIdentifier, add360ImageOptions?: AddImage360Options): Promise<Image360Collection>;
     /**
      * Adds a set of 360 images to the scene from the /events API in Cognite Data Fusion.
      * @param datasource The CDF data source which holds the references to the 360 image sets.

package/dist/packages/api/src/public/migration/types.d.ts

@@ -144,6 +144,11 @@ export interface Cognite3DViewerOptions {
      * Default value is set to true.
      */
     continuousModelStreaming?: boolean;
+    /**
+     * Use the new the new flexiable camera manager or not, default not to be used.
+     * @beta
+     */
+    useFlexibleCameraManager?: boolean;
 }
 /**
  * @module @cognite/reveal

package/dist/packages/camera-manager/index.d.ts

@@ -8,5 +8,13 @@ export { CameraManagerHelper } from './src/CameraManagerHelper';
 export { CameraManager } from './src/CameraManager';
 export { ComboControls, ComboControlsEventType } from './src/ComboControls';
 export { ComboControlsOptions } from './src/ComboControlsOptions';
+export { CameraControlsOptions } from './src/CameraControlsOptions';
 export { DebouncedCameraStopEventTrigger } from './src/utils/DebouncedCameraStopEventTrigger';
+export { IFlexibleCameraManager } from './src/Flexible/IFlexibleCameraManager';
+export { FlexibleControlsTypeChangeDelegate } from './src/Flexible/IFlexibleCameraManager';
+export { FlexibleCameraManager } from './src/Flexible/FlexibleCameraManager';
+export { FlexibleControlsOptions } from './src/Flexible/FlexibleControlsOptions';
+export { FlexibleWheelZoomType } from './src/Flexible/FlexibleWheelZoomType';
+export { FlexibleControlsType } from './src/Flexible/FlexibleControlsType';
+export { FlexibleMouseActionType } from './src/Flexible/FlexibleMouseActionType';
 export * from './src/types';

package/dist/packages/camera-manager/src/CameraControlsOptions.d.ts

@@ -0,0 +1,35 @@
+/*!
+ * Copyright 2021 Cognite AS
+ */
+export type CameraControlsOptions = {
+    /**
+     * Sets mouse wheel initiated action.
+     *
+     * Modes:
+     *
+     * 'zoomToTarget' - zooms just to the current target (center of the screen) of the camera.
+     *
+     * 'zoomPastCursor' - zooms in the direction of the ray coming from camera through cursor screen position, allows going through objects.
+     *
+     * 'zoomToCursor' - mouse wheel scroll zooms towards the point on the model where cursor is hovering over, doesn't allow going through objects.
+     *
+     * Default is 'zoomPastCursor'.
+     *
+     */
+    mouseWheelAction?: 'zoomToTarget' | 'zoomPastCursor' | 'zoomToCursor';
+    /**
+     * Enables or disables change of camera target on mouse click. New target is then set to the point of the model under current cursor position.
+     *
+     * Default is false.
+     *
+     */
+    changeCameraTargetOnClick?: boolean;
+    /**
+     * Enables or disables change of camera position on mouse doubke click. New target is then set to the point of the model under current cursor
+     * position and the a camera position is set half way to this point
+     *
+     * Default is false.
+     *
+     */
+    changeCameraPositionOnDoubleClick?: boolean;
+};

package/dist/packages/camera-manager/src/CameraManager.d.ts

@@ -1,7 +1,7 @@
 /*!
  * Copyright 2022 Cognite AS
  */
-import * as THREE from 'three';
+import { Box3, PerspectiveCamera } from 'three';
 import { CameraState, CameraChangeDelegate, CameraStopDelegate, CameraManagerEventType, CameraEventDelegate } from './types';
 /**
  * Interface for manager responsible for all manipulations to the camera,
@@ -17,7 +17,7 @@ export interface CameraManager {
      * Implementations must trigger the `cameraChange`-event whenever the
      * camera changes.
      */
-    getCamera(): THREE.PerspectiveCamera;
+    getCamera(): PerspectiveCamera;
     /**
      * Set camera's state. Rotation and target can't be set at the same time as they could conflict,
      * should throw an error if both are passed with non-zero value inside state.
@@ -79,7 +79,7 @@ export interface CameraManager {
      * @param duration The duration of the animation moving the camera.
      * @param radiusFactor The ratio of the distance from camera to center of box and radius of the box.
      */
-    fitCameraToBoundingBox(boundingBox: THREE.Box3, duration?: number, radiusFactor?: number): void;
+    fitCameraToBoundingBox(boundingBox: Box3, duration?: number, radiusFactor?: number): void;
     /**
      * Updates internal state of camera manager. Expected to update visual state of the camera
      * as well as it's near and far planes if needed. Called in `requestAnimationFrame`-loop.
@@ -87,7 +87,7 @@ export interface CameraManager {
      * @param deltaTime Delta time since last update in seconds.
      * @param boundingBox Global bounding box of the model(s) and any custom objects added to the scene.
      */
-    update(deltaTime: number, boundingBox: THREE.Box3): void;
+    update(deltaTime: number, boundingBox: Box3): void;
     /**
      * @obvious
      */

package/dist/packages/camera-manager/src/CameraManagerHelper.d.ts

@@ -1,7 +1,7 @@
 /*!
  * Copyright 2022 Cognite AS
  */
-import * as THREE from 'three';
+import { Box3, PerspectiveCamera, Quaternion, Vector3 } from 'three';
 /**
  * Helper methods for implementing a camera manager.
  */
@@ -19,30 +19,30 @@ export declare class CameraManagerHelper {
      * @param position New camera position.
      * @returns
      */
-    static calculateNewTargetFromRotation(camera: THREE.PerspectiveCamera, rotation: THREE.Quaternion, currentTarget: THREE.Vector3, position: THREE.Vector3): THREE.Vector3;
+    static calculateNewTargetFromRotation(camera: PerspectiveCamera, rotation: Quaternion, currentTarget: Vector3, position: Vector3): Vector3;
     /**
      * Calculates camera rotation from target
      * @param camera Used Camera instance
      * @param newTarget The target to compute rotation from
      * @returns New camera rotationg
      */
-    static calculateNewRotationFromTarget(camera: THREE.PerspectiveCamera, newTarget: THREE.Vector3): THREE.Quaternion;
+    static calculateNewRotationFromTarget(camera: PerspectiveCamera, newTarget: Vector3): Quaternion;
     /**
      * Updates near and far plane of the camera based on the bounding box.
      * @param camera Used camera instance.
-     * @param combinedBbox Bounding box of all objects on the scene.
+     * @param boundingBox Bounding box of all objects on the scene.
      */
-    static updateCameraNearAndFar(camera: THREE.PerspectiveCamera, combinedBbox: THREE.Box3): void;
+    static updateCameraNearAndFar(camera: PerspectiveCamera, boundingBox: Box3): void;
     /**
      * Calculates camera position and target that allows to see the content of provided bounding box.
      * @param camera Used camera instance.
-     * @param box Bounding box to be fitted.
+     * @param boundingBox Bounding box to be fitted.
      * @param radiusFactor The ratio of the distance from camera to center of box and radius of the box.
      * @returns
      */
-    static calculateCameraStateToFitBoundingBox(camera: THREE.PerspectiveCamera, box: THREE.Box3, radiusFactor?: number): {
-        position: THREE.Vector3;
-        target: THREE.Vector3;
+    static calculateCameraStateToFitBoundingBox(camera: PerspectiveCamera, boundingBox: Box3, radiusFactor?: number): {
+        position: Vector3;
+        target: Vector3;
     };
     private static calculateCameraFar;
     private static calculateCameraNear;

package/dist/packages/camera-manager/src/DefaultCameraManager.d.ts

@@ -3,8 +3,9 @@
  */
 import * as THREE from 'three';
 import { ComboControlsOptions } from './ComboControlsOptions';
-import { CameraControlsOptions, CameraState, CameraManagerEventType, CameraEventDelegate } from './types';
+import { CameraState, CameraManagerEventType, CameraEventDelegate } from './types';
 import { CameraManager } from './CameraManager';
+import { CameraControlsOptions } from './CameraControlsOptions';
 /**
  * Default implementation of {@link CameraManager}. Uses target-based orbit controls combined with
  * keyboard and mouse navigation possibility. Supports automatic update of camera near and far
@@ -23,8 +24,8 @@ export declare class DefaultCameraManager implements CameraManager {
     private _isEnabled;
     private readonly _modelRaycastCallback;
     private _onClick;
-    private _onWheel;
     private _onDoubleClick;
+    private _onWheel;
     private static readonly AnimationDuration;
     private static readonly MinAnimationDuration;
     private static readonly MaxAnimationDuration;

package/dist/packages/camera-manager/src/Flexible/DampedSpherical.d.ts

@@ -0,0 +1,23 @@
+/*!
+ * Copyright 2024 Cognite AS
+ */
+import { Spherical, Vector3 } from 'three';
+export declare class DampedSpherical {
+    readonly value: Spherical;
+    readonly end: Spherical;
+    private readonly _valueVector;
+    private readonly _endVector;
+    static isVertical(vector: Vector3): boolean;
+    isChanged(epsilon: number): boolean;
+    getValueVector(): Vector3;
+    getEndVector(): Vector3;
+    setValueVector(vector: Vector3): void;
+    setEndVector(vector: Vector3): void;
+    setThetaFromVector(vector: Vector3): void;
+    copy(vector: Vector3): void;
+    synchronize(): void;
+    synchronizeEnd(): void;
+    damp(dampeningFactor: number): void;
+    static correctPhi(value: Spherical): void;
+    static dampSphericalVectors(value: Spherical, end: Spherical, dampeningFactor: number): void;
+}

package/dist/packages/camera-manager/src/Flexible/DampedVector3.d.ts

@@ -0,0 +1,25 @@
+/*!
+ * Copyright 2024 Cognite AS
+ */
+import { Vector3 } from 'three';
+export declare class DampedVector3 {
+    readonly value: Vector3;
+    readonly end: Vector3;
+    private readonly _valueVector;
+    private readonly _endVector;
+    private readonly _valueSpherical;
+    private readonly _endSpherical;
+    isChanged(epsilon: number): boolean;
+    clear(): void;
+    copy(value: Vector3): void;
+    add(other: DampedVector3): void;
+    synchronize(): void;
+    synchronizeEnd(): void;
+    damp(dampeningFactor: number): void;
+    /**
+     * Suppose this(DampedVector3) is the position that orbits around the center point (DampedVector3). This has to be damped as a vector
+     * instead of a point. It is used when the camera is orbiting around a center point.
+     * This function also damp the center, since it is dependend on the center damped position
+     * **/
+    dampAsVectorAndCenter(dampeningFactor: number, center: DampedVector3): void;
+}

package/dist/packages/camera-manager/src/Flexible/FlexibleCameraManager.d.ts

@@ -0,0 +1,81 @@
+/*!
+ * Copyright 2024 Cognite AS
+ */
+import { Box3, PerspectiveCamera, Vector3, Scene } from 'three';
+import { FlexibleControls } from './FlexibleControls';
+import { FlexibleControlsOptions } from './FlexibleControlsOptions';
+import { InputHandler } from '../../../utilities';
+import { CameraEventDelegate, CameraManagerCallbackData, CameraManagerEventType, CameraState } from './../types';
+import { CameraManager } from './../CameraManager';
+import { FlexibleControlsType } from './FlexibleControlsType';
+import { FlexibleControlsTypeChangeDelegate, IFlexibleCameraManager } from './IFlexibleCameraManager';
+type RaycastCallback = (x: number, y: number, pickBoundingBox: boolean) => Promise<CameraManagerCallbackData>;
+/**
+ * Flexible implementation of {@link CameraManager}. The user can switch between Orbit, FirstPersion or OrbitInCenter
+ * Supports automatic update of camera near and far planes and animated change of camera position and target.
+ * @beta
+ */
+export declare class FlexibleCameraManager implements IFlexibleCameraManager {
+    private readonly _triggers;
+    private readonly _stopEventTrigger;
+    private readonly _controls;
+    private readonly _camera;
+    private readonly _domElement;
+    private readonly _inputHandler;
+    private readonly _markers?;
+    private readonly _currentBoundingBox;
+    private _isDisposed;
+    private _nearAndFarNeedsUpdate;
+    private _isEnabled;
+    private _prevTime;
+    private readonly _prevCoords;
+    private readonly _raycastCallback;
+    constructor(domElement: HTMLElement, inputHandler: InputHandler, raycastCallback: RaycastCallback, camera?: PerspectiveCamera, scene?: Scene);
+    getCamera(): PerspectiveCamera;
+    getCameraState(): Required<CameraState>;
+    /**
+     * Sets camera state. All parameters are optional. Rotation and target can't be set at the same time,
+     * if so, error will be thrown. Set rotation is preserved until next call of setCameraState with
+     * empty rotation field.
+     * @param state Camera state.
+     * **/
+    setCameraState(state: CameraState): void;
+    activate(cameraManager?: CameraManager): void;
+    deactivate(): void;
+    on(event: CameraManagerEventType, callback: CameraEventDelegate): void;
+    off(event: CameraManagerEventType, callback: CameraEventDelegate): void;
+    fitCameraToBoundingBox(boundingBox: Box3, duration?: number, radiusFactor?: number): void;
+    update(deltaTime: number, boundingBox: Box3): void;
+    dispose(): void;
+    get controlsType(): FlexibleControlsType;
+    set controlsType(value: FlexibleControlsType);
+    addControlsTypeChangeListener(callback: FlexibleControlsTypeChangeDelegate): void;
+    removeControlsTypeChangeListener(callback: FlexibleControlsTypeChangeDelegate): void;
+    get options(): FlexibleControlsOptions;
+    get controls(): FlexibleControls;
+    get camera(): PerspectiveCamera;
+    get domElement(): HTMLElement;
+    get isEnabled(): boolean;
+    get isDisposed(): boolean;
+    private set isEnabled(value);
+    private getPosition;
+    private getTarget;
+    getBoundingBoxDiagonal(): number;
+    getHorizontalDiagonal(): number;
+    setPositionAndTarget(position: Vector3, target: Vector3): void;
+    private getPickedPointPixelCoordinates;
+    private getTargetByBoundingBox;
+    private addEventListeners;
+    private removeEventListeners;
+    private readonly onCameraChange;
+    private readonly onControlsTypeChange;
+    private readonly onKeyDown;
+    private readonly onClick;
+    private readonly onDoubleClick;
+    private readonly onWheel;
+    private mouseAction;
+    private setTargetAndCameraPosition;
+    private updateCameraNearAndFar;
+    private updateControlsSensitivity;
+}
+export {};

package/dist/packages/camera-manager/src/Flexible/FlexibleCameraMarkers.d.ts

@@ -0,0 +1,11 @@
+/*!
+ * Copyright 2024 Cognite AS
+ */
+import { Scene } from 'three';
+import { FlexibleCameraManager } from './FlexibleCameraManager';
+export declare class FlexibleCameraMarkers {
+    private readonly _scene;
+    private _targetMarker;
+    constructor(scene: Scene);
+    update(manager: FlexibleCameraManager): void;
+}

package/dist/packages/camera-manager/src/Flexible/FlexibleControls.d.ts

@@ -0,0 +1,80 @@
+/*!
+ * Copyright 2024 Cognite AS
+ */
+import { EventDispatcher, OrthographicCamera, PerspectiveCamera, Quaternion, Vector3 } from 'three';
+import { FlexibleControlsType } from './FlexibleControlsType';
+import { FlexibleControlsOptions } from './FlexibleControlsOptions';
+import { FlexibleControlsEvent } from './FlexibleControlsEvent';
+/**
+ * @beta
+ */
+export declare class FlexibleControls extends EventDispatcher<FlexibleControlsEvent> {
+    private _isEnabled;
+    temporarlyDisableKeyboard: boolean;
+    private readonly _options;
+    private readonly _domElement;
+    private readonly _camera;
+    private readonly _target;
+    private readonly _cameraPosition;
+    private readonly _cameraVector;
+    private _scrollDirection;
+    private _scrollDistance;
+    private _tempTarget;
+    private readonly _keyboard;
+    private readonly _pointEventCache;
+    private readonly _reusableVector3s;
+    constructor(camera: PerspectiveCamera | OrthographicCamera, domElement: HTMLElement, options: FlexibleControlsOptions);
+    dispose(): void;
+    get options(): FlexibleControlsOptions;
+    get isEnabled(): boolean;
+    set isEnabled(isEnabled: boolean);
+    get controlsType(): FlexibleControlsType;
+    getTarget(): Vector3;
+    setTarget(value: Vector3): void;
+    getLookAt(): Vector3;
+    getState(): {
+        target: Vector3;
+        position: Vector3;
+    };
+    setScrollCursor(value: Vector3 | undefined): void;
+    setTempTarget(value: Vector3 | undefined): void;
+    setPositionAndTarget(position: Vector3, target: Vector3): void;
+    setPositionAndDirection(position: Vector3, direction: Vector3): void;
+    setPositionAndRotation(position: Vector3, rotation: Quaternion): void;
+    setControlsType(controlsType: FlexibleControlsType): boolean;
+    private getPanFactor;
+    private getWheelSpeed;
+    private getDampingFactor;
+    private newVector3;
+    update(deltaTimeS: number, forceUpdate?: boolean): boolean;
+    triggerCameraChangeEvent(): void;
+    triggerControlsTypeChangeEvent(): void;
+    private readonly onPointerDown;
+    private readonly onMouseDown;
+    private readonly onPointerUp;
+    private readonly onMouseWheel;
+    private readonly onTouchStart;
+    private readonly onFocusChanged;
+    private readonly onContextMenu;
+    addEventListeners(): void;
+    private removeEventListeners;
+    private startMouseRotation;
+    private startTouchRotation;
+    private rotate;
+    private getAzimuthCompensationFactor;
+    private rotateByAngles;
+    private rawRotateByAngles;
+    private startTouchPinch;
+    private startMousePan;
+    private pan;
+    private translate;
+    private dollyOrthographicCamera;
+    private dollyWithWheelScroll;
+    private getTranslation;
+    private getTranslationByDirection;
+    private getTranslationByScrollCursor;
+    private getStep;
+    private handleKeyboard;
+    private handleRotationFromKeyboard;
+    private handleMoveFromKeyboard;
+}

package/dist/packages/camera-manager/src/Flexible/FlexibleControlsEvent.d.ts

@@ -0,0 +1,19 @@
+/*!
+ * Copyright 2024 Cognite AS
+ */
+import { Vector3 } from 'three';
+import { FlexibleControlsType } from './FlexibleControlsType';
+/**
+ * @beta
+ */
+export type FlexibleControlsEvent = {
+    cameraChange: {
+        content: {
+            position: Vector3;
+            target: Vector3;
+        };
+    };
+    controlsTypeChange: {
+        controlsType: FlexibleControlsType;
+    };
+};

package/dist/packages/camera-manager/src/Flexible/FlexibleControlsOptions.d.ts

@@ -0,0 +1,56 @@
+/*!
+ * Copyright 2024 Cognite AS
+ */
+import { FlexibleControlsType } from './FlexibleControlsType';
+import { FlexibleMouseActionType } from './FlexibleMouseActionType';
+import { FlexibleWheelZoomType } from './FlexibleWheelZoomType';
+/**
+ * @beta
+ */
+export declare class FlexibleControlsOptions {
+    controlsType: FlexibleControlsType;
+    showTarget: boolean;
+    mouseWheelAction: FlexibleWheelZoomType;
+    mouseClickType: FlexibleMouseActionType;
+    mouseDoubleClickType: FlexibleMouseActionType;
+    enableChangeControlsTypeOn123Key: boolean;
+    enableKeyboardNavigation: boolean;
+    animationDuration: number;
+    minimumTimeBetweenRaycasts: number;
+    maximumTimeBetweenRaycasts: number;
+    mouseDistanceThresholdBetweenRaycasts: number;
+    minPolarAngle: number;
+    maxPolarAngle: number;
+    minAzimuthAngle: number;
+    maxAzimuthAngle: number;
+    enableDamping: boolean;
+    dampingFactor: number;
+    automaticNearFarPlane: boolean;
+    sensitivity: number;
+    automaticSensitivity: boolean;
+    sensitivityDiagonalFraction: number;
+    minSensitivity: number;
+    maxSensitivity: number;
+    mouseRotationSpeedAzimuth: number;
+    mouseRotationSpeedPolar: number;
+    keyboardRotationSpeedAzimuth: number;
+    keyboardRotationSpeedPolar: number;
+    zoomFraction: number;
+    minOrthographicZoom: number;
+    maxOrthographicZoom: number;
+    wheelDollySpeed: number;
+    mousePanSpeed: number;
+    mouseDollySpeed: number;
+    keyboardPanSpeed: number;
+    keyboardDollySpeed: number;
+    keyboardFastMoveFactor: number;
+    pinchEpsilon: number;
+    pinchPanSpeed: number;
+    EPSILON: number;
+    orthographicCameraDollyFactor: number;
+    get realMouseWheelAction(): FlexibleWheelZoomType;
+    get shouldPick(): boolean;
+    getLegalAzimuthAngle(azimuthAngle: number): number;
+    getLegalPolarAngle(polarAngle: number): number;
+    getLegalSensitivity(controlsSensitivity: number): number;
+}

package/dist/packages/camera-manager/src/Flexible/FlexibleControlsType.d.ts

@@ -0,0 +1,11 @@
+/*!
+ * Copyright 2024 Cognite AS
+ */
+/**
+ * @beta
+ */
+export declare enum FlexibleControlsType {
+    OrbitInCenter = "orbitInCenter",
+    FirstPerson = "firstPerson",
+    Orbit = "orbit"
+}

package/dist/packages/camera-manager/src/Flexible/FlexibleMouseActionType.d.ts

@@ -0,0 +1,12 @@
+/*!
+ * Copyright 2024 Cognite AS
+ */
+/**
+ * @beta
+ */
+export declare enum FlexibleMouseActionType {
+    None = "none",
+    SetTarget = "setTarget",
+    SetTargetAndCameraDirection = "setTargetAndCameraDirection",
+    SetTargetAndCameraPosition = "setTargetAndCameraPosition"
+}

package/dist/packages/camera-manager/src/Flexible/FlexibleWheelZoomType.d.ts

@@ -0,0 +1,24 @@
+/*!
+ * Copyright 2024 Cognite AS
+ */
+/**
+ * Sets mouse wheel initiated action.
+ *
+ * Modes:
+ *
+ * 'ToTarget' - zooms just to the current target (center of the screen) of the camera.
+ *
+ * 'PastCursor' - zooms in the direction of the ray coming from camera through cursor screen position, allows going through objects.
+ *
+ * 'ToCursor' - mouse wheel scroll zooms towards the point on the model where cursor is hovering over, doesn't allow going through objects.
+ *
+ * Default is 'zoomPastCursor'.
+ *
+ * @beta
+ */
+export declare enum FlexibleWheelZoomType {
+    Center = "center",
+    PastCursor = "pastCursor",
+    ToCursor = "toCursor",
+    Auto = "auto"
+}

package/dist/packages/camera-manager/src/Flexible/IFlexibleCameraManager.d.ts

@@ -0,0 +1,20 @@
+/*!
+ * Copyright 2024 Cognite AS
+ */
+import { CameraManager } from '../CameraManager';
+import { FlexibleControlsType } from './FlexibleControlsType';
+/**
+ * @beta
+ */
+export type FlexibleControlsTypeChangeDelegate = (controlsType: FlexibleControlsType) => void;
+/**
+ * Flexible implementation of {@link CameraManager}. The user can switch between Orbit, FirstPersion or OrbitInCenter
+ * Supports automatic update of camera near and far planes and animated change of camera position and target.
+ * @beta
+ */
+export interface IFlexibleCameraManager extends CameraManager {
+    get controlsType(): FlexibleControlsType;
+    set controlsType(value: FlexibleControlsType);
+    addControlsTypeChangeListener(callback: FlexibleControlsTypeChangeDelegate): void;
+    removeControlsTypeChangeListener(callback: FlexibleControlsTypeChangeDelegate): void;
+}

package/dist/packages/camera-manager/src/Flexible/ReusableVector3s.d.ts

@@ -0,0 +1,10 @@
+/*!
+ * Copyright 2024 Cognite AS
+ */
+import { Vector3 } from 'three';
+export declare class ReusableVector3s {
+    private readonly _vectors;
+    private _index;
+    constructor(size?: number);
+    getNext(): Vector3;
+}

package/dist/packages/camera-manager/src/Flexible/moveCamera.d.ts

@@ -0,0 +1,7 @@
+/*!
+ * Copyright 2024 Cognite AS
+ */
+import { Vector3 } from 'three';
+import { FlexibleCameraManager } from './FlexibleCameraManager';
+export declare function moveCameraTo(manager: FlexibleCameraManager, position: Vector3, target: Vector3, duration?: number): void;
+export declare function moveCameraTargetTo(manager: FlexibleCameraManager, target: Vector3, duration?: number): void;

package/dist/packages/camera-manager/src/ProxyCameraManager.d.ts

@@ -1,7 +1,7 @@
 /*!
  * Copyright 2022 Cognite AS
  */
-import * as THREE from 'three';
+import { Box3, PerspectiveCamera } from 'three';
 import { CameraManager } from './CameraManager';
 import { CameraChangeDelegate, CameraState, CameraStopDelegate } from './types';
 export declare class ProxyCameraManager implements CameraManager {
@@ -11,7 +11,7 @@ export declare class ProxyCameraManager implements CameraManager {
     get innerCameraManager(): CameraManager;
     constructor(initialActiveCamera: CameraManager);
     setActiveCameraManager(cameraManager: CameraManager): void;
-    getCamera(): THREE.PerspectiveCamera;
+    getCamera(): PerspectiveCamera;
     setCameraState(state: CameraState): void;
     getCameraState(): Required<CameraState>;
     activate(cameraManager?: CameraManager): void;
@@ -20,8 +20,8 @@ export declare class ProxyCameraManager implements CameraManager {
     on(eventType: 'cameraStop', callback: CameraStopDelegate): void;
     off(eventType: 'cameraChange', callback: CameraChangeDelegate): void;
     off(eventType: 'cameraStop', callback: CameraStopDelegate): void;
-    fitCameraToBoundingBox(boundingBox: THREE.Box3, duration?: number | undefined, radiusFactor?: number | undefined): void;
-    update(deltaTime: number, boundingBox: THREE.Box3): void;
+    fitCameraToBoundingBox(boundingBox: Box3, duration?: number | undefined, radiusFactor?: number | undefined): void;
+    update(deltaTime: number, boundingBox: Box3): void;
     dispose(): void;
     private onActiveCameraManagerChangeFired;
     private onActiveCameraManagerStopFired;

package/dist/packages/camera-manager/src/StationaryCameraManager.d.ts

@@ -1,7 +1,7 @@
 /*!
  * Copyright 2022 Cognite AS
  */
-import * as THREE from 'three';
+import { Box3, PerspectiveCamera, Vector3 } from 'three';
 import { CameraManager } from './CameraManager';
 import { CameraChangeDelegate, CameraEventDelegate, CameraManagerEventType, CameraState } from './types';
 export declare class StationaryCameraManager implements CameraManager {
@@ -13,8 +13,8 @@ export declare class StationaryCameraManager implements CameraManager {
     private readonly _stopEventTrigger;
     private _isDragging;
     private _pointerEventCache;
-    constructor(domElement: HTMLElement, camera: THREE.PerspectiveCamera);
-    getCamera(): THREE.PerspectiveCamera;
+    constructor(domElement: HTMLElement, camera: PerspectiveCamera);
+    getCamera(): PerspectiveCamera;
     get defaultFOV(): number;
     setCameraState(state: CameraState): void;
     getCameraState(): Required<CameraState>;
@@ -22,10 +22,10 @@ export declare class StationaryCameraManager implements CameraManager {
     deactivate(): void;
     on(eventType: CameraManagerEventType, callback: CameraEventDelegate): void;
     off(eventType: CameraManagerEventType, callback: CameraChangeDelegate): void;
-    fitCameraToBoundingBox(boundingBox: THREE.Box3, _?: number, radiusFactor?: number): void;
-    moveTo(targetPosition: THREE.Vector3, duration?: number): Promise<void>;
+    fitCameraToBoundingBox(boundingBox: Box3, _?: number, radiusFactor?: number): void;
+    moveTo(targetPosition: Vector3, duration?: number): Promise<void>;
     setFOV(fov: number): void;
-    update(_: number, boundingBox: THREE.Box3): void;
+    update(_: number, boundingBox: Box3): void;
     dispose(): void;
     private enableDragging;
     private disableDragging;