vim-web 0.3.44-dev.9 → 0.4.1-dev.0

package/dist/types/core-viewers/webgl/loader/geometry.d.ts

@@ -24,82 +24,80 @@ export declare namespace Transparency {
      */
     function requiresAlpha(mode: Mode): mode is "all" | "transparentOnly";
 }
-export declare namespace Geometry {
-    /**
-     * Creates a BufferGeometry with all given instances merged
-     * @param instances indices of the instances from the g3d to merge
-     * @returns a BufferGeometry
-     */
-    function createGeometryFromInstances(g3d: G3d, args: MergeArgs): THREE.BufferGeometry<THREE.NormalBufferAttributes>;
-    /**
-     * Creates a BufferGeometry from a given mesh index in the g3d
-     * @param mesh g3d mesh index
-     * @param transparent specify to use RGB or RGBA for colors
-     */
-    function createGeometryFromMesh(g3d: G3d, mesh: number, section: MeshSection, transparent: boolean): THREE.BufferGeometry;
-    /**
-     * Returns a THREE.Matrix4 from the g3d for given instance
-     * @param instance g3d instance index
-     * @param target matrix where the data will be copied, a new matrix will be created if none provided.
-     */
-    function getInstanceMatrix(g3d: G3d, instance: number, target?: THREE.Matrix4): THREE.Matrix4;
-    /**
-     * Creates a BufferGeometry from given geometry data arrays
-     * @param vertices vertex data with 3 number per vertex (XYZ)
-     * @param indices index data with 3 indices per face
-     * @param vertexColors color data with 3 or 4 number per vertex. RBG or RGBA
-     * @param colorSize specify whether to treat colors as RGB or RGBA
-     * @returns a BufferGeometry
-     */
-    function createGeometryFromArrays(vertices: Float32Array, indices: Uint32Array, vertexColors?: Float32Array | undefined, colorSize?: number): THREE.BufferGeometry;
-    /**
-     * Returns a merged mesh of all meshes related to given instances along with picking related metadata
-     * Returns undefined if mesh would be empty
-     * @param section mesh sections to include in the merged mesh.
-     * @param transparent true to use a transparent material.
-     * @param instances instances for which to merge meshes.
-     */
-    function mergeInstanceMeshes(g3d: G3d, mergeArgs: MergeArgs): MergeResult;
-    /**
-     * Returns a merged mesh of all unique meshes along with picking related metadata
-     * @param section mesh sections to include in the merged mesh.
-     * @param transparent true to use a transparent material.
-     * @param instances instances for which to merge meshes.
-     */
-    function mergeUniqueMeshes(g3d: G3d, args: MergeArgs): MergeResult;
-    /**
-     * Holds the info that needs to be precomputed for a merge.
-     */
-    class MergeInfo {
-        section: MeshSection;
-        transparent: boolean;
-        instances: number[];
-        indexCount: number;
-        vertexCount: number;
-        constructor(section: MeshSection, transparent: boolean, instance: number[], indexCount: number, vertexCount: number);
-        createBuffer(): MergeBuffer;
-    }
-    /**
-     * Allocates and holds all arrays needed to merge meshes.
-     */
-    class MergeBuffer {
-        indices: Uint32Array;
-        vertices: Float32Array;
-        colors: Float32Array;
-        groups: number[];
-        colorSize: number;
-        boxes: THREE.Box3[];
-        constructor(info: MergeInfo, positionSize: number, colorSize: number);
-        toBufferGeometry(): THREE.BufferGeometry<THREE.NormalBufferAttributes>;
-    }
-    /**
-     * Holds the result from a merge operation.
-     */
-    class MergeResult {
-        geometry: THREE.BufferGeometry;
-        instances: number[];
-        submeshes: number[];
-        boxes: THREE.Box3[];
-        constructor(geometry: THREE.BufferGeometry, instance: number[], submeshes: number[], boxes: THREE.Box3[]);
-    }
+/**
+ * Creates a BufferGeometry with all given instances merged
+ * @param instances indices of the instances from the g3d to merge
+ * @returns a BufferGeometry
+ */
+export declare function createGeometryFromInstances(g3d: G3d, args: MergeArgs): THREE.BufferGeometry<THREE.NormalBufferAttributes>;
+/**
+ * Creates a BufferGeometry from a given mesh index in the g3d
+ * @param mesh g3d mesh index
+ * @param transparent specify to use RGB or RGBA for colors
+ */
+export declare function createGeometryFromMesh(g3d: G3d, mesh: number, section: MeshSection, transparent: boolean): THREE.BufferGeometry;
+/**
+ * Returns a THREE.Matrix4 from the g3d for given instance
+ * @param instance g3d instance index
+ * @param target matrix where the data will be copied, a new matrix will be created if none provided.
+ */
+export declare function getInstanceMatrix(g3d: G3d, instance: number, target?: THREE.Matrix4): THREE.Matrix4;
+/**
+ * Creates a BufferGeometry from given geometry data arrays
+ * @param vertices vertex data with 3 number per vertex (XYZ)
+ * @param indices index data with 3 indices per face
+ * @param vertexColors color data with 3 or 4 number per vertex. RBG or RGBA
+ * @param colorSize specify whether to treat colors as RGB or RGBA
+ * @returns a BufferGeometry
+ */
+export declare function createGeometryFromArrays(vertices: Float32Array, indices: Uint32Array, vertexColors?: Float32Array | undefined, colorSize?: number): THREE.BufferGeometry;
+/**
+ * Returns a merged mesh of all meshes related to given instances along with picking related metadata
+ * Returns undefined if mesh would be empty
+ * @param section mesh sections to include in the merged mesh.
+ * @param transparent true to use a transparent material.
+ * @param instances instances for which to merge meshes.
+ */
+export declare function mergeInstanceMeshes(g3d: G3d, mergeArgs: MergeArgs): MergeResult;
+/**
+ * Returns a merged mesh of all unique meshes along with picking related metadata
+ * @param section mesh sections to include in the merged mesh.
+ * @param transparent true to use a transparent material.
+ * @param instances instances for which to merge meshes.
+ */
+export declare function mergeUniqueMeshes(g3d: G3d, args: MergeArgs): MergeResult;
+/**
+ * Holds the info that needs to be precomputed for a merge.
+ */
+export declare class MergeInfo {
+    section: MeshSection;
+    transparent: boolean;
+    instances: number[];
+    indexCount: number;
+    vertexCount: number;
+    constructor(section: MeshSection, transparent: boolean, instance: number[], indexCount: number, vertexCount: number);
+    createBuffer(): MergeBuffer;
+}
+/**
+ * Allocates and holds all arrays needed to merge meshes.
+ */
+export declare class MergeBuffer {
+    indices: Uint32Array;
+    vertices: Float32Array;
+    colors: Float32Array;
+    groups: number[];
+    colorSize: number;
+    boxes: THREE.Box3[];
+    constructor(info: MergeInfo, positionSize: number, colorSize: number);
+    toBufferGeometry(): THREE.BufferGeometry<THREE.NormalBufferAttributes>;
+}
+/**
+ * Holds the result from a merge operation.
+ */
+export declare class MergeResult {
+    geometry: THREE.BufferGeometry;
+    instances: number[];
+    submeshes: number[];
+    boxes: THREE.Box3[];
+    constructor(geometry: THREE.BufferGeometry, instance: number[], submeshes: number[], boxes: THREE.Box3[]);
 }

package/dist/types/core-viewers/webgl/loader/index.d.ts

@@ -0,0 +1,24 @@
+export * from './vimSettings';
+export { requestVim as request, type RequestSource, type VimRequest } from './progressive/vimRequest';
+export * as Materials from './materials';
+export type { Transparency } from './geometry';
+export type * from './webglAttribute';
+export type * from './colorAttribute';
+export type * from './element3d';
+export type * from './elementMapping';
+export type * from './mesh';
+export type * from './scene';
+export type * from './vim';
+export type * from './progressive/vimx';
+export type * from './progressive/g3dOffsets';
+export type * from './progressive/g3dSubset';
+export type * from './progressive/insertableGeometry';
+export type * from './progressive/insertableMesh';
+export type * from './progressive/insertableSubmesh';
+export type * from './progressive/instancedMesh';
+export type * from './progressive/instancedMeshFactory';
+export type * from './progressive/instancedSubmesh';
+export type * from './progressive/legacyMeshFactory';
+export type * from './progressive/loadingSynchronizer';
+export type * from './progressive/subsetBuilder';
+export type * from './progressive/subsetRequest';

package/dist/types/core-viewers/webgl/loader/materials/index.d.ts

@@ -0,0 +1,9 @@
+export * from './ghostMaterial';
+export * from './maskMaterial';
+export * from './materials';
+export * from './mergeMaterial';
+export * from './outlineMaterial';
+export * from './simpleMaterial';
+export * from './skyboxMaterial';
+export * from './standardMaterial';
+export * from './transferMaterial';

package/dist/types/core-viewers/webgl/loader/materials/{viewerMaterials.d.ts → materials.d.ts}

@@ -11,10 +11,10 @@ export type ModelMaterial = THREE.Material | THREE.Material[] | undefined;
 /**
  * Defines the materials to be used by the vim loader and allows for material injection.
  */
-export declare class ViewerMaterials {
-    static instance: ViewerMaterials;
-    static createInstance(instance: ViewerMaterials): void;
-    static getInstance(): ViewerMaterials;
+export declare class Materials {
+    static instance: Materials;
+    static createInstance(instance: Materials): void;
+    static getInstance(): Materials;
     /**
      * Material used for opaque model geometry.
      */
@@ -131,7 +131,7 @@ export declare class ViewerMaterials {
     get outlineAntialias(): boolean;
     set outlineAntialias(value: boolean);
     /**
-     * Size of the blur convolution on the selection outline effect.
+     * Size of the blur convolution on the selection outline effect. Minimum 2.
      */
     get outlineBlur(): number;
     set outlineBlur(value: number);

package/dist/types/core-viewers/webgl/loader/mesh.d.ts

@@ -5,7 +5,7 @@ import * as THREE from 'three';
 import { InsertableSubmesh } from './progressive/insertableSubmesh';
 import { Vim } from './vim';
 import { InstancedSubmesh } from './progressive/instancedSubmesh';
-import { ModelMaterial } from './materials/viewerMaterials';
+import { ModelMaterial } from './materials/materials';
 /**
  * Wrapper around THREE.Mesh
  * Keeps track of what VIM instances are part of this mesh.
@@ -112,5 +112,5 @@ export declare class StandardSubmesh {
     /**
      * Returns vim object for this submesh.
      */
-    get object(): import("./object3D").Object3D;
+    get object(): import("./element3d").Element3D;
 }

package/dist/types/core-viewers/webgl/loader/progressive/insertableMesh.d.ts

@@ -7,7 +7,7 @@ import { InsertableGeometry } from './insertableGeometry';
 import { InsertableSubmesh } from './insertableSubmesh';
 import { G3dMeshOffsets } from './g3dOffsets';
 import { Vim } from '../vim';
-import { ModelMaterial } from '../materials/viewerMaterials';
+import { ModelMaterial } from '../materials/materials';
 export declare class InsertableMesh {
     offsets: G3dMeshOffsets;
     mesh: THREE.Mesh;

package/dist/types/core-viewers/webgl/loader/progressive/insertableSubmesh.d.ts

@@ -37,7 +37,7 @@ export declare class InsertableSubmesh {
     /**
      * Returns vim object for this submesh.
      */
-    get object(): import("../object3D").Object3D;
+    get object(): import("..").Element3D;
     saveColors(colors: Float32Array): void;
     popColors(): Float32Array<ArrayBufferLike>;
 }

package/dist/types/core-viewers/webgl/loader/progressive/instancedMesh.d.ts

@@ -5,7 +5,7 @@ import * as THREE from 'three';
 import { Vim } from '../vim';
 import { InstancedSubmesh } from './instancedSubmesh';
 import { G3d, G3dMesh } from 'vim-format';
-import { ModelMaterial } from '../materials/viewerMaterials';
+import { ModelMaterial } from '../materials/materials';
 export declare class InstancedMesh {
     g3dMesh: G3dMesh | G3d;
     vim: Vim;

package/dist/types/core-viewers/webgl/loader/progressive/instancedSubmesh.d.ts

@@ -27,5 +27,5 @@ export declare class InstancedSubmesh {
     /**
      * Returns vim object for this submesh.
      */
-    get object(): import("../object3D").Object3D;
+    get object(): import("..").Element3D;
 }

package/dist/types/core-viewers/webgl/loader/progressive/vimRequest.d.ts

@@ -1,6 +1,6 @@
 import { VimPartialSettings } from '../vimSettings';
 import { Vim } from '../vim';
-import { RequestResult } from '../../utils/requestResult';
+import { Result } from '../../../../utils/result';
 import { VimSource } from '../..';
 import { IProgressLogs } from 'vim-format';
 export type RequestSource = {
@@ -14,7 +14,7 @@ export type RequestSource = {
  * @param settings the settings to configure how the vim will be loaded.
  * @returns a request object that can be used to track progress and get the result.
  */
-export declare function request(options: RequestSource, settings?: VimPartialSettings): VimRequest;
+export declare function requestVim(options: RequestSource, settings?: VimPartialSettings): VimRequest;
 /**
  * A class that represents a request to load a VIM object from a given source.
  */
@@ -34,7 +34,7 @@ export declare class VimRequest {
      */
     private startRequest;
     private end;
-    getResult(): Promise<RequestResult<Vim>>;
+    getResult(): Promise<Result<Vim>>;
     /**
      * Async generator that yields progress updates.
      * @returns An AsyncGenerator yielding IProgressLogs.

package/dist/types/core-viewers/webgl/loader/scene.d.ts

@@ -6,7 +6,8 @@ import { Mesh, Submesh } from './mesh';
 import { Vim } from './vim';
 import { InsertableMesh } from './progressive/insertableMesh';
 import { InstancedMesh } from './progressive/instancedMesh';
-import { ModelMaterial } from './materials/viewerMaterials';
+import { ModelMaterial } from './materials/materials';
+import { Renderer } from '../viewer/rendering/renderer';
 /**
  * Interface for a renderer object, providing methods to add and remove objects from a scene, update bounding boxes, and notify scene updates.
  */
@@ -26,16 +27,12 @@ export declare class Scene {
     private _matrix;
     insertables: InsertableMesh[];
     meshes: (Mesh | InsertableMesh | InstancedMesh)[];
-    private _outlineCount;
     private _boundingBox;
     private _averageBoundingBox;
     private _instanceToMeshes;
     private _material;
     constructor(matrix: THREE.Matrix4);
     setDirty(): void;
-    hasOutline(): boolean;
-    addOutline(): void;
-    removeOutline(): void;
     clearUpdateFlag(): void;
     /**
      * Returns the scene bounding box. Returns undefined if scene is empty.
@@ -55,8 +52,8 @@ export declare class Scene {
      */
     getMeshFromInstance(instance: number): Submesh[];
     getMeshesFromInstances(instances: number[] | undefined): Submesh[];
-    get renderer(): IRenderer;
-    set renderer(value: IRenderer);
+    get renderer(): Renderer;
+    set renderer(value: Renderer);
     get vim(): Vim;
     /**
      * Sets vim index for this scene and all its THREE.Meshes.

package/dist/types/core-viewers/webgl/loader/vim.d.ts

@@ -5,18 +5,19 @@ import * as THREE from 'three';
 import { VimDocument, G3d, VimHeader, FilterMode } from 'vim-format';
 import { Scene } from './scene';
 import { VimSettings } from './vimSettings';
-import { Object3D } from './object3D';
+import { Element3D } from './element3d';
 import { ElementMapping, ElementMapping2, ElementNoMapping } from './elementMapping';
 import { ISignal } from 'ste-signals';
 import { G3dSubset } from './progressive/g3dSubset';
 import { SubsetBuilder } from './progressive/subsetBuilder';
 import { LoadPartialSettings } from './progressive/subsetRequest';
+import { IVim } from '../../shared/vim';
 type VimFormat = 'vim' | 'vimx';
 /**
  * Represents a container for the built three.js meshes and the vim data from which they were constructed.
  * Facilitates high-level scene manipulation by providing access to objects.
  */
-export declare class Vim {
+export declare class Vim implements IVim<Element3D> {
     /**
      * Indicates whether the vim was opened from a vim or vimx file.
      */
@@ -82,6 +83,7 @@ export declare class Vim {
    * @param {boolean} isLegacy - Indicates whether the Vim object uses a legacy loading pipeline.
    */
     constructor(header: VimHeader | undefined, document: VimDocument, g3d: G3d | undefined, scene: Scene, settings: VimSettings, map: ElementMapping | ElementNoMapping | ElementMapping2, builder: SubsetBuilder, source: string, format: VimFormat);
+    getBoundingBox(): Promise<THREE.Box3>;
     /**
      * Retrieves the matrix representation of the Vim object's position, rotation, and scale.
      * @returns {THREE.Matrix4} The matrix representing the Vim object's transformation.
@@ -92,36 +94,30 @@ export declare class Vim {
      * @param {number} instance - The instance number of the object.
      * @returns {THREE.Object3D | undefined} The object corresponding to the instance, or undefined if not found.
      */
-    getObjectFromInstance(instance: number): Object3D;
+    getElementFromInstanceIndex(instance: number): Element3D;
     /**
      * Retrieves the objects associated with the specified element ID.
      * @param {number} id - The element ID to retrieve objects for.
      * @returns {THREE.Object3D[]} An array of objects corresponding to the element ID, or an empty array if none are found.
      */
-    getObjectsFromElementId(id: number): any;
+    getElementsFromId(id: number): any;
     /**
      * Retrieves the Vim object associated with the given Vim element index.
      * @param {number} element - The index of the Vim element.
-     * @returns {Object3D | undefined} The Vim object corresponding to the element index, or undefined if not found.
+     * @returns {WebglElement3D | undefined} The Vim object corresponding to the element index, or undefined if not found.
      */
-    getObjectFromElement(element: number): Object3D | undefined;
-    /**
-     * Retrieves an array containing all Vim objects strictly contained within the specified bounding box.
-     * @param {THREE.Box3} box - The bounding box to search within.
-     * @returns {Object3D[]} An array of Vim objects strictly contained within the bounding box.
-     */
-    getObjectsInBox(box: THREE.Box3): Object3D[];
+    getElementFromIndex(element: number): Element3D | undefined;
     /**
      * Retrieves an array of all objects within the Vim.
-     * @returns {Object3D[]} An array containing all objects within the Vim.
+     * @returns {WebglElement3D[]} An array containing all objects within the Vim.
      */
-    getObjects(): Object3D[];
+    getAllElements(): Element3D[];
     /**
      * Retrieves an array containing all objects within the specified subset.
      * @param {G3dSubset} subset - The subset to retrieve objects from.
-     * @returns {Object3D[]} An array of objects within the specified subset.
+     * @returns {WebglElement3D[]} An array of objects within the specified subset.
      */
-    getObjectsInSubset(subset: G3dSubset): Object3D[];
+    getObjectsInSubset(subset: G3dSubset): Element3D[];
     /**
      * Retrieves all instances as a subset.
      * @returns {G3dSubset} A subset containing all instances.

package/dist/types/core-viewers/webgl/loader/vimSettings.d.ts

@@ -49,7 +49,7 @@ export type VimSettings = {
 /**
  * Default configuration settings for a vim object.
  */
-export declare const defaultConfig: VimSettings;
+export declare function getDefaultVimSettings(): VimSettings;
 /**
  * Represents a partial configuration of settings for a vim object.
  */
@@ -59,4 +59,4 @@ export type VimPartialSettings = Partial<VimSettings>;
  * @param {VimPartialSettings} [options] - Optional partial settings for the Vim object.
  * @returns {VimSettings} The complete settings for the Vim object, including defaults.
  */
-export declare function getFullSettings(options?: VimPartialSettings): VimSettings;
+export declare function createVimSettings(options?: VimPartialSettings): VimSettings;

package/dist/types/core-viewers/webgl/loader/{objectAttributes.d.ts → webglAttribute.d.ts}

@@ -2,16 +2,16 @@
  * @module vim-loader
  */
 import { SimpleInstanceSubmesh, Submesh } from './mesh';
-export type AttributeTarget = Submesh | SimpleInstanceSubmesh;
-export declare class ObjectAttribute<T> {
+export type WebglAttributeTarget = Submesh | SimpleInstanceSubmesh;
+export declare class WebglAttribute<T> {
     readonly vertexAttribute: string;
     readonly instanceAttribute: string;
     readonly defaultValue: T;
     readonly toNumber: (value: T) => number;
     private _value;
     private _meshes;
-    constructor(value: T, vertexAttribute: string, instanceAttribute: string, meshes: AttributeTarget[] | undefined, toNumber: (value: T) => number);
-    updateMeshes(meshes: AttributeTarget[] | undefined): void;
+    constructor(value: T, vertexAttribute: string, instanceAttribute: string, meshes: WebglAttributeTarget[] | undefined, toNumber: (value: T) => number);
+    updateMeshes(meshes: WebglAttributeTarget[] | undefined): void;
     get value(): T;
     apply(value: T): boolean;
     private applyInstanced;

package/dist/types/core-viewers/webgl/viewer/camera/camera.d.ts

@@ -2,125 +2,26 @@
  * @module viw-webgl-viewer/camera
  */
 import * as THREE from 'three';
-import { Viewport } from '../viewport';
-import { ViewerSettings } from '../settings/viewerSettings';
-import { RenderScene } from '../rendering/renderScene';
 import { ISignal } from 'ste-signals';
-import { PerspectiveWrapper } from './perspective';
-import { OrthographicWrapper } from './orthographic';
+import { RenderScene } from '../rendering/renderScene';
+import { ViewerSettings } from '../settings/viewerSettings';
+import { Viewport } from '../viewport';
+import { ICamera } from './cameraInterface';
 import { CameraMovement } from './cameraMovement';
-/**
- * Interface representing a camera with various properties and methods for controlling its behavior.
- */
-export interface ICamera {
-    /**
-     * A signal that is dispatched when camera settings change.
-     */
-    onSettingsChanged: ISignal;
-    /**
-     * A signal that is dispatched when camera moves.
-     */
-    onMoved: ISignal;
-    /**
-     * True if the camera has moved this frame.
-     */
-    get hasMoved(): boolean;
-    /**
-     * Represents allowed movement along each axis using a Vector3 object.
-     * Each component of the Vector3 should be either 0 or 1 to enable/disable movement along the corresponding axis.
-     */
-    allowedMovement: THREE.Vector3;
-    /**
-     * Represents allowed rotation using a Vector2 object.
-     * Each component of the Vector2 should be either 0 or 1 to enable/disable rotation around the corresponding axis.
-     */
-    allowedRotation: THREE.Vector2;
-    /**
-     * The default forward direction that can be used to initialize the camera.
-     */
-    defaultForward: THREE.Vector3;
-    /**
-     * Interface for instantaneously moving the camera.
-     * @param {boolean} [force=false] - Set to true to ignore locked axis and rotation.
-     * @returns {CameraMovement} The camera movement api.
-     */
-    snap(force?: boolean): CameraMovement;
-    /**
-     * Interface for smoothly moving the camera over time.
-     * @param {number} [duration=1] - The duration of the camera movement animation.
-     * @param {boolean} [force=false] - Set to true to ignore locked axis and rotation.
-     * @returns {CameraMovement} The camera movement api.
-     */
-    lerp(duration: number, force?: boolean): CameraMovement;
-    /**
-     * Calculates the frustum size at a given point in the scene.
-     * @param {THREE.Vector3} point - The point in the scene to calculate the frustum size at.
-     * @returns {number} The frustum size at the specified point.
-     */
-    frustrumSizeAt(point: THREE.Vector3): THREE.Vector2;
-    /**
-     * The current THREE Camera
-     */
-    get three(): THREE.Camera;
-    /**
-     * The quaternion representing the orientation of the object.
-     */
-    get quaternion(): THREE.Quaternion;
-    /**
-    * The position of the camera.
-    */
-    get position(): THREE.Vector3;
-    /**
-     * The matrix representing the transformation of the camera.
-     */
-    get matrix(): THREE.Matrix4;
-    /**
-     * The forward direction of the camera.
-     */
-    get forward(): THREE.Vector3;
-    get isLerping(): boolean;
-    /**
-     * The camera speed factor.
-     */
-    speed: number;
-    /**
-     * The current or target velocity of the camera.
-     */
-    localVelocity: THREE.Vector3;
-    /**
-     * Immediately stops the camera movement.
-     */
-    stop(): void;
-    /**
-     * The target at which the camera is looking at and around which it rotates.
-     */
-    get target(): THREE.Vector3;
-    /**
-     * The distance from the camera to the target.
-     */
-    get orbitDistance(): number;
-    /**
-     * Saves current camera orientation to restore on next reset.
-     */
-    save(): void;
-    /**
-     * Represents whether the camera projection is orthographic.
-     */
-    orthographic: boolean;
-}
+import { OrthographicCamera } from './cameraOrthographic';
+import { PerspectiveCamera } from './cameraPerspective';
 /**
  * Manages viewer camera movement and position
  */
 export declare class Camera implements ICamera {
-    camPerspective: PerspectiveWrapper;
-    camOrthographic: OrthographicWrapper;
+    camPerspective: PerspectiveCamera;
+    camOrthographic: OrthographicCamera;
     private _viewport;
-    _scene: RenderScene;
+    private _scene;
     private _lerp;
     private _movement;
     private _inputVelocity;
     private _velocity;
-    private _speed;
     private _orthographic;
     private _target;
     private _lastPosition;
@@ -128,8 +29,7 @@ export declare class Camera implements ICamera {
     private _lastTarget;
     private _tmp1;
     private _tmp2;
-    _savedPosition: THREE.Vector3;
-    _savedTarget: THREE.Vector3;
+    private _savedState;
     /**
      * A signal that is dispatched when camera settings change.
      */
@@ -169,7 +69,6 @@ export declare class Camera implements ICamera {
     get defaultForward(): THREE.Vector3;
     set defaultForward(value: THREE.Vector3);
     private _velocityBlendFactor;
-    private _moveSpeed;
     constructor(scene: RenderScene, viewport: Viewport, settings: ViewerSettings);
     /**
      * Interface for instantaneously moving the camera.
@@ -210,11 +109,6 @@ export declare class Camera implements ICamera {
      * The forward direction of the camera.
      */
     get forward(): THREE.Vector3;
-    /**
-     * The camera speed factor.
-     */
-    get speed(): number;
-    set speed(value: number);
     /**
      * The current or target velocity of the camera.
      */
@@ -231,7 +125,7 @@ export declare class Camera implements ICamera {
      * The target at which the camera is looking at and around which it rotates.
      */
     get target(): THREE.Vector3;
-    applySettings(settings: ViewerSettings): void;
+    private applySettings;
     /**
      * The distance from the camera to the target.
      */

package/dist/types/core-viewers/webgl/viewer/camera/{ICamera.d.ts → cameraInterface.d.ts}

@@ -71,10 +71,6 @@ export interface ICamera {
      */
     get forward(): THREE.Vector3;
     get isLerping(): boolean;
-    /**
-     * The camera speed factor.
-     */
-    speed: number;
     /**
      * The current or target velocity of the camera.
      */
@@ -100,3 +96,12 @@ export interface ICamera {
      */
     orthographic: boolean;
 }
+export declare class CameraSaveState {
+    private _camera;
+    private _position;
+    private _target;
+    constructor(camera: ICamera);
+    save(): void;
+    get position(): THREE.Vector3;
+    get target(): THREE.Vector3;
+}