vim-web 0.3.23 → 0.3.25

package/dist/types/webgl-viewer/vim-loader/scene.d.ts

@@ -0,0 +1,92 @@
+/**
+ * @module vim-loader
+ */
+import * as THREE from 'three';
+import { Mesh, Submesh } from './mesh';
+import { Vim } from './vim';
+import { InsertableMesh } from './progressive/insertableMesh';
+import { InstancedMesh } from './progressive/instancedMesh';
+/**
+ * Interface for a renderer object, providing methods to add and remove objects from a scene, update bounding boxes, and notify scene updates.
+ */
+export interface IRenderer {
+    add(scene: Scene | THREE.Object3D): any;
+    remove(scene: Scene): any;
+    updateBox(box: THREE.Box3): any;
+    notifySceneUpdate(): any;
+}
+/**
+ * Represents a scene that contains multiple meshes.
+ * It tracks the global bounding box as meshes are added and maintains a mapping between g3d instance indices and meshes.
+ */
+export declare class Scene {
+    private _renderer;
+    private _vim;
+    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.
+     */
+    getBoundingBox(target?: THREE.Box3): THREE.Box3;
+    /**
+     * Returns the bounding box of the average center of all meshes.
+     * Less precise but is more stable against outliers.
+     */
+    getAverageBoundingBox(): THREE.Box3;
+    updateBox(box: THREE.Box3): void;
+    getMemory(): number;
+    /**
+     * Returns the THREE.Mesh in which this instance is represented along with index
+     * For merged mesh, index refers to submesh index
+     * For instanced mesh, index refers to instance index.
+     */
+    getMeshFromInstance(instance: number): Submesh[];
+    getMeshesFromInstances(instances: number[] | undefined): Submesh[];
+    get renderer(): IRenderer;
+    set renderer(value: IRenderer);
+    get vim(): Vim;
+    /**
+     * Sets vim index for this scene and all its THREE.Meshes.
+     */
+    set vim(value: Vim);
+    addSubmesh(submesh: Submesh): void;
+    /**
+     * Add an instanced mesh to the Scene and recomputes fields as needed.
+     * @param mesh Is expected to have:
+     * userData.instances = number[] (indices of the g3d instances that went into creating the mesh)
+     * userData.boxes = THREE.Box3[] (bounding box of each instance)
+     */
+    addMesh(mesh: Mesh | InsertableMesh | InstancedMesh): this;
+    /**
+     * Adds the content of other Scene to this Scene and recomputes fields as needed.
+     */
+    merge(other: Scene): this;
+    /**
+     * Gets the current material override or undefined if none.
+     */
+    get material(): THREE.Material | undefined;
+    /**
+     * Sets and apply a material override to the scene, set to undefined to remove override.
+     */
+    set material(value: THREE.Material | undefined);
+    /**
+     * Unloads and disposes all meshes and leaves the scene ready to add new ones.
+     */
+    clear(): void;
+    /**
+     * Disposes of all resources.
+     */
+    dispose(): void;
+}

package/dist/types/webgl-viewer/vim-loader/vim.d.ts

