@thatopen/components 2.4.11 → 3.1.1

package/dist/core/Cullers/src/mesh-culler-renderer.d.ts

@@ -1,59 +0,0 @@
-import * as THREE from "three";
-import { CullerRenderer } from "./culler-renderer";
-import { Components } from "../../Components";
-import { Event, World, Disposable } from "../../Types";
-/**
- * A renderer to hide/show meshes depending on their visibility from the user's point of view.
- */
-export declare class MeshCullerRenderer extends CullerRenderer implements Disposable {
-    /**
-     * Event triggered when the visibility of meshes is updated.
-     * Contains two sets: seen and unseen.
-     */
-    readonly onViewUpdated: Event<{
-        seen: Set<THREE.Mesh>;
-        unseen: Set<THREE.Mesh>;
-    }>;
-    /**
-     * Map of color code to THREE.InstancedMesh.
-     * Used to keep track of color-coded meshes.
-     */
-    colorMeshes: Map<string, THREE.InstancedMesh<THREE.BufferGeometry<THREE.NormalBufferAttributes>, THREE.Material | THREE.Material[], THREE.InstancedMeshEventMap>>;
-    /**
-     * @deprecated use config.threshold instead.
-     */
-    get threshold(): number;
-    /**
-     * @deprecated use config.threshold instead.
-     */
-    set threshold(value: number);
-    private _colorCodeMeshMap;
-    private _meshIDColorCodeMap;
-    private _currentVisibleMeshes;
-    private _recentlyHiddenMeshes;
-    private readonly _transparentMat;
-    constructor(components: Components, world: World);
-    /** {@link Disposable.dispose} */
-    dispose(): void;
-    /**
-     * Adds a mesh to the culler. When the mesh is not visibile anymore, it will be removed from the scene. When it's visible again, it will be added to the scene.
-     * @param mesh - The mesh to add. It can be a regular THREE.Mesh or an instance of THREE.InstancedMesh.
-     */
-    add(mesh: THREE.Mesh | THREE.InstancedMesh): void;
-    /**
-     * Removes a mesh from the culler, so its visibility is not controlled by the culler anymore.
-     * When the mesh is removed, it will be hidden from the scene and its color-coded mesh will be destroyed.
-     * @param mesh - The mesh to remove. It can be a regular THREE.Mesh or an instance of THREE.InstancedMesh.
-     */
-    remove(mesh: THREE.Mesh | THREE.InstancedMesh): void;
-    /**
-     * Updates the given instanced meshes inside the culler. You should use this if you change the count property, e.g. when changing the visibility of fragments.
-     *
-     * @param meshes - The meshes to update.
-     *
-     * @returns {void}
-     */
-    updateInstanced(meshes: Iterable<THREE.InstancedMesh>): void;
-    private handleWorkerMessage;
-    private getAvailableMaterial;
-}

package/dist/core/Cullers/src/screen-culler-helper.d.ts

@@ -1 +0,0 @@
-export declare function readPixelsAsync(gl: WebGL2RenderingContext, x: number, y: number, w: number, h: number, format: any, type: any, dest: ArrayBufferView): Promise<ArrayBufferView>;

package/dist/core/Disposer/index.d.ts

@@ -1,45 +0,0 @@
-import * as THREE from "three";
-import { Components } from "../Components";
-import { Component } from "../Types";
-/**
- * A tool to safely remove meshes, geometries, materials and other items from memory to [prevent memory leaks](https://threejs.org/docs/#manual/en/introduction/How-to-dispose-of-objects).
- */
-export declare class Disposer extends Component {
-    private _disposedComponents;
-    /** {@link Component.enabled} */
-    enabled: boolean;
-    /**
-     * A unique identifier for the component.
-     * This UUID is used to register the component within the Components system.
-     */
-    static readonly uuid: "76e9cd8e-ad8f-4753-9ef6-cbc60f7247fe";
-    constructor(components: Components);
-    /**
-     * Return the UUIDs of all disposed components.
-     */
-    get(): Set<string>;
-    /**
-     * Removes a mesh, its geometry and its materials from memory. If you are
-     * using any of these in other parts of the application, make sure that you
-     * remove them from the mesh before disposing it.
-     *
-     * @param object - the [object](https://threejs.org/docs/#api/en/core/Object3D)
-     * to remove.
-     *
-     * @param materials - whether to dispose the materials of the mesh.
-     *
-     * @param recursive - whether to recursively dispose the children of the mesh.
-     */
-    destroy(object: THREE.Object3D, materials?: boolean, recursive?: boolean): void;
-    /**
-     * Disposes a geometry from memory.
-     *
-     * @param geometry - the
-     * [geometry](https://threejs.org/docs/#api/en/core/BufferGeometry)
-     * to remove.
-     */
-    disposeGeometry(geometry: THREE.BufferGeometry): void;
-    private disposeGeometryAndMaterials;
-    private disposeChildren;
-    private static disposeMaterial;
-}

