@giro3d/giro3d

import { Box3, type Camera, EventDispatcher, Frustum, Matrix4, Object3D, type OrthographicCamera, PerspectiveCamera, Sphere } from 'three'; import { type OBB } from 'three/examples/jsm/Addons.js'; import type Disposable from '../core/Disposable'; import type CoordinateSystem from '../core/geographic/CoordinateSystem'; import type HasDefaultPointOfView from '../core/HasDefaultPointOfView'; import type PointOfView from '../core/PointOfView'; import Coordinates from '../core/geographic/Coordinates'; export interface ExternalControls extends EventDispatcher<{ change: unknown; }> { update(): void; } export declare const DEFAULT_MIN_NEAR_PLANE = 2; export declare const DEFAULT_MAX_FAR_PLANE = 2000000000; interface ViewEvents { change: unknown; } /** * Returns the distance from the center of the bounding sphere so * that the perspective camera's frustum view fits the sphere. * @param camera - The perspective camera. * @param radius - The sphere radius. */ export declare function computeDistanceToFitSphere(camera: PerspectiveCamera, radius: number): number; /** * Computes the zoom value so that the sphere fits in the orthographic camera's frustum. * @param camera - The orthographic camera. * @param radius - The sphere radius. */ export declare function computeZoomToFitSphere(camera: OrthographicCamera, radius: number): number; /** * Represent the users's point of view. Internally this encapsulate a three.js camera. */ declare class View extends EventDispatcher<ViewEvents> implements Disposable { private readonly _coordinateSystem; private readonly _viewMatrix; private _camera; private _width; private _height; private _preSSE; private _maxFar; private _minNear; private _controls; private _onControlsUpdated; private _frustum; /** * The width, in pixels, of this view. */ get width(): number; /** * The height, in pixels, of this view. */ get height(): number; /** * Gets or sets the current camera. */ get camera(): PerspectiveCamera | OrthographicCamera; set camera(c: PerspectiveCamera | OrthographicCamera); /** * @param params - The constructor parameters. */ constructor(params: { /** The coordinate system of the view. */ crs: CoordinateSystem; /** The width in pixels of the camera viewport */ width: number; /** The height in pixels of the camera viewport */ height: number; /** The three.js camera to use. If unspecified, a default perspective camera is created. */ camera?: PerspectiveCamera | OrthographicCamera; }); get crs(): CoordinateSystem; get preSSE(): number; set preSSE(value: number); get viewMatrix(): Matrix4; get near(): number; get frustum(): Readonly<Frustum>; /** * Gets or sets the distance to the near plane. The distance will be clamped to be within * the bounds defined by {@link minNearPlane} and {@link maxFarPlane}. */ set near(distance: number); get far(): number; /** * Gets or sets the distance to the far plane. The distance will be clamped to be within * the bounds defined by {@link minNearPlane} and {@link maxFarPlane}. */ set far(distance: number); /** * Gets or sets the maximum distance allowed for the camera far plane. */ get maxFarPlane(): number; set maxFarPlane(distance: number); /** * Gets or sets the minimum distance allowed for the camera near plane. */ get minNearPlane(): number; set minNearPlane(distance: number); /** * Gets the currently registered controls, if any. * * Note: To register controls, use {@link setControls}. */ get controls(): ExternalControls | null; /** * Registers external controls that must be udpated periodically. * * Note: this is the case of simple controls in the `examples/{js,jsm}/controls` folder * of THREE.js (e.g `MapControls`): * * - they fire `'change'` events when the controls' state has changed and the view must be rendered, * - they have an `update()` method to update the controls' state. * * For more complex controls, such as the package [`camera-controls`](https://www.npmjs.com/package/camera-controls), * a more complex logic is required. Please refer to the appropriate examples for a detailed * documentation on how to bind Giro3D and those controls. * * @param controls - The controls to register. If `null`, currently registered controls * are unregistered (they are not disabled however). */ setControls(controls: ExternalControls | null): void; /** * Resets the near and far planes to their default value. */ resetPlanes(): void; /** * @internal */ update(): void; setSize(width?: number, height?: number): void; /** * Return the position in the requested CRS, or in camera's CRS if undefined. * * @param crs - if defined (e.g 'EPSG:4236') the camera position will be * returned in this CRS * @returns Coordinates object holding camera's position */ position(crs?: CoordinateSystem): Coordinates; isOBBVisible(worldOBB: OBB): boolean; isBox3Visible(box3: Box3, matrixWorld?: Matrix4): boolean; isSphereVisible(sphere: Sphere, matrixWorld?: Matrix4): boolean; box3SizeOnScreen(box3: Box3, matrixWorld: Matrix4): Box3; /** * Returns the "up" vector at a given coordinates. * * The "up" vector is generally used to orient objects and cameras. * * If a custom function was specified in the constructor of the instance, this will be used. * * Otherwise, the default implementation is used: * * - For projected coordinate systems, this is equal to the vertical axis (typically Z). * - For the ECEF geocentric coordinate system (EPSG:4878), this is equal to the normal * of the WGS84 ellipsoid at this location. * * @param coordinate - The coordinate of the point for which to compute the vector. * @param target - The vector to store the result. If unspecified, a new one is created. * @returns The up vector at this location. */ private getUpVector; /** * Computes a {@link PointOfView} for the given object. * @param obj - The object to compute the point of view, or a world space bounding box. * @param options - Optional parameters. * @returns The readonly point of view if it could be computed, `null` otherwise. */ getDefaultPointOfView(obj: Object3D | Box3, options?: { /** * The optional camera to compute this point of view. * If unspecified, the currently active camera on this view is used. */ camera?: Camera; }): Readonly<PointOfView> | null; private applyPointOfView; /** * Setup the camera to match the specified object or point of view. * * - If the argument is a {@link PointOfView}, this will be used directly. * - If the object implements {@link HasDefaultPointOfView}, this will be used to compute the point of view. * - Otherwise, a default point of view is computed from the object's bounding box. * * **Important note:** this method does not update any camera controls that are controlling the camera. * Those controls have to be updated manually so they do not override the new camera position. For example, * controls that have a target must be updated so that the target position matches the one returned by this method. * @param obj - The object to go to. * @param options - The options. * @returns The immutable {@link PointOfView} that was used to setup the camera, or `null` if it couldn't be computed. */ goTo(obj: Object3D | HasDefaultPointOfView | PointOfView, options?: { /** * Allow moving the camera. If `false`, the camera is only rotated to look at the object. * @defaultValue true */ allowTranslation?: boolean; }): Readonly<PointOfView> | null; private projectBox3PointsInCameraSpace; dispose(): void; } export default View; //# sourceMappingURL=View.d.ts.map