@@ -0,0 +1,157 @@
+/**
+ * @module vim-loader
+ */
+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 { 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';
+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 {
+    /**
+     * Indicates whether the vim was opened from a vim or vimx file.
+     */
+    readonly format: VimFormat;
+    /**
+     * Indicates the url this vim came from if applicable.
+     */
+    readonly source: string | undefined;
+    /**
+     * The header for this vim.
+     */
+    readonly header: VimHeader | undefined;
+    /**
+     * The interface to access bim data related to this vim if available.
+     */
+    readonly bim: VimDocument | undefined;
+    /**
+     * The raw g3d geometry scene definition.
+     */
+    readonly g3d: G3d | undefined;
+    /**
+     * The settings used when this vim was opened.
+     */
+    readonly settings: VimSettings;
+    /**
+     * Mostly Internal - The scene in which the vim geometry is added.
+     */
+    readonly scene: Scene;
+    /**
+     * The mapping from Bim to Geometry for this vim.
+     */
+    readonly map: ElementMapping | ElementNoMapping | ElementMapping2;
+    private readonly _builder;
+    private readonly _loadedInstances;
+    private readonly _elementToObject;
+    /**
+     * Getter for accessing the event dispatched whenever a subset begins or finishes loading.
+     * @returns {ISignal} The event dispatcher for loading updates.
+     */
+    get onLoadingUpdate(): ISignal;
+    /**
+     * Indicates whether there are subsets currently being loaded.
+     * @returns {boolean} True if subsets are being loaded; otherwise, false.
+     */
+    get isLoading(): boolean;
+    /**
+     * Getter for accessing the signal dispatched when the object is disposed.
+     * @returns {ISignal} The signal for disposal events.
+     */
+    get onDispose(): ISignal;
+    private _onDispose;
+    /**
+   * Constructs a new instance of a Vim object with the provided parameters.
+   * @param {VimHeader | undefined} header - The Vim header, if available.
+   * @param {VimDocument} document - The Vim document.
+   * @param {G3d | undefined} g3d - The G3d object, if available.
+   * @param {Scene} scene - The scene containing the vim's geometry.
+   * @param {VimSettings} settings - The settings used to open this vim.
+   * @param {ElementMapping | ElementNoMapping | ElementMapping2} map - The element mapping.
+   * @param {SubsetBuilder} builder - The subset builder for constructing subsets of the Vim object.
+   * @param {string} source - The source of the Vim object.
+   * @param {VimFormat} format - The format of the Vim object.
+   * @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);
+    /**
+     * Retrieves the matrix representation of the Vim object's position, rotation, and scale.
+     * @returns {THREE.Matrix4} The matrix representing the Vim object's transformation.
+     */
+    getMatrix(): THREE.Matrix4;
+    /**
+     * Retrieves the object associated with the specified instance number.
+     * @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;
+    /**
+     * 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;
+    /**
+     * 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.
+     */
+    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[];
+    /**
+     * Retrieves an array of all objects within the Vim.
+     * @returns {Object3D[]} An array containing all objects within the Vim.
+     */
+    getObjects(): Object3D[];
+    /**
+     * 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.
+     */
+    getObjectsInSubset(subset: G3dSubset): Object3D[];
+    /**
+     * Retrieves all instances as a subset.
+     * @returns {G3dSubset} A subset containing all instances.
+     */
+    getFullSet(): G3dSubset;
+    /**
+     * Asynchronously loads all geometry according to the provided settings.
+     * @param {LoadPartialSettings} [settings] - Optional settings for the loading process.
+     */
+    loadAll(settings?: LoadPartialSettings): Promise<void>;
+    /**
+     * Asynchronously loads geometry for the specified subset according to the provided settings.
+     * @param {G3dSubset} subset - The subset to load resources for.
+     * @param {LoadPartialSettings} [settings] - Optional settings for the loading process.
+     */
+    loadSubset(subset: G3dSubset, settings?: LoadPartialSettings): Promise<void>;
+    /**
+     * Asynchronously loads geometry based on a specified filter mode and criteria.
+     * @param {FilterMode} filterMode - The mode of filtering to apply.
+     * @param {number[]} filter - The filter criteria.
+     * @param {LoadPartialSettings} [settings] - Optional settings for the loading process.
+     */
+    loadFilter(filterMode: FilterMode, filter: number[], settings?: LoadPartialSettings): Promise<void>;
+    /**
+     * Removes the current geometry from the renderer.
+     */
+    clear(): void;
+    /**
+     * Cleans up and releases resources associated with the vim.
+     */
+    dispose(): void;
+}
+export {};

package/dist/types/webgl-viewer/vim-loader/vimSettings.d.ts

@@ -0,0 +1,62 @@
+/**
+ * @module vim-loader
+ */
+import { Transparency } from './geometry';
+import * as THREE from 'three';
+export type FileType = 'vim' | 'vimx' | undefined;
+/**
+ * Represents settings for configuring the behavior and rendering of a vim object.
+ */
+export type VimSettings = {
+    /**
+     * The positional offset for the vim object.
+     */
+    position: THREE.Vector3;
+    /**
+     * The XYZ rotation applied to the vim object.
+     */
+    rotation: THREE.Vector3;
+    /**
+     * The scaling factor applied to the vim object.
+     */
+    scale: number;
+    /**
+     * The matrix representation of the vim object's position, rotation, and scale.
+     * Setting this will override individual position, rotation, and scale properties.
+     */
+    matrix: THREE.Matrix4;
+    /**
+     * Determines whether objects are drawn based on their transparency.
+     */
+    transparency: Transparency.Mode;
+    /**
+     * Set to true to enable verbose HTTP logging.
+     */
+    verboseHttp: boolean;
+    /**
+     * Specifies the file type (vim or vimx) if it cannot or should not be inferred from the file extension.
+     */
+    fileType: FileType;
+    /**
+     * Set to true to stream geometry to the scene. Only supported with vimx files.
+     */
+    progressive: boolean;
+    /**
+     * The time in milliseconds between each scene refresh during progressive loading.
+     */
+    progressiveInterval: number;
+};
+/**
+ * Default configuration settings for a vim object.
+ */
+export declare const defaultConfig: VimSettings;
+/**
+ * Represents a partial configuration of settings for a vim object.
+ */
+export type VimPartialSettings = Partial<VimSettings>;
+/**
+ * Wraps Vim options, converting values to related THREE.js types and providing default values.
+ * @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;

package/dist/types/webgl-viewer/vim-webgl-viewer/camera/camera.d.ts

@@ -0,0 +1,255 @@
+/**
+ * @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 { 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;
+}
+/**
+ * Manages viewer camera movement and position
+ */
+export declare class Camera implements ICamera {
+    camPerspective: PerspectiveWrapper;
+    camOrthographic: OrthographicWrapper;
+    private _viewport;
+    _scene: RenderScene;
+    private _lerp;
+    private _movement;
+    private _inputVelocity;
+    private _velocity;
+    private _speed;
+    private _orthographic;
+    private _target;
+    private _lastPosition;
+    private _lastQuaternion;
+    private _lastTarget;
+    private _tmp1;
+    private _tmp2;
+    _savedPosition: THREE.Vector3;
+    _savedTarget: THREE.Vector3;
+    /**
+     * A signal that is dispatched when camera settings change.
+     */
+    get onSettingsChanged(): ISignal;
+    private _onValueChanged;
+    /**
+     * True if the camera has moved this frame.
+     */
+    get hasMoved(): boolean;
+    private _hasMoved;
+    get isLerping(): boolean;
+    /**
+     * A signal that is dispatched when the camera is moved.
+     */
+    get onMoved(): ISignal;
+    private _onMoved;
+    /** Ignore movement permissions when true */
+    private _force;
+    /**
+     * 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.
+     */
+    private _allowedMovement;
+    get allowedMovement(): THREE.Vector3;
+    set allowedMovement(axes: 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.
+     */
+    get allowedRotation(): THREE.Vector2;
+    set allowedRotation(axes: THREE.Vector2);
+    private _allowedRotation;
+    /**
+     * The default forward direction that can be used to initialize the camera.
+     */
+    private _defaultForward;
+    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.
+     * @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.PerspectiveCamera | THREE.OrthographicCamera;
+    /**
+     * 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;
+    /**
+     * The camera speed factor.
+     */
+    get speed(): number;
+    set speed(value: number);
+    /**
+     * The current or target velocity of the camera.
+     */
+    get localVelocity(): THREE.Vector3;
+    /**
+     * The current or target velocity of the camera.
+     */
+    set localVelocity(vector: 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;
+    applySettings(settings: ViewerSettings): void;
+    /**
+     * 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.
+     */
+    get orthographic(): boolean;
+    set orthographic(value: boolean);
+    update(deltaTime: number): boolean;
+    private updateProjection;
+    private updateOrthographic;
+    private applyVelocity;
+    private getVelocityMultiplier;
+    private checkForMovement;
+    private applyVelocityOrthographic;
+}

package/dist/types/webgl-viewer/vim-webgl-viewer/camera/cameraMovement.d.ts

@@ -0,0 +1,77 @@
+/**
+ * @module viw-webgl-viewer/camera
+ */
+import { Camera } from './camera';
+import { Object3D } from '../../vim-loader/object3D';
+import { SelectableObject } from '../selection';
+import * as THREE from 'three';
+import { Vim } from '../../vim-loader/vim';
+export declare abstract class CameraMovement {
+    protected _camera: Camera;
+    constructor(camera: Camera);
+    /**
+     * Moves the camera by the specified 3D vector.
+     * @param {THREE.Vector3} vector - The 3D vector representing the direction and distance of movement.
+     */
+    abstract move3(vector: THREE.Vector3): void;
+    /**
+     * Moves the camera in a specified 2D direction within a plane defined by the given axes.
+     * @param {THREE.Vector2} vector - The 2D vector representing the direction of movement.
+     * @param {'XY' | 'XZ'} axes - The axes defining the plane of movement ('XY' or 'XZ').
+     */
+    move2(vector: THREE.Vector2, axes: 'XY' | 'XZ'): void;
+    /**
+     * Moves the camera along a specified axis by a given amount.
+     * @param {number} amount - The amount to move the camera.
+     * @param {'X' | 'Y' | 'Z'} axis - The axis along which to move the camera ('X', 'Y', or 'Z').
+     */
+    move1(amount: number, axis: 'X' | 'Y' | 'Z'): void;
+    /**
+     * Rotates the camera by the specified angles.
+     * @param {THREE.Vector2} angle - The 2D vector representing the rotation angles around the X and Y axes.
+     */
+    abstract rotate(angle: THREE.Vector2): void;
+    /**
+     * Changes the distance between the camera and its target by a specified factor.
+     * @param {number} amount - The factor by which to change the distance (e.g., 0.5 for halving the distance, 2 for doubling the distance).
+     */
+    abstract zoom(amount: number): void;
+    /**
+     * Sets the distance between the camera and its target to the specified value.
+     * @param {number} dist - The new distance between the camera and its target.
+     */
+    abstract setDistance(dist: number): void;
+    /**
+     * Orbits the camera around its target by the given angle while maintaining the distance.
+     * @param {THREE.Vector2} vector - The 2D vector representing the orbit angles around the X and Y axes.
+     */
+    abstract orbit(vector: THREE.Vector2): void;
+    /**
+     * Orbits the camera around its target to align with the given direction.
+     * @param {THREE.Vector3} direction - The direction towards which the camera should be oriented.
+     */
+    orbitTowards(direction: THREE.Vector3): void;
+    /**
+     * Rotates the camera without moving so that it looks at the specified target.
+     * @param {Object3D | THREE.Vector3} target - The target object or position to look at.
+     */
+    abstract target(target: Object3D | THREE.Vector3): void;
+    /**
+     * Resets the camera to its last saved position and orientation.
+     */
+    abstract reset(): void;
+    /**
+     * Moves both the camera and its target to the given positions.
+     * @param {THREE.Vector3} position - The new position of the camera.
+     * @param {THREE.Vector3 | undefined} [target] - The new position of the target (optional).
+     */
+    abstract set(position: THREE.Vector3, target?: THREE.Vector3): any;
+    /**
+     * Sets the camera's orientation and position to focus on the specified target.
+     * @param {IObject | Vim | THREE.Sphere | THREE.Box3 | 'all' | undefined} target - The target object, or 'all' to frame all objects.
+     * @param {THREE.Vector3} [forward] - Optional forward direction after framing.
+     */
+    frame(target: SelectableObject | Vim | THREE.Sphere | THREE.Box3 | 'all' | undefined, forward?: THREE.Vector3): void;
+    protected frameSphere(sphere: THREE.Sphere, forward?: THREE.Vector3): void;
+    private getNormalizedDirection;
+}

package/dist/types/webgl-viewer/vim-webgl-viewer/camera/cameraMovementLerp.d.ts

@@ -0,0 +1,28 @@
+/**
+ * @module viw-webgl-viewer/camera
+ */
+import * as THREE from 'three';
+import { Camera } from './camera';
+import { Object3D } from '../../vim-loader/object3D';
+import { CameraMovementSnap } from './cameraMovementSnap';
+import { CameraMovement } from './cameraMovement';
+export declare class CameraLerp extends CameraMovement {
+    _movement: CameraMovementSnap;
+    _clock: THREE.Clock;
+    onProgress: ((progress: number) => void) | undefined;
+    _duration: number;
+    constructor(camera: Camera, movement: CameraMovementSnap);
+    get isLerping(): boolean;
+    init(duration: number): void;
+    cancel(): void;
+    easeOutCubic(x: number): number;
+    update(): void;
+    move3(vector: THREE.Vector3): void;
+    rotate(angle: THREE.Vector2): void;
+    zoom(amount: number): void;
+    setDistance(dist: number): void;
+    orbit(angle: THREE.Vector2): void;
+    target(target: Object3D | THREE.Vector3): void;
+    reset(): void;
+    set(position: THREE.Vector3, target?: THREE.Vector3): void;
+}