package/dist/core/Grids/index.d.ts

@@ -1,46 +0,0 @@
-import { Component, Disposable, World, Event } from "../Types";
-import { SimpleGrid } from "./src";
-import { Components } from "../Components";
-export * from "./src";
-/**
- * A component that manages grid instances. Each grid is associated with a unique world. 📕 [Tutorial](https://docs.thatopen.com/Tutorials/Components/Core/Grids). 📘 [API](https://docs.thatopen.com/api/@thatopen/components/classes/Grids).
- */
-export declare class Grids extends Component implements Disposable {
-    /**
-     * A unique identifier for the component.
-     * This UUID is used to register the component within the Components system.
-     */
-    static readonly uuid: "d1e814d5-b81c-4452-87a2-f039375e0489";
-    /**
-     * A map of world UUIDs to their corresponding grid instances.
-     */
-    list: Map<string, SimpleGrid>;
-    /** {@link Disposable.onDisposed} */
-    readonly onDisposed: Event<unknown>;
-    /** {@link Component.enabled} */
-    enabled: boolean;
-    constructor(components: Components);
-    /**
-     * Creates a new grid for the given world.
-     * Throws an error if a grid already exists for the world.
-     *
-     * @param world - The world to create the grid for.
-     * @returns The newly created grid.
-     *
-     * @throws Will throw an error if a grid already exists for the given world.
-     */
-    create(world: World): SimpleGrid;
-    /**
-     * Deletes the grid associated with the given world.
-     * If a grid does not exist for the given world, this method does nothing.
-     *
-     * @param world - The world for which to delete the grid.
-     *
-     * @remarks
-     * This method will dispose of the grid and remove it from the internal list.
-     * If the world is disposed before calling this method, the grid will be automatically deleted.
-     */
-    delete(world: World): void;
-    /** {@link Disposable.dispose} */
-    dispose(): void;
-}

package/dist/core/Grids/src/index.d.ts

@@ -1,2 +0,0 @@
-export * from "./simple-grid";
-export * from "./simple-grid-config";

package/dist/core/Grids/src/simple-grid-config.d.ts

@@ -1,80 +0,0 @@
-import * as THREE from "three";
-import { BooleanSettingsControl, ColorSettingsControl, NumberSettingControl } from "../../Types";
-import { Configurator } from "../../ConfigManager";
-import { SimpleGrid } from "./simple-grid";
-type SimpleGridConfigType = {
-    visible: BooleanSettingsControl;
-    color: ColorSettingsControl;
-    primarySize: NumberSettingControl;
-    secondarySize: NumberSettingControl;
-    distance: NumberSettingControl;
-};
-/**
- * Configuration interface for the {@link SimpleGrid}.
- */
-export interface SimpleGridConfig {
-    /**
-     * Whether the grid is visible or not.
-     */
-    visible: boolean;
-    /**
-     * The color of the grid lines.
-     */
-    color: THREE.Color;
-    /**
-     * The size of the primary grid lines.
-     */
-    primarySize: number;
-    /**
-     * The size of the secondary grid lines.
-     */
-    secondarySize: number;
-    /**
-     * The distance at which the grid lines start to fade away.
-     */
-    distance: number;
-}
-export declare class SimpleGridConfigManager extends Configurator<SimpleGrid, SimpleGridConfigType> {
-    protected _config: SimpleGridConfigType;
-    /**
-     * Whether the grid is visible or not.
-     */
-    get visible(): boolean;
-    /**
-     * Whether the grid is visible or not.
-     */
-    set visible(value: boolean);
-    /**
-     * The color of the grid lines.
-     */
-    get color(): THREE.Color;
-    /**
-     * The color of the grid lines.
-     */
-    set color(value: THREE.Color);
-    /**
-     * The size of the primary grid lines.
-     */
-    get primarySize(): number;
-    /**
-     * The size of the primary grid lines.
-     */
-    set primarySize(value: number);
-    /**
-     * The size of the secondary grid lines.
-     */
-    get secondarySize(): number;
-    /**
-     * The size of the secondary grid lines.
-     */
-    set secondarySize(value: number);
-    /**
-     * The distance at which the grid lines start to fade away.
-     */
-    get distance(): number;
-    /**
-     * The distance at which the grid lines start to fade away.
-     */
-    set distance(value: number);
-}
-export {};

package/dist/core/Grids/src/simple-grid.d.ts

@@ -1,48 +0,0 @@
-import * as THREE from "three";
-import { Hideable, Event, World, Disposable, Configurable } from "../../Types";
-import { Components } from "../../Components";
-import { SimpleGridConfig, SimpleGridConfigManager } from "./simple-grid-config";
-/**
- * An infinite grid. Created by [fyrestar](https://github.com/Fyrestar/THREE.InfiniteGridHelper) and translated to typescript by [dkaraush](https://github.com/dkaraush/THREE.InfiniteGridHelper/blob/master/InfiniteGridHelper.ts).
- */
-export declare class SimpleGrid implements Hideable, Disposable, Configurable<SimpleGridConfigManager, SimpleGridConfig> {
-    /** {@link Disposable.onDisposed} */
-    readonly onDisposed: Event<unknown>;
-    /** {@link Configurable.onSetup} */
-    readonly onSetup: Event<unknown>;
-    /** {@link Configurable.isSetup} */
-    isSetup: boolean;
-    /** The world instance to which this Raycaster belongs. */
-    world: World;
-    /** The components instance to which this grid belongs. */
-    components: Components;
-    /** {@link Configurable.config} */
-    config: SimpleGridConfigManager;
-    protected _defaultConfig: SimpleGridConfig;
-    /** {@link Hideable.visible} */
-    get visible(): boolean;
-    /** {@link Hideable.visible} */
-    set visible(visible: boolean);
-    /** The material of the grid. */
-    get material(): THREE.ShaderMaterial;
-    /**
-     * Whether the grid should fade away with distance. Recommended to be true for
-     * perspective cameras and false for orthographic cameras.
-     */
-    get fade(): boolean;
-    /**
-     * Whether the grid should fade away with distance. Recommended to be true for
-     * perspective cameras and false for orthographic cameras.
-     */
-    set fade(active: boolean);
-    /** The Three.js mesh that contains the infinite grid. */
-    readonly three: THREE.Mesh;
-    private _fade;
-    constructor(components: Components, world: World);
-    /** {@link Configurable.setup} */
-    setup(config?: Partial<SimpleGridConfig>): void;
-    /** {@link Disposable.dispose} */
-    dispose(): void;
-    private setupEvents;
-    private updateZoom;
-}

package/dist/core/MiniMap/index.d.ts

@@ -1,50 +0,0 @@
-import { MiniMap } from "./src";
-import { Component, Updateable, World, Event, Disposable } from "../Types";
-import { Components } from "../Components";
-export * from "./src";
-/**
- * A component that manages multiple {@link MiniMap} instances, each associated with a unique world ID. 📕 [Tutorial](https://docs.thatopen.com/Tutorials/Components/Core/MiniMap). 📘 [API](https://docs.thatopen.com/api/@thatopen/components/classes/MiniMaps).
- */
-export declare class MiniMaps extends Component implements Updateable, Disposable {
-    /**
-     * A unique identifier for the component.
-     * This UUID is used to register the component within the Components system.
-     */
-    static readonly uuid: "39ad6aad-84c8-4adf-a1e0-7f25313a9e7f";
-    /** {@link Updateable.onAfterUpdate} */
-    readonly onAfterUpdate: Event<unknown>;
-    /** {@link Updateable.onBeforeUpdate} */
-    readonly onBeforeUpdate: Event<unknown>;
-    /** {@link Disposable.onDisposed} */
-    readonly onDisposed: Event<unknown>;
-    /** {@link Configurable.onSetup} */
-    readonly onSetup: Event<unknown>;
-    /** {@link Component.enabled} */
-    enabled: boolean;
-    /**
-     * A collection of {@link MiniMap} instances, each associated with a unique world ID.
-     */
-    list: Map<string, MiniMap>;
-    constructor(components: Components);
-    /**
-     * Creates a new {@link MiniMap} instance associated with the given world.
-     * If a {@link MiniMap} instance already exists for the given world, an error will be thrown.
-     *
-     * @param world - The {@link World} for which to create a {@link MiniMap} instance.
-     * @returns The newly created {@link MiniMap} instance.
-     * @throws Will throw an error if a {@link MiniMap} instance already exists for the given world.
-     */
-    create(world: World): MiniMap;
-    /**
-     * Deletes a {@link MiniMap} instance associated with the given world ID.
-     * If a {@link MiniMap} instance does not exist for the given ID, nothing happens.
-     *
-     * @param id - The unique identifier of the world for which to delete the {@link MiniMap} instance.
-     * @returns {void}
-     */
-    delete(id: string): void;
-    /** {@link Disposable.dispose} */
-    dispose(): void;
-    /** {@link Updateable.update} */
-    update(): void;
-}

package/dist/core/MiniMap/src/index.d.ts

@@ -1,2 +0,0 @@
-export * from "./mini-map";
-export * from "./mini-map-config";

package/dist/core/MiniMap/src/mini-map-config.d.ts

@@ -1,112 +0,0 @@
-import * as THREE from "three";
-import { BooleanSettingsControl, ColorSettingsControl, NumberSettingControl } from "../../Types";
-import { Configurator } from "../../ConfigManager";
-import { MiniMap } from "./index";
-type MiniMapConfigType = {
-    visible: BooleanSettingsControl;
-    lockRotation: BooleanSettingsControl;
-    zoom: NumberSettingControl;
-    frontOffset: NumberSettingControl;
-    sizeX: NumberSettingControl;
-    sizeY: NumberSettingControl;
-    backgroundColor: ColorSettingsControl;
-};
-/**
- * Configuration interface for the {@link MiniMap}.
- */
-export interface MiniMapConfig {
-    /**
-     * Whether the minimap is visible or not.
-     */
-    visible: boolean;
-    /**
-     * Whether to lock the rotation of the top camera in the minimap.
-     */
-    lockRotation: boolean;
-    /**
-     * The zoom of the camera in the minimap.
-     */
-    zoom: number;
-    /**
-     * The front offset of the minimap.
-     * It determines how much the minimap's view is offset from the camera's view.
-     * By pushing the map to the front, what the user sees on screen corresponds with what they see on the map
-     */
-    frontOffset: number;
-    /**
-     * The horizontal dimension of the minimap.
-     */
-    sizeX: number;
-    /**
-     * The vertical dimension of the minimap.
-     */
-    sizeY: number;
-    /**
-     * The color of the background of the minimap.
-     */
-    backgroundColor: THREE.Color;
-}
-export declare class MiniMapConfigManager extends Configurator<MiniMap, MiniMapConfigType> {
-    protected _config: MiniMapConfigType;
-    /**
-     * Whether the minimap is visible or not.
-     */
-    get visible(): boolean;
-    /**
-     * Whether the minimap is visible or not.
-     */
-    set visible(value: boolean);
-    /**
-     * Whether to lock the rotation of the top camera in the minimap.
-     */
-    get lockRotation(): boolean;
-    /**
-     * Whether to lock the rotation of the top camera in the minimap.
-     */
-    set lockRotation(value: boolean);
-    /**
-     * The zoom of the camera in the minimap.
-     */
-    get zoom(): number;
-    /**
-     * The zoom of the camera in the minimap.
-     */
-    set zoom(value: number);
-    /**
-     * The front offset of the minimap.
-     * It determines how much the minimap's view is offset from the camera's view.
-     * By pushing the map to the front, what the user sees on screen corresponds with what they see on the map
-     */
-    get frontOffset(): number;
-    /**
-     * The front offset of the minimap.
-     * It determines how much the minimap's view is offset from the camera's view.
-     * By pushing the map to the front, what the user sees on screen corresponds with what they see on the map
-     */
-    set frontOffset(value: number);
-    /**
-     * The horizontal dimension of the minimap.
-     */
-    get sizeX(): number;
-    /**
-     * The horizontal dimension of the minimap.
-     */
-    set sizeX(value: number);
-    /**
-     * The vertical dimension of the minimap.
-     */
-    get sizeY(): number;
-    /**
-     * The vertical dimension of the minimap.
-     */
-    set sizeY(value: number);
-    /**
-     * The color of the background of the minimap.
-     */
-    get backgroundColor(): THREE.Color;
-    /**
-     * The color of the background of the minimap.
-     */
-    set backgroundColor(value: THREE.Color);
-}
-export {};

package/dist/core/MiniMap/src/mini-map.d.ts

@@ -1,100 +0,0 @@
-import * as THREE from "three";
-import { Resizeable, Updateable, World, Event, Disposable, Configurable } from "../../Types";
-import { MiniMapConfig, MiniMapConfigManager } from "./mini-map-config";
-import { Components } from "../../Components";
-/**
- * A class representing a 2D minimap of a 3D world.
- */
-export declare class MiniMap implements Resizeable, Updateable, Disposable, Configurable<MiniMapConfigManager, MiniMapConfig> {
-    /** {@link Disposable.onDisposed} */
-    readonly onDisposed: Event<unknown>;
-    /** {@link Updateable.onAfterUpdate} */
-    readonly onAfterUpdate: Event<unknown>;
-    /** {@link Updateable.onBeforeUpdate} */
-    readonly onBeforeUpdate: Event<unknown>;
-    /** {@link Resizeable.onResize} */
-    readonly onResize: Event<THREE.Vector2>;
-    /** {@link Configurable.onSetup} */
-    readonly onSetup: Event<unknown>;
-    /**
-     * The front offset of the minimap.
-     * It determines how much the minimap's view is offset from the camera's view.
-     * By pushing the map to the front, what the user sees on screen corresponds with what they see on the map
-     */
-    frontOffset: number;
-    /**
-     * The override material for the minimap.
-     * It is used to render the depth information of the world onto the minimap.
-     */
-    overrideMaterial: THREE.MeshDepthMaterial;
-    /**
-     * The background color of the minimap.
-     * It is used to set the background color of the minimap's renderer.
-     */
-    backgroundColor: THREE.Color;
-    /**
-     * The WebGL renderer for the minimap.
-     * It is used to render the minimap onto the screen.
-     */
-    renderer: THREE.WebGLRenderer;
-    /**
-     * A flag indicating whether the minimap is enabled.
-     * If disabled, the minimap will not update or render.
-     */
-    enabled: boolean;
-    /**
-     * The world in which the minimap is displayed.
-     * It provides access to the 3D scene, camera, and other relevant world elements.
-     */
-    world: World;
-    /** {@link Configurable.config} */
-    config: MiniMapConfigManager;
-    /** {@link Configurable.isSetup} */
-    isSetup: boolean;
-    protected _defaultConfig: MiniMapConfig;
-    private _lockRotation;
-    private _size;
-    private _camera;
-    private _plane;
-    private _tempVector1;
-    private _tempVector2;
-    private _tempTarget;
-    private readonly down;
-    /**
-     * Gets or sets whether the minimap rotation is locked.
-     * When rotation is locked, the minimap will always face the same direction as the camera.
-     */
-    get lockRotation(): boolean;
-    /**
-     * Sets whether the minimap rotation is locked.
-     * When rotation is locked, the minimap will always face the same direction as the camera.
-     * @param active - If `true`, rotation is locked. If `false`, rotation is not locked.
-     */
-    set lockRotation(active: boolean);
-    /**
-     * Gets the current zoom level of the minimap.
-     * The zoom level determines how much of the world is visible on the minimap.
-     * @returns The current zoom level of the minimap.
-     */
-    get zoom(): number;
-    /**
-     * Sets the zoom level of the minimap.
-     * The zoom level determines how much of the world is visible on the minimap.
-     * @param value - The new zoom level of the minimap.
-     */
-    set zoom(value: number);
-    constructor(world: World, components: Components);
-    /** {@link Disposable.dispose} */
-    dispose(): void;
-    /** Returns the camera used by the MiniMap */
-    get(): THREE.OrthographicCamera;
-    /** {@link Updateable.update} */
-    update(): void;
-    /** {@link Resizeable.getSize} */
-    getSize(): THREE.Vector2;
-    /** {@link Resizeable.resize} */
-    resize(size?: THREE.Vector2): void;
-    /** {@link Configurable.setup} */
-    setup(config?: Partial<MiniMapConfig>): void;
-    private updatePlanes;
-}

package/dist/core/OrthoPerspectiveCamera/index.d.ts

@@ -1,65 +0,0 @@
-import * as THREE from "three";
-import { Components } from "../Components";
-import { SimpleCamera } from "..";
-import { NavigationMode, NavModeID, ProjectionManager } from "./src";
-export * from "./src";
-/**
- * A flexible camera that uses [yomotsu's cameracontrols](https://github.com/yomotsu/camera-controls) to control the camera in 2D and 3D. It supports multiple navigation modes, such as 2D floor plan navigation, first person and 3D orbit. This class extends the SimpleCamera class and adds additional functionality for managing different camera projections and navigation modes. 📕 [Tutorial](https://docs.thatopen.com/Tutorials/Components/Core/OrthoPerspectiveCamera). 📘 [API](https://docs.thatopen.com/api/@thatopen/components/classes/OrthoPerspectiveCamera).
- */
-export declare class OrthoPerspectiveCamera extends SimpleCamera {
-    /**
-     * A ProjectionManager instance that manages the projection modes of the camera.
-     */
-    readonly projection: ProjectionManager;
-    /**
-     * A THREE.OrthographicCamera instance that represents the orthographic camera.
-     * This camera is used when the projection mode is set to orthographic.
-     */
-    readonly threeOrtho: THREE.OrthographicCamera;
-    /**
-     * A THREE.PerspectiveCamera instance that represents the perspective camera.
-     * This camera is used when the projection mode is set to perspective.
-     */
-    readonly threePersp: THREE.PerspectiveCamera;
-    protected readonly _userInputButtons: any;
-    protected readonly _frustumSize = 50;
-    protected readonly _navigationModes: Map<NavModeID, NavigationMode>;
-    protected _mode: NavigationMode | null;
-    private previousSize;
-    /**
-     * Getter for the current navigation mode.
-     * Throws an error if the mode is not found or the camera is not initialized.
-     *
-     * @returns {NavigationMode} The current navigation mode.
-     *
-     * @throws {Error} Throws an error if the mode is not found or the camera is not initialized.
-     */
-    get mode(): NavigationMode;
-    constructor(components: Components);
-    /** {@link Disposable.dispose} */
-    dispose(): void;
-    /**
-     * Sets a new {@link NavigationMode} and disables the previous one.
-     *
-     * @param mode - The {@link NavigationMode} to set.
-     */
-    set(mode: NavModeID): void;
-    /**
-     * Make the camera view fit all the specified meshes.
-     *
-     * @param meshes the meshes to fit. If it is not defined, it will
-     * evaluate {@link Components.meshes}.
-     * @param offset the distance to the fit object
-     */
-    fit(meshes: Iterable<THREE.Mesh>, offset?: number): Promise<void>;
-    /**
-     * Allows or prevents all user input.
-     *
-     * @param active - whether to enable or disable user inputs.
-     */
-    setUserInput(active: boolean): void;
-    private disableUserInput;
-    private enableUserInput;
-    private newOrthoCamera;
-    private setOrthoPerspCameraAspect;
-}

package/dist/core/OrthoPerspectiveCamera/src/first-person-mode.d.ts

@@ -1,16 +0,0 @@
-import { NavigationMode } from "./types";
-import { OrthoPerspectiveCamera } from "../index";
-/**
- * A {@link NavigationMode} that allows first person navigation, simulating FPS video games.
- */
-export declare class FirstPersonMode implements NavigationMode {
-    private camera;
-    /** {@link NavigationMode.enabled} */
-    enabled: boolean;
-    /** {@link NavigationMode.id} */
-    readonly id = "FirstPerson";
-    constructor(camera: OrthoPerspectiveCamera);
-    /** {@link NavigationMode.set} */
-    set(active: boolean): void;
-    private setupFirstPersonCamera;
-}

package/dist/core/OrthoPerspectiveCamera/src/index.d.ts

@@ -1,5 +0,0 @@
-export * from "./first-person-mode";
-export * from "./orbit-mode";
-export * from "./plan-mode";
-export * from "./projections";
-export * from "./types";

package/dist/core/OrthoPerspectiveCamera/src/orbit-mode.d.ts

@@ -1,16 +0,0 @@
-import { NavigationMode } from "./types";
-import { OrthoPerspectiveCamera } from "../index";
-/**
- * A {@link NavigationMode} that allows 3D navigation and panning like in many 3D and CAD softwares.
- */
-export declare class OrbitMode implements NavigationMode {
-    camera: OrthoPerspectiveCamera;
-    /** {@link NavigationMode.enabled} */
-    enabled: boolean;
-    /** {@link NavigationMode.id} */
-    readonly id = "Orbit";
-    constructor(camera: OrthoPerspectiveCamera);
-    /** {@link NavigationMode.set} */
-    set(active: boolean): void;
-    private activateOrbitControls;
-}