@cognite/reveal 2.1.2 → 3.0.0-alpha.0

package/packages/cad-parsers/src/metadata/parsers/CadMetadataParserV8.d.ts

@@ -2,50 +2,5 @@
  * Copyright 2021 Cognite AS
  */
 import { SectorScene } from '../../utilities/types';
-export interface CadSectorMetadataV8 {
-    readonly id: number;
-    readonly parentId: number;
-    readonly path: string;
-    readonly depth: number;
-    readonly estimatedDrawCallCount: number;
-    readonly estimatedTriangleCount: number;
-    readonly boundingBox: {
-        readonly min: {
-            x: number;
-            y: number;
-            z: number;
-        };
-        readonly max: {
-            x: number;
-            y: number;
-            z: number;
-        };
-    };
-    readonly indexFile: {
-        readonly fileName: string;
-        readonly peripheralFiles: string[];
-        readonly downloadSize: number;
-    };
-    readonly facesFile: {
-        readonly quadSize: number;
-        readonly coverageFactors: {
-            xy: number;
-            yz: number;
-            xz: number;
-        };
-        readonly recursiveCoverageFactors: {
-            xy: number;
-            yz: number;
-            xz: number;
-        } | undefined;
-        readonly fileName: string | null;
-        readonly downloadSize: number;
-    } | null;
-}
-export interface CadMetadataV8 {
-    readonly version: 8;
-    readonly maxTreeIndex: number;
-    readonly sectors: CadSectorMetadataV8[];
-    readonly unit: string | null;
-}
-export declare function parseCadMetadataV8(metadata: CadMetadataV8): SectorScene;
+import { CadSceneRootMetadata } from './types';
+export declare function parseCadMetadataV8(metadata: CadSceneRootMetadata): SectorScene;

package/packages/cad-parsers/src/metadata/parsers/types.d.ts

@@ -0,0 +1,60 @@
+/*!
+ * Copyright 2021 Cognite AS
+ */
+export declare type CadSceneRootMetadata = {
+    readonly version: number;
+    readonly maxTreeIndex: number;
+    readonly sectors: SceneSectorMetadata[];
+    readonly unit: string | null;
+};
+export declare type SceneSectorMetadata = BaseSceneSectorMetadata & (GltfSceneSectorMetadata | I3dF3dSceneSectorMetadata);
+export declare type V8SceneSectorMetadata = BaseSceneSectorMetadata & I3dF3dSceneSectorMetadata;
+export declare type V9SceneSectorMetadata = BaseSceneSectorMetadata & GltfSceneSectorMetadata;
+export declare type BaseSceneSectorMetadata = {
+    readonly id: number;
+    readonly parentId: number | null;
+    readonly path: string;
+    readonly depth: number;
+    readonly estimatedDrawCallCount: number;
+    readonly estimatedTriangleCount: number;
+    readonly boundingBox: {
+        readonly min: {
+            x: number;
+            y: number;
+            z: number;
+        };
+        readonly max: {
+            x: number;
+            y: number;
+            z: number;
+        };
+    };
+};
+export declare type GltfSceneSectorMetadata = {
+    readonly sectorFileName: string | null;
+    readonly maxDiagonalLength: number;
+    readonly minDiagonalLength: number;
+    readonly downloadSize: number;
+};
+export declare type I3dF3dSceneSectorMetadata = {
+    readonly indexFile: {
+        readonly fileName: string;
+        readonly peripheralFiles: string[];
+        readonly downloadSize: number;
+    };
+    readonly facesFile: {
+        readonly quadSize: number;
+        readonly coverageFactors: {
+            xy: number;
+            yz: number;
+            xz: number;
+        };
+        readonly recursiveCoverageFactors: {
+            xy: number;
+            yz: number;
+            xz: number;
+        } | undefined;
+        readonly fileName: string | null;
+        readonly downloadSize: number;
+    } | null;
+};

package/packages/cad-parsers/src/metadata/types.d.ts

@@ -28,14 +28,25 @@ export interface SectorMetadataFacesFileSection {
     readonly fileName: string | null;
     readonly downloadSize: number;
 }
-export interface SectorMetadata {
+export declare type BaseSectorMetadata = {
     readonly id: number;
     readonly path: string;
     readonly depth: number;
     readonly bounds: THREE.Box3;
-    readonly indexFile: SectorMetadataIndexFileSection;
-    readonly facesFile: SectorMetadataFacesFileSection;
     readonly children: SectorMetadata[];
     readonly estimatedDrawCallCount: number;
     readonly estimatedRenderCost: number;
-}
+};
+export declare type SectorMetadata = BaseSectorMetadata & (I3dF3dSectorMetadata | GltfSectorMetadata);
+export declare type V8SectorMetadata = BaseSectorMetadata & I3dF3dSectorMetadata;
+export declare type V9SectorMetadata = BaseSectorMetadata & GltfSectorMetadata;
+export declare type I3dF3dSectorMetadata = {
+    readonly indexFile: SectorMetadataIndexFileSection;
+    readonly facesFile: SectorMetadataFacesFileSection;
+};
+export declare type GltfSectorMetadata = {
+    readonly sectorFileName: string | null;
+    readonly maxDiagonalLength: number;
+    readonly minDiagonalLength: number;
+    readonly downloadSize: number;
+};

package/packages/{cad-geometry-loaders → cad-parsers}/src/sector/RootSectorNode.d.ts

@@ -3,7 +3,7 @@
  */
 import * as THREE from 'three';
 import { SectorNode } from './SectorNode';
-import { CadModelMetadata } from '../../../cad-parsers';
+import { CadModelMetadata } from '../metadata/CadModelMetadata';
 export declare class RootSectorNode extends SectorNode {
     readonly sectorNodeMap: Map<number, SectorNode>;
     constructor(modelMetadata: CadModelMetadata);

package/packages/{cad-geometry-loaders → cad-parsers}/src/sector/SectorNode.d.ts

@@ -3,7 +3,7 @@
  */
 import * as THREE from 'three';
 import { AutoDisposeGroup } from '../../../utilities';
-import { LevelOfDetail } from '../../../cad-parsers';
+import { LevelOfDetail } from '../cad/LevelOfDetail';
 export declare class SectorNode extends THREE.Group {
     readonly sectorPath: string;
     readonly sectorId: number;

package/packages/cad-parsers/src/utilities/SectorSceneFactory.d.ts

@@ -1,12 +1,9 @@
-/*!
- * Copyright 2021 Cognite AS
- */
-import { SectorSceneImpl } from './SectorScene';
 import { SectorMetadata } from '../metadata/types';
+import { SectorScene } from './types';
 /**
  * Factory for creating instance of {@link SectorScene} based on
  * the version of the format provided.
  */
 export declare class SectorSceneFactory {
-    createSectorScene(version: number, maxTreeIndex: number, unit: string, root: SectorMetadata): SectorSceneImpl;
+    createSectorScene(version: number, maxTreeIndex: number, unit: string, root: SectorMetadata): SectorScene;
 }

package/packages/cad-parsers/src/utilities/computeBoundingBoxFromAttributes.d.ts

@@ -0,0 +1,10 @@
+/*!
+ * Copyright 2021 Cognite AS
+ */
+import * as THREE from 'three';
+import { ParsePrimitiveAttribute } from '@cognite/reveal-parser-worker';
+export declare function computeBoundingBoxFromCenterAndRadiusAttributes(attributeFloatValues: Float32Array, centerAByteOffset: number, centerBByteOffset: number, radiusAByteOffset: number, radiusBByteOffset: number, elementSize: number, elementIndex: number, out: THREE.Box3): THREE.Box3;
+export declare function computeBoundingBoxFromVertexAttributes(vertex1AttributeByteOffset: number, vertex2AttributeByteOffset: number, vertex3AttributeByteOffset: number, vertex4AttributeByteOffset: number, attributeFloatValues: Float32Array, elementSize: number, elementIndex: number, out: THREE.Box3): THREE.Box3;
+export declare function computeBoundingBoxFromInstanceMatrixAttributes(attributeFloatValues: Float32Array, byteOffset: number, elementSize: number, elementIndex: number, baseBoundingBox: THREE.Box3, out: THREE.Box3): THREE.Box3;
+export declare function computeBoundingBoxFromEllipseValues(radius1: number, radius2: number, height: number, center: THREE.Vector3, out: THREE.Box3): THREE.Box3;
+export declare function computeBoundingBoxFromEllipseAttributes(centerAttribute: ParsePrimitiveAttribute, radius1Attribute: ParsePrimitiveAttribute, radius2Attribute: ParsePrimitiveAttribute, heightAttribute: ParsePrimitiveAttribute, attributeFloatValues: Float32Array, elementSize: number, elementIndex: number, out: THREE.Box3): THREE.Box3;

package/packages/cad-parsers/src/utilities/types.d.ts

@@ -46,3 +46,29 @@ export interface SectorScene {
     getSectorsIntersectingFrustum(projectionMatrix: THREE.Matrix4, inverseCameraModelMatrix: THREE.Matrix4): SectorMetadata[];
     getAllSectors(): SectorMetadata[];
 }
+export interface SectorMetadataIndexFileSection {
+    readonly fileName: string;
+    readonly peripheralFiles: string[];
+    readonly downloadSize: number;
+}
+export interface SectorMetadataFacesFileSection {
+    readonly quadSize: number;
+    /**
+     * Coverage factors for the sector without children.
+     */
+    readonly coverageFactors: {
+        xy: number;
+        yz: number;
+        xz: number;
+    };
+    /**
+     * Coverage factor for the sectors including children.
+     */
+    readonly recursiveCoverageFactors: {
+        xy: number;
+        yz: number;
+        xz: number;
+    };
+    readonly fileName: string | null;
+    readonly downloadSize: number;
+}

package/packages/cad-styling/index.d.ts

@@ -7,3 +7,7 @@ export { TreeIndexNodeCollection } from './src/TreeIndexNodeCollection';
 export { UnionNodeCollection } from './src/UnionNodeCollection';
 export { NodeAppearance, DefaultNodeAppearance, NodeOutlineColor } from './src/NodeAppearance';
 export { NodeAppearanceProvider } from './src/NodeAppearanceProvider';
+export { AreaCollection } from './src/prioritized/AreaCollection';
+export { EmptyAreaCollection } from './src/prioritized/EmptyAreaCollection';
+export { ClusteredAreaCollection } from './src/prioritized/ClusteredAreaCollection';
+export { PrioritizedArea } from './src/prioritized/types';

package/packages/cad-styling/src/CombineNodeCollectionBase.d.ts

@@ -2,12 +2,13 @@
  * Copyright 2021 Cognite AS
  */
 import { IndexSet } from '../../utilities';
+import { AreaCollection } from './prioritized/AreaCollection';
 import { NodeCollectionBase, SerializedNodeCollection } from './NodeCollectionBase';
 /**
  * Node collection that combines the result from multiple underlying node collections.
  */
 export declare abstract class CombineNodeCollectionBase extends NodeCollectionBase {
-    private _changedUnderlyingNodeCollectionHandler;
+    private readonly _changedUnderlyingNodeCollectionHandler;
     private _cachedCombinedIndexSet;
     protected _nodeCollections: NodeCollectionBase[];
     constructor(classToken: string, nodeCollections?: NodeCollectionBase[]);
@@ -17,7 +18,7 @@ export declare abstract class CombineNodeCollectionBase extends NodeCollectionBa
      * Clears all underlying node collections.
      */
     clear(): void;
-    private makeDirty;
+    protected makeDirty(): void;
     /**
      * @override
      */
@@ -27,5 +28,6 @@ export declare abstract class CombineNodeCollectionBase extends NodeCollectionBa
      */
     get isLoading(): boolean;
     abstract serialize(): SerializedNodeCollection;
+    abstract getAreas(): AreaCollection;
     protected abstract createCombinedIndexSet(): IndexSet;
 }

package/packages/cad-styling/src/IntersectionNodeCollection.d.ts

@@ -3,13 +3,17 @@
  */
 import { NodeCollectionBase, SerializedNodeCollection } from './NodeCollectionBase';
 import { CombineNodeCollectionBase } from './CombineNodeCollectionBase';
+import { AreaCollection } from './prioritized/AreaCollection';
 import { IndexSet } from '../../utilities';
 /**
  * Node collection that is the intersection between a set of underlying node collections.
  */
 export declare class IntersectionNodeCollection extends CombineNodeCollectionBase {
+    private _cachedNodeAreas;
     static readonly classToken = "IntersectionNodeCollection";
     constructor(nodeCollections?: NodeCollectionBase[]);
     serialize(): SerializedNodeCollection;
     protected createCombinedIndexSet(): IndexSet;
+    makeDirty(): void;
+    getAreas(): AreaCollection;
 }

package/packages/cad-styling/src/NodeAppearance.d.ts

@@ -42,6 +42,28 @@ export declare type NodeAppearance = {
      * node to make it stand out.
      */
     readonly outlineColor?: NodeOutlineColor;
+    /**
+     * When provided, this value can be used to prioritize certain areas of the
+     * 3D model to be loaded. This can be useful to prioritize key objects in the
+     * 3D model to always be loaded.
+     *
+     * When non-zero, sectors containing geometry in the vicinity of the prioritized
+     * sectors are given an *extra* priority. Recommended values are in range 1 (somewhat
+     * higher priority to be loaded) to 10 (very likely to be loaded). Usually values around 4-5
+     * is recommended.
+     *
+     * Prioritized nodes are loaded at the expense of non-prioritized areas. There are no
+     * guarantees that the nodes are actually loaded, and the more prioritized areas/nodes
+     * provided, the less likely it is that the hint is obeyed.
+     *
+     * Extra priority doesn't accumulate when sectors are prioritized because they intersect/contain
+     * several nodes.
+     *
+     * **This is an advanced feature and not recommended for most users**
+     *
+     * @version Only works with 3D models converted later than Q4 2021.
+     */
+    readonly prioritizedForLoadingHint?: number;
 };
 /**
  * A set of default node appearances used in Reveal.
@@ -58,5 +80,6 @@ export declare const DefaultNodeAppearance: {
         renderInFront?: boolean | undefined;
         renderGhosted?: boolean | undefined;
         outlineColor?: NodeOutlineColor | undefined;
+        prioritizedForLoadingHint?: number | undefined;
     };
 };

package/packages/cad-styling/src/NodeAppearanceProvider.d.ts

@@ -4,6 +4,7 @@
 import { NodeAppearance } from './NodeAppearance';
 import { NodeCollectionBase } from './NodeCollectionBase';
 import { IndexSet } from '../../utilities';
+import { PrioritizedArea } from './prioritized/types';
 /**
  * Delegate for applying styles in {@see NodeStyleProvider}.
  * @param treeIndices Set of tree indices that the style is applied to.
@@ -13,6 +14,7 @@ export declare type ApplyStyleDelegate = (treeIndices: IndexSet, appearance: Nod
 export declare class NodeAppearanceProvider {
     private readonly _styledCollections;
     private _lastFiredLoadingState?;
+    private _cachedPrioritizedAreas?;
     private readonly _events;
     on(event: 'changed', listener: () => void): void;
     on(event: 'loadingStateChanged', listener: (isLoading: boolean) => void): void;
@@ -21,9 +23,14 @@ export declare class NodeAppearanceProvider {
     assignStyledNodeCollection(nodeCollection: NodeCollectionBase, appearance: NodeAppearance): void;
     unassignStyledNodeCollection(nodeCollection: NodeCollectionBase): void;
     applyStyles(applyCb: ApplyStyleDelegate): void;
+    getPrioritizedAreas(): PrioritizedArea[];
     clear(): void;
     get isLoading(): boolean;
     private notifyChanged;
+    /**
+     * Schedules event 'changed' to trigger at the next tick.
+     */
+    private readonly scheduleNotifyChanged;
     private notifyLoadingStateChanged;
     private handleNodeCollectionChanged;
 }

package/packages/cad-styling/src/NodeCollectionBase.d.ts

@@ -2,6 +2,7 @@
  * Copyright 2021 Cognite AS
  */
 import { IndexSet } from '../../utilities';
+import { AreaCollection } from './prioritized/AreaCollection';
 export declare type SerializedNodeCollection = {
     token: string;
     state: any;
@@ -35,6 +36,12 @@ export declare abstract class NodeCollectionBase {
      * of the nodes contained by the set.
      */
     abstract getIndexSet(): IndexSet;
+    /**
+     * Returns a set of areas that together contain all the nodes
+     * in the node collection. Note that this not necessarily is a minimum
+     * set of encapsulating areas.
+     */
+    abstract getAreas(): AreaCollection;
     /**
      * Clears the set, making it empty.
      */

package/packages/cad-styling/src/TreeIndexNodeCollection.d.ts

@@ -1,14 +1,17 @@
 /*!
  * Copyright 2021 Cognite AS
  */
-import { NumericRange, IndexSet } from '../../utilities';
+import * as THREE from 'three';
+import { AreaCollection } from './prioritized/AreaCollection';
 import { NodeCollectionBase, SerializedNodeCollection } from './NodeCollectionBase';
+import { NumericRange, IndexSet } from '../../utilities';
 /**
  * Node collection that holds a set of nodes defined by a set of tree indices.
  */
 export declare class TreeIndexNodeCollection extends NodeCollectionBase {
     static readonly classToken = "TreeIndexNodeCollection";
     private _treeIndices;
+    private _areaCollection;
     constructor(treeIndexSet?: IndexSet);
     constructor(treeIndices?: Iterable<number>);
     constructor(treeIndexRange?: NumericRange);
@@ -18,6 +21,19 @@ export declare class TreeIndexNodeCollection extends NodeCollectionBase {
      */
     clear(): void;
     getIndexSet(): IndexSet;
+    getAreas(): AreaCollection;
+    /**
+     * Add areas to this node collection's area set.
+     * Nearby areas may be clustered and merged together to keep
+     * the number of areas in the set small.
+     */
+    addAreas(areas: THREE.Box3[]): void;
+    /**
+     * Add points to this node collection's area set.
+     * This effectively adds boxes of size 1x1x1 meter with the points as their centers.
+     */
+    addAreaPoints(points: THREE.Vector3[]): void;
+    clearAreas(): void;
     get isLoading(): boolean;
     serialize(): SerializedNodeCollection;
 }

package/packages/cad-styling/src/UnionNodeCollection.d.ts

@@ -3,13 +3,16 @@
  */
 import { NodeCollectionBase, SerializedNodeCollection } from './NodeCollectionBase';
 import { CombineNodeCollectionBase } from './CombineNodeCollectionBase';
+import { AreaCollection } from './prioritized/AreaCollection';
 import { IndexSet } from '../../utilities';
 /**
  * Node collection that takes the set union of multiple node collections.
  */
 export declare class UnionNodeCollection extends CombineNodeCollectionBase {
+    private _cachedNodeAreas;
     static readonly classToken = "UnionNodeCollection";
     constructor(nodeCollections?: NodeCollectionBase[]);
     serialize(): SerializedNodeCollection;
     protected createCombinedIndexSet(): IndexSet;
+    getAreas(): AreaCollection;
 }

package/packages/cad-styling/src/prioritized/AreaCollection.d.ts

@@ -0,0 +1,39 @@
+/*!
+ * Copyright 2021 Cognite AS
+ */
+/**
+ * Represents a collection of areas/axis-aligned
+ * bounding boxes for use e.g. for load prioritization. Implementations
+ * are not expected to store all areas inserted with `addAreas`,
+ * but rather some "representative box set" covering the inserted areas.
+ * Performance will be better the fewer boxes the representative set contains,
+ * while the effectiveness of node prioritization will suffer if the
+ * representative set covers too much area that is not part
+ * of the inserted boxes
+ */
+export interface AreaCollection {
+    readonly isEmpty: boolean;
+    /**
+     * Return some set of boxes that cover the boxes inserted with `addAreas`.
+     * It is required that each inserted box is completely covered by some
+     * subset of boxes in the set returned from `areas`
+     */
+    areas(): Generator<THREE.Box3>;
+    /**
+     * Return whether the input box intersects the AreaCollection.
+     */
+    intersectsBox(box: THREE.Box3): boolean;
+    /**
+     * Add areas to be covered by the representative set of this
+     * AreaCollection.
+     */
+    addAreas(boxes: Iterable<THREE.Box3>): void;
+    /**
+     * Alter the representative set to cover only the intersection between the
+     * representative set of this AreaCollection and the incoming boxes.
+     * Note that the intersection of two representative sets A' and B' that
+     * represent the original box sets A and B will cover the intersection between
+     * A and B, and will thus be a valid representative set for the intersection of A and B.
+     */
+    intersectWith(boxes: Iterable<THREE.Box3>): void;
+}

package/packages/cad-styling/src/prioritized/BoxClusterer.d.ts

@@ -0,0 +1,29 @@
+/*!
+ * Copyright 2021 Cognite AS
+ */
+import { Box3 } from 'three';
+/**
+ * SmartMergeBoxes - takes in batches of bounding boxes and
+ * clusters them together in larger bounding boxes. The union of the larger
+ * boxes contains all boxes that have been inserted
+ */
+export declare class BoxClusterer {
+    private readonly resultBoxes;
+    private addedSinceSquash;
+    constructor();
+    constructor(boxes: Box3[]);
+    private mergeBoxesAtIndices;
+    private readonly _surfaceAreaVars;
+    private surfaceArea;
+    private readonly _shouldMergeBoxesVars;
+    private shouldMergeBoxes;
+    private addBox;
+    get boxCount(): number;
+    addBoxes(boxes: Iterable<Box3>): void;
+    squashBoxes(): void;
+    getBoxes(): Generator<Box3>;
+    intersectsBox(box: Box3): boolean;
+    union(boxes: Iterable<Box3>): BoxClusterer;
+    private addIntersectionIfNonempty;
+    intersection(other: Iterable<THREE.Box3>): BoxClusterer;
+}

package/packages/cad-styling/src/prioritized/ClusteredAreaCollection.d.ts

@@ -0,0 +1,17 @@
+/*!
+ * Copyright 2021 Cognite AS
+ */
+import { AreaCollection } from './AreaCollection';
+/**
+ * AreaCollection that stores a representative box set by merging
+ * inserted boxes that are overlapping or close to each other.
+ * It uses simple heuristics to determine which boxes are to be merged.
+ */
+export declare class ClusteredAreaCollection implements AreaCollection {
+    private readonly _clusterer;
+    get isEmpty(): boolean;
+    areas(): Generator<THREE.Box3>;
+    intersectsBox(box: THREE.Box3): boolean;
+    addAreas(boxes: Iterable<THREE.Box3>): void;
+    intersectWith(boxes: Iterable<THREE.Box3>): void;
+}

package/packages/cad-styling/src/prioritized/EmptyAreaCollection.d.ts

@@ -0,0 +1,18 @@
+/*!
+ * Copyright 2021 Cognite AS
+ */
+import { AreaCollection } from './AreaCollection';
+/**
+ * Convenience implementation to represent an empty collection of areas.
+ * that can be shared among several instances.
+ */
+export declare class EmptyAreaCollection implements AreaCollection {
+    private static _instance;
+    static instance(): AreaCollection;
+    private constructor();
+    areas(): Generator<THREE.Box3>;
+    intersectsBox(_box: THREE.Box3): boolean;
+    addAreas(_: Iterable<THREE.Box3>): void;
+    intersectWith(_: Iterable<THREE.Box3>): void;
+    get isEmpty(): boolean;
+}

package/packages/cad-styling/src/prioritized/types.d.ts

@@ -0,0 +1,7 @@
+/*!
+ * Copyright 2021 Cognite AS
+ */
+export declare type PrioritizedArea = {
+    area: THREE.Box3;
+    extraPriority: number;
+};

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

@@ -1,4 +1,6 @@
 /*!
  * Copyright 2021 Cognite AS
  */
-export { default } from './src/ComboControls';
+export { ComboControls } from './src/ComboControls';
+export { CameraManager } from './src/CameraManager';
+export * from './src/types';

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

@@ -0,0 +1,84 @@
+/*!
+ * Copyright 2021 Cognite AS
+ */
+import * as THREE from 'three';
+import { ComboControls } from './ComboControls';
+import { CameraManagerCallbackData, CameraControlsOptions, CameraChangeData, ControlsState } from './types';
+export declare class CameraManager {
+    private readonly _events;
+    private readonly _controls;
+    private readonly _camera;
+    private readonly _domElement;
+    private readonly _inputHandler;
+    private readonly _raycaster;
+    private isDisposed;
+    private readonly _modelRaycastCallback;
+    private _onClick;
+    private _onWheel;
+    private static readonly DefaultAnimationDuration;
+    private static readonly DefaultMinAnimationDuration;
+    private static readonly DefaultMaxAnimationDuration;
+    private static readonly DefaultMinDistance;
+    private static readonly DefaultMinZoomDistance;
+    private static readonly DefaultMinimalTimeBetweenRaycasts;
+    private static readonly DefaultCameraControlsOptions;
+    private _cameraControlsOptions;
+    automaticNearFarPlane: boolean;
+    automaticControlsSensitivity: boolean;
+    /**
+     * Reusable buffers used by functions in Cognite3dViewer to avoid allocations.
+     */
+    private readonly _updateNearAndFarPlaneBuffers;
+    private readonly _calculateCameraFarBuffers;
+    constructor(camera: THREE.PerspectiveCamera, domElement: HTMLElement, raycastFunction: (x: number, y: number) => Promise<CameraManagerCallbackData>);
+    on(event: 'cameraChange', callback: CameraChangeData): void;
+    off(event: 'cameraChange', callback: CameraChangeData): void;
+    fitCameraToBoundingBox(box: THREE.Box3, duration?: number, radiusFactor?: number): void;
+    set cameraControlsEnabled(enabled: boolean);
+    get cameraControlsEnabled(): boolean;
+    set keyboardNavigationEnabled(enabled: boolean);
+    get keyboardNavigationEnabled(): boolean;
+    get cameraControls(): ComboControls;
+    setCameraTarget(target: THREE.Vector3, animated?: boolean): void;
+    setCameraControlsState(controlsState: ControlsState): void;
+    getCameraControlsState(): ControlsState;
+    getCameraControlsOptions(): CameraControlsOptions;
+    setCameraControlsOptions(controlsOptions: CameraControlsOptions): void;
+    moveCameraTo(position: THREE.Vector3, target: THREE.Vector3, duration?: number): void;
+    moveCameraTargetTo(target: THREE.Vector3, duration?: number): void;
+    updateCameraNearAndFar(camera: THREE.PerspectiveCamera, combinedBbox: THREE.Box3): void;
+    updateCameraControlsState(deltaTime: number): void;
+    dispose(): void;
+    private calculateAnimationStartTarget;
+    private createTweenAnimation;
+    private calculateCameraFar;
+    private calculateCameraNear;
+    /**
+     * Calculates new target when raycaster doesn't have any intersections with the model.
+     * @param cursorPosition Cursor position for desired calculations.
+     * @param cursorPosition.x
+     * @param cursorPosition.y
+     */
+    private calculateNewTargetWithoutModel;
+    /**
+     * Calculates new camera target based on cursor position.
+     * @param event MouseEvent that contains pointer location data.
+     */
+    private calculateNewTarget;
+    /**
+     * Removes controls event listeners if they are defined.
+     */
+    private teardownControls;
+    private handleMouseWheelActionChange;
+    /**
+     * Method for setting up camera controls listeners and values inside current controls class.
+     */
+    private setupControls;
+    /**
+     * Convert pixel coordinates of the cursor to [-1,1]^2 coordinates.
+     * @param pixelX
+     * @param pixelY
+     */
+    private convertPixelCoordinatesToNormalized;
+    private calculateDefaultDuration;
+}