@openglobus/og 1.0.0-rc2 → 1.0.0-rc21

package/lib/control/FreeNavigation.d.ts

@@ -0,0 +1,253 @@
+import type { IControlParams } from "./Control";
+import { Control } from "./Control";
+import type { IMouseState } from "../renderer/RendererEvents";
+import { Navigation } from "./Navigation";
+import type { Vec2 } from "../math/Vec2";
+import { Vec3 } from "../math/Vec3";
+import { type EventsHandler } from "../Events";
+export interface IFreeNavigationParams extends IControlParams {
+    speed?: number;
+    minSpeed?: number;
+    maxSpeed?: number;
+    speedStep?: number;
+    speedFactor?: number;
+    lookSensitivity?: number;
+    rollSpeed?: number;
+    accelerationTime?: number;
+    decelerationTime?: number;
+    pitchLimit?: number;
+    invertY?: boolean;
+    pointerLock?: boolean;
+    toggleKey?: number;
+    showInfo?: boolean;
+}
+export type FreeNavigationEventsList = ["move", "rotate", "speedchange", "activate", "deactivate"];
+/**
+ * Free-flight camera navigation.
+ *
+ * - W/S — move forward/backward
+ * - A/D — strafe left/right
+ * - Space/Ctrl — increase/decrease altitude
+ * - Shift — hold to move without changing the camera height above the ellipsoid
+ * - Q/E — roll
+ * - Mouse — look around
+ * - Mouse wheel — adjust movement speed
+ * - Right mouse button — hold to keep the point under the screen center in the center
+ * - F — activate and deactivate the control, see `toggleKey`
+ *
+ * Yaw follows the local ellipsoid normal, while pitch uses the camera's right vector.
+ * The camera preserves its orientation relative to the local horizon while moving.
+ *
+ * By default, pointer lock allows unrestricted mouse rotation. Pressing Escape releases
+ * the pointer and deactivates the control. Set `pointerLock` to `false` to use regular
+ * mouse movement instead.
+ *
+ * The control conflicts with the {@link Navigation} control, so an active {@link Navigation}
+ * is deactivated while the free navigation is active, and restored back on deactivation.
+ *
+ * @class
+ * @extends {Control}
+ * @param {IFreeNavigationParams} [options] - Free navigation options:
+ * @param {number} [options.speed] - Initial selected movement speed in m/s. Default is 0
+ * @param {number} [options.minSpeed] - Minimal selected movement speed in m/s. Default is -300
+ * @param {number} [options.maxSpeed] - Maximal selected movement speed in m/s. Default is 1000000
+ * @param {number} [options.speedStep] - Mouse wheel speed step near the zero speed in m/s. Default is 1
+ * @param {number} [options.speedFactor] - Relative speed increment per one mouse wheel step. Default is 0.45
+ * @param {number} [options.lookSensitivity] - Camera rotation angle in radians per mouse move pixel
+ * @param {number} [options.rollSpeed] - Q/E roll angular speed in radians per second the smoothed
+ * roll velocity approaches
+ * @param {number} [options.accelerationTime] - Acceleration smoothing time in seconds. Default is 0.6
+ * @param {number} [options.decelerationTime] - Deceleration smoothing time in seconds. Default is 0.4
+ * @param {number} [options.pitchLimit] - Maximal pitch angle above and below the local horizon in radians
+ * @param {boolean} [options.invertY] - Inverts vertical mouse rotation direction. Default is false
+ * @param {boolean} [options.pointerLock] - Locks and hides the mouse pointer. Default is true
+ * @param {number} [options.toggleKey] - Key code which activates and deactivates the control,
+ * it works while the control is inactive as well. Zero disables it. Default is `input.KEY_F`
+ * @param {boolean} [options.showInfo] - Shows the movement speed and the key hint. Default is false
+ * @fires move
+ * @fires rotate
+ * @fires speedchange
+ * @fires activate
+ * @fires deactivate
+ */
+export declare class FreeNavigation extends Control {
+    events: EventsHandler<FreeNavigationEventsList>;
+    minSpeed: number;
+    maxSpeed: number;
+    speedStep: number;
+    speedFactor: number;
+    lookSensitivity: number;
+    rollSpeed: number;
+    accelerationTime: number;
+    decelerationTime: number;
+    pitchLimit: number;
+    invertY: boolean;
+    pointerLock: boolean;
+    toggleKey: number;
+    /**
+     * Current camera velocity in meters per second.
+     * @public
+     * @type {Vec3}
+     */
+    vel: Vec3;
+    /**
+     * Current camera roll angular velocity in radians per second.
+     * @public
+     * @type {number}
+     */
+    rollVel: number;
+    /**
+     * Selected movement speed in meters per second.
+     * @protected
+     * @type {number}
+     */
+    protected _speed: number;
+    protected _moveForward: boolean;
+    protected _moveBackward: boolean;
+    protected _moveLeft: boolean;
+    protected _moveRight: boolean;
+    protected _moveUp: boolean;
+    protected _moveDown: boolean;
+    protected _rollDir: number;
+    protected _dx: number;
+    protected _dy: number;
+    protected _skipPointerMove: boolean;
+    protected _targetPoint: Vec3 | null;
+    protected _targetRequest: number;
+    protected _holdHeight: number | null;
+    protected _lastFrameTime: number;
+    protected _frameDeltaTime: number;
+    protected _infoEl: HTMLElement | null;
+    protected _suspendedNavigation: Navigation[];
+    constructor(options?: IFreeNavigationParams);
+    onadd(): void;
+    oninit(): void;
+    onremove(): void;
+    /**
+     * Activates the control when it is inactive and deactivates it otherwise.
+     * @public
+     */
+    toggle(): void;
+    protected _onToggleKey: () => void;
+    protected _updateInfo(): void;
+    onactivate(): void;
+    ondeactivate(): void;
+    /**
+     * Returns selected movement speed in meters per second.
+     * @public
+     * @return {number} -
+     */
+    get speed(): number;
+    /**
+     * Sets selected movement speed in meters per second.
+     * @public
+     * @param {number} speed - Speed in m/s.
+     */
+    set speed(speed: number);
+    /**
+     * Sets selected movement speed in meters per second, clamped to the min and max speed.
+     * @public
+     * @param {number} speed - Speed in m/s.
+     */
+    setSpeed(speed: number): void;
+    /**
+     * Changes the movement speed by the given number of wheel steps.
+     *
+     * The speed step increases with the current speed. Changes are reversible,
+     * and zero speed is always reachable.
+     * @public
+     * @param {number} steps - Number of the wheel steps, negative decreases the speed.
+     */
+    stepSpeed(steps: number): void;
+    /**
+     * True when the mouse pointer is locked by the control.
+     * @public
+     * @return {boolean} -
+     */
+    isPointerLocked(): boolean;
+    /**
+     * Locks and hides the mouse pointer over the canvas.
+     * @public
+     */
+    requestPointerLock(): void;
+    /**
+     * Releases the mouse pointer.
+     * @public
+     */
+    exitPointerLock(): void;
+    /**
+     * Locked target point in the cartesian coordinates, or null when no target is locked.
+     * @public
+     * @return {Vec3 | null} -
+     */
+    get targetPoint(): Vec3 | null;
+    /**
+     * Locks the target point, so the camera keeps looking at it wherever it moves,
+     * @public
+     * @param {Vec3} [point] - Target point in the cartesian coordinates.
+     */
+    lockTarget(point?: Vec3 | null): void;
+    /**
+     * Releases the locked target point.
+     * @public
+     */
+    unlockTarget(): void;
+    /**
+     * Stops the camera movement and releases the locked target point.
+     * @public
+     */
+    stop(): void;
+    protected onPreDraw(): void;
+    protected _hasInput(): boolean;
+    protected _resetInput(): void;
+    private _onCameraFly;
+    protected _onMouseMove: (e: IMouseState) => void;
+    protected _onLockedMouseMove: (e: MouseEvent) => void;
+    protected _onPointerLockChange: () => void;
+    protected _onLDown: () => void;
+    protected _onRDown: () => void;
+    protected _onRUp: () => void;
+    protected _onKeyEscape: () => void;
+    protected _onMouseLeave: () => void;
+    protected _onMouseWheel: (e: IMouseState) => void;
+    protected _onKeyForward: () => void;
+    protected _onKeyBackward: () => void;
+    protected _onKeyLeft: () => void;
+    protected _onKeyRight: () => void;
+    protected _onKeyUp: () => void;
+    protected _onKeyDown: () => void;
+    protected _onKeyRollLeft: () => void;
+    protected _onKeyRollRight: () => void;
+    protected _getLocalUp(eye: Vec3): Vec3;
+    protected _getTargetPixel(): Vec2;
+    protected _pickTargetPoint(px: Vec2): Vec3 | null;
+    protected _handleTargetLock(): void;
+    protected _handleRotation(): void;
+    /**
+     * Clamps the pitch rotation angle.
+     * @protected
+     * @param {number} angle - Pitch angle in radians.
+     * @param {Vec3} forward - Camera forward vector.
+     * @param {Vec3} right - Camera right vector.
+     * @param {Vec3} localUp - Local reference frame up direction.
+     * @return {number} - Applicable pitch angle in radians.
+     */
+    protected _limitPitch(angle: number, forward: Vec3, right: Vec3, localUp: Vec3): number;
+    /**
+     * Rollls the camera around its forward axis and keeps its angular velocity smoothed.
+     * @protected
+     */
+    protected _handleRoll(): void;
+    protected _orthonormalizeCamera(): void;
+    /**
+     * Moves the camera and keeps its orientation in the local reference frame.
+     * @protected
+     */
+    protected _handleMove(): void;
+    protected _isHeightHold(): boolean;
+    protected _handleHeightHold(): void;
+    protected _suspendNavigation(): void;
+    protected _restoreNavigation(): void;
+    protected _updateFrameDeltaTime(): void;
+    protected get dt(): number;
+}

package/lib/control/LayerSwitcher.d.ts

@@ -1,6 +1,7 @@
 import { Control } from "./Control";
 import type { IControlParams } from "./Control";
 import { Dialog } from "../ui/Dialog";
+import { EmptyTerrain } from "../terrain/EmptyTerrain";
 import { Layer } from "../layer/Layer";
 import { ToggleButton } from "../ui/ToggleButton";
 import { View } from "../ui/View";
@@ -15,6 +16,17 @@ declare class LayerButtonView extends View<Layer> {
     protected _onDblClick: () => void;
     remove(): void;
 }
+interface ITerrainButtonParams extends IViewParams {
+    model: EmptyTerrain;
+    onClick: (terrain: EmptyTerrain) => void;
+}
+declare class TerrainButtonView extends View<EmptyTerrain> {
+    protected _onClickCallback: (terrain: EmptyTerrain) => void;
+    constructor(params: ITerrainButtonParams);
+    render(params?: any): this;
+    setActive(isActive: boolean): void;
+    protected _onClick: () => void;
+}
 /**
  * Advanced :) layer switcher, includes base layers, overlays, geo images etc. groups.
  * Double click for zoom, drag-and-drop to change zIndex
@@ -23,11 +35,17 @@ export declare class LayerSwitcher extends Control {
     protected _dialog: Dialog<null>;
     protected _toggleBtn: ToggleButton;
     protected _panel: View<null>;
+    $terrains: HTMLElement | null;
     $baseLayers: HTMLElement | null;
     $overlays: HTMLElement | null;
     _layerViews: LayerButtonView[];
+    _terrainViews: TerrainButtonView[];
     constructor(options?: ILayerSwitcherParams);
     oninit(): void;
+    protected _initTerrains(): void;
+    protected _onTerrainChange: () => void;
+    addTerrain: (terrain: EmptyTerrain) => void;
+    removeTerrain: (terrain: EmptyTerrain) => void;
     protected _initLayers(): void;
     protected _createLayerButton(layer: Layer): LayerButtonView;
     protected _findLayerView(layer: Layer): LayerButtonView | null;

package/lib/control/Lighting.d.ts

@@ -18,10 +18,12 @@ export declare class Lighting extends Control {
     protected _panel: View<null>;
     protected _atmosphereMaxOpacity: Slider;
     protected _atmosphereMinOpacity: Slider;
+    protected _atmosphereOpacityCurveShift: Slider;
     protected _simpleSkyBackgroundColorOne: Color;
     protected _simpleSkyBackgroundColorTwo: Color;
     protected _gamma: Slider;
     protected _exposure: Slider;
+    protected _whitepoint: Slider;
     protected _night: Slider;
     protected _opacity: Slider;
     protected _diffuse_r: Slider;
@@ -36,6 +38,7 @@ export declare class Lighting extends Control {
     protected _shininess: Slider;
     $gamma: HTMLElement | null;
     $exposure: HTMLElement | null;
+    $whitepoint: HTMLElement | null;
     $night: HTMLElement | null;
     $opacity: HTMLElement | null;
     $diffuse: HTMLElement | null;

package/lib/control/Navigation.d.ts

@@ -9,6 +9,9 @@ import { type EventsHandler } from "../Events";
 export type NavigationMode = "north" | "adaptive" | "free";
 export interface INavigationParams extends IControlParams {
     inertia?: number;
+    minInertia?: number;
+    maxInertia?: number;
+    minInertiaAltitude?: number;
     velInertia?: number;
     dragInertia?: number;
     minSlope?: number;
@@ -27,6 +30,9 @@ export type NavigationEventsList = ["drag", "zoom", "rotate"];
  * @param {INavigationParams} [options] - Navigation options:
  * @param {NavigationMode} [options.mode] - Navigation mode: "north" (keeps north fixed), "adaptive" (default, auto-detects arc mode), "free" (arc rotation mode)
  * @param {number} [options.inertia] - inertia factor
+ * @param {number} [options.minInertia] - inertia factor at minInertiaAltitude. Default is 1
+ * @param {number} [options.maxInertia] - inertia factor at maximal camera altitude. Default is 1.1
+ * @param {number} [options.minInertiaAltitude] - minimal altitude where inertia interpolation starts. Default is 3000000
  * @param {number} [options.velInertia] - base velocity inertia factor. Default is 0.89
  * @param {number} [options.dragInertia] - drag inertia
  * @param {number} [options.mass] - camera mass, affects velocity. Default is 1
@@ -48,6 +54,9 @@ export declare class Navigation extends Control {
     mass: number;
     minSlope: number;
     inertia: number;
+    minInertia: number;
+    maxInertia: number;
+    minInertiaAltitude: number;
     dragInertia: number;
     zoomSpeed: number;
     poleThreshold: number;
@@ -67,6 +76,7 @@ export declare class Navigation extends Control {
     protected _grabbedSphere: Sphere;
     protected _wheelDirection: number;
     protected _currScreenPos: Vec2;
+    protected _grabbedScreenPoint: Vec2;
     protected _tUp: Vec3;
     protected _tRad: number;
     protected _shiftBusy: boolean;
@@ -89,7 +99,13 @@ export declare class Navigation extends Control {
     onremove(): void;
     onactivate(): void;
     ondeactivate(): void;
-    protected onDraw(): void;
+    protected onPreDraw(): void;
+    /**
+     * Returns true while the inertia has not been damped yet.
+     * @public
+     * @returns {boolean}
+     */
+    isMoving(): boolean;
     _onShiftFree: () => void;
     private _onCameraFly;
     protected _onMouseMove: (e: IMouseState) => void;
@@ -120,5 +136,6 @@ export declare class Navigation extends Control {
     protected _updateVel_roll(): void;
     protected get dt(): number;
     protected get velocityInertia(): number;
+    protected _calcInertia(): number;
     stop(): void;
 }

package/lib/control/ShowFps.d.ts

@@ -1,10 +1,22 @@
+import { Button } from "../ui/Button";
 import { Control } from "./Control";
 import type { IControlParams } from "./Control";
 /**
- * Frame per second(FPS) display control.
+ * Frames per second(FPS) display control. It looks like a map button in the top right
+ * corner and shows the current frame rate instead of an icon.
+ *
+ * Note that the rate is measured by the control itself and not taken from
+ * {@link Handler#deltaTime}, which is clamped and does not represent the real frame time.
+ * @class
+ * @extends {Control}
  */
 export declare class ShowFps extends Control {
-    constructor(options: IControlParams);
+    protected _btn: Button | null;
+    protected _text: HTMLElement | null;
+    protected _frames: number;
+    protected _measureStart: number;
+    constructor(options?: IControlParams);
     oninit(): void;
-    protected _draw(): void;
+    onremove(): void;
+    protected _draw: () => void;
 }

package/lib/control/Sun.d.ts

@@ -1,22 +1,48 @@
 import { Control } from "./Control";
 import type { IControlParams } from "./Control";
 import { Clock } from "../Clock";
+import type { JulianDate } from "../astro/jd";
 import { Vec3 } from "../math/Vec3";
+import type { PlanetCamera } from "../camera/PlanetCamera";
 interface ISunParams extends IControlParams {
     activationHeight?: number;
     offsetVertical?: number;
     offsetHorizontal?: number;
     stopped?: boolean;
+    localDateTime?: Date | null;
 }
 /**
  * Real Sun geocentric position control that place the Sun on the right place by the Earth.
+ * @class
+ *
+ * @example <caption>Lighting frozen at 21:30 local solar time under the camera</caption>
+ * new Sun({ localDateTime: new Date(2026, 7, 3, 21, 30) })
+ *
+ * @param {ISunParams} [options] - Options:
+ * @param {number} [options.activationHeight=12079000.0] - Camera height above which the Sun takes its real position by the clock.
+ * @param {number} [options.offsetVertical=-5000000] - Vertical offset of the camera following light.
+ * @param {number} [options.offsetHorizontal=5000000] - Horizontal offset of the camera following light.
+ * @param {boolean} [options.stopped=false] - Stops the control, leaving the Sun on its real position by the clock.
+ * @param {Date} [options.localDateTime] - Lights the scene by the local apparent solar time under the camera
+ * instead of the camera following light. At 12:00 the Sun stands on the meridian there, while the date sets the
+ * season. Read by its UTC clock, so it is not an instant in time but the numbers a wall clock shows: build it
+ * with Date.UTC. While it is set it drives the light at any height, whether the control is stopped or not, and
+ * the Clock is left untouched.
  */
 export declare class Sun extends Control {
     activationHeight: number;
     offsetVertical: number;
     offsetHorizontal: number;
+    /**
+     * Local apparent solar time under the camera, read by its UTC clock,
+     * or null for the camera following light.
+     * @public
+     * @type {Date | null}
+     */
+    localDateTime: Date | null;
     protected _currDate: number;
     protected _prevDate: number;
+    protected _redrawDate: number;
     protected _clockPtr: Clock | null;
     protected _lightOn: boolean;
     protected _stopped: boolean;
@@ -25,12 +51,45 @@ export declare class Sun extends Control {
     protected _sunlightPosition: Vec3;
     constructor(options?: ISunParams);
     oninit(): void;
+    protected _onClockTick: () => void;
     stop(): void;
     start(): void;
     onactivate(): void;
     bindClock(clock: Clock): void;
     getPosition(): Vec3;
+    /**
+     * Sets the local apparent solar time under the camera, read by its UTC clock.
+     * @public
+     * @param {Date | null} localDateTime - Local date and time, or null to restore the camera following light.
+     */
+    setLocalDateTime(localDateTime: Date | null): void;
     protected _setSunPosition3v(position: Vec3): void;
+    /**
+     * Returns a light position offset from the camera along its own up and right axes,
+     * so that nearby terrain is lit regardless of the real Sun direction.
+     * @protected
+     * @param {PlanetCamera} cam - Planet camera.
+     * @returns {Vec3} -
+     */
+    protected _getCameraFollowingPosition(cam: PlanetCamera): Vec3;
+    /**
+     * Returns the julian date at which the clock of the given one, read as UTC, is the local apparent
+     * solar time at lon. Local mean solar time is the first guess, then the measured subsolar longitude
+     * corrects it; that point drifts -360 degrees a day, so a residual of d degrees is worth -d / 360
+     * of a day.
+     * @protected
+     * @param {JulianDate} utc - Julian date to take the clock of.
+     * @param {number} lon - Longitude under the camera, degrees.
+     * @returns {JulianDate} -
+     */
+    protected _getLocalJulian(utc: JulianDate, lon: number): JulianDate;
+    /**
+     * Returns the Sun position for localDateTime at the location under the camera.
+     * @protected
+     * @param {PlanetCamera} cam - Planet camera.
+     * @returns {Vec3} -
+     */
+    protected _getLocalDateTimePosition(cam: PlanetCamera): Vec3;
     protected _draw(): void;
 }
 export {};

package/lib/control/depthCamera/DepthCamera.d.ts

@@ -0,0 +1,132 @@
+import { Camera } from "../../camera/Camera";
+import { PlanetCamera } from "../../camera/PlanetCamera";
+import { Entity } from "../../entity/Entity";
+import { LonLat } from "../../LonLat";
+import { Vec3 } from "../../math/Vec3";
+import { Vec4, type NumberArray4 } from "../../math/Vec4";
+import { QuadTreeStrategy } from "../../quadTree";
+import type { Renderer } from "../../renderer/Renderer";
+import type { Planet } from "../../scene/Planet";
+import { Framebuffer } from "../../webgl";
+import { Vector } from "../../layer/Vector";
+import type { ShadowMap } from "../../renderer/shadows/ShadowMap";
+import type { DepthCameraHandler } from "./DepthCameraHandler";
+interface IPerimeterSegmentsData {
+    segments: LonLat[][];
+    isClosed: boolean;
+}
+export interface IDepthCameraParams {
+    enabled?: boolean;
+    width?: number;
+    height?: number;
+    near?: number;
+    far?: number;
+    verticalViewAngle?: number;
+    horizontalViewAngle?: number;
+    showFrustum?: boolean;
+    showFootprint?: boolean;
+    frustumLength?: number;
+    frustumColor?: Vec4 | NumberArray4 | string;
+    isOrthographic?: boolean;
+    focusDistance?: number;
+    enableSegmentSkirts?: boolean;
+    enableSegmentFaceCulling?: boolean;
+    excludeLayers?: Vector[];
+    depthBiasWorld?: number;
+    normalBias?: number;
+}
+export declare class DepthCamera {
+    protected static __counter__: number;
+    readonly id: number;
+    readonly width: number;
+    readonly height: number;
+    readonly near: number;
+    readonly far: number;
+    readonly verticalViewAngle: number;
+    readonly horizontalViewAngle?: number;
+    readonly excludeLayers: Vector[];
+    depthBiasWorld: number;
+    normalBias: number;
+    enabled: boolean;
+    enableSegmentSkirts: boolean;
+    enableSegmentFaceCulling: boolean;
+    camera: Camera;
+    framebuffer: Framebuffer;
+    quadTreeStrategy: QuadTreeStrategy;
+    shadowMap: ShadowMap | null;
+    _handler: DepthCameraHandler | null;
+    _handlerIndex: number;
+    protected _planet: Planet | null;
+    protected _renderer: Renderer | null;
+    protected _initialized: boolean;
+    _forceOwnQuadTreeStrategyPass: boolean;
+    protected _showFrustum: boolean;
+    protected _showFootprint: boolean;
+    protected _isOrthographic: boolean;
+    protected _focusDistance: number;
+    protected _lastPlanetHeightFactor: number;
+    protected _orthoTexelSizeX: number;
+    protected _orthoTexelSizeY: number;
+    protected _frustumLength: number;
+    protected _frustumColor: Vec4 | NumberArray4 | string;
+    protected _cameraFrustumEntity: Entity | null;
+    protected _cameraFootprintEntity: Entity | null;
+    protected _cameraFootprintSegmentPointCounts: number[];
+    protected _cameraFootprintClosedState: boolean;
+    protected _prevCameraPos: Vec3;
+    protected _prevCameraPitch: number;
+    protected _prevCameraYaw: number;
+    protected _prevCameraRoll: number;
+    protected _prevCameraFrustumEntityPos: Vec3;
+    protected _prevCameraFrustumEntityPitch: number;
+    protected _prevCameraFrustumEntityYaw: number;
+    protected _prevCameraFrustumEntityRoll: number;
+    constructor(params?: IDepthCameraParams);
+    get initialized(): boolean;
+    get showFrustum(): boolean;
+    set showFrustum(showFrustum: boolean);
+    get showFootprint(): boolean;
+    set showFootprint(showFootprint: boolean);
+    get texelScale(): number;
+    get isOrthographic(): boolean;
+    set isOrthographic(isOrthographic: boolean);
+    get focusDistance(): number;
+    set focusDistance(focusDistance: number);
+    get cameraFootprintEntity(): Entity | null;
+    get cameraFrustumEntity(): Entity | null;
+    get frustumLength(): number;
+    set frustumLength(length: number);
+    get frustumColor(): Vec4 | NumberArray4 | string;
+    set frustumColor(color: Vec4 | NumberArray4 | string);
+    get frustumScale(): Vec3;
+    init(planet: Planet, renderer: Renderer): void;
+    destroy(): void;
+    frame(): void;
+    prepareFrame(): void;
+    protected _prepareCameraEntitySync(): void;
+    protected _finishCameraEntitySync(): void;
+    finishFrame(): void;
+    renderFootprint(): void;
+    getCamera(): Camera;
+    getFramebuffer(): Framebuffer;
+    getDepthTexture(): WebGLTexture;
+    protected _syncPlanetHeightFactor(): void;
+    protected _prepareOrthographicProjection(): void;
+    /**
+     * Quantizes the orthographic extent and keeps the previous size while it still fits to prevent jitter.
+     */
+    protected _quantizeOrthoTexelSize(extent: number, resolution: number, prevTexelSize: number): number;
+    protected _snapOrthographicProjectionToTexelGrid(): boolean;
+    getCartesianFromPixelTerrain(x: number, y: number): Vec3 | undefined;
+    getLonLatFromPixelTerrain(x: number, y: number): LonLat | undefined;
+    protected _createCameraFootprintEntity(): Entity;
+    protected _createCameraFrustumEntity(): Entity;
+    protected _createCamera(planet: Planet): Camera;
+    protected _createFramebuffer(renderer: Renderer): Framebuffer;
+    protected _createQuadTreeStrategy(planet: Planet, camera: PlanetCamera): QuadTreeStrategy;
+    protected _getQuadTreeStrategy(depthCamera: PlanetCamera): QuadTreeStrategy;
+    protected _segmentsPass(camera: PlanetCamera, quadTreeStrategy: QuadTreeStrategy): void;
+    protected _geoObjectsPass(camera: PlanetCamera): void;
+    protected _collectPerimeterLonLats(width: number, height: number): IPerimeterSegmentsData;
+}
+export {};

package/lib/control/depthCamera/DepthCameraHandler.d.ts

@@ -0,0 +1,25 @@
+import { Control, IControlParams } from "../Control";
+import { DepthCamera } from "./DepthCamera";
+import { Vector } from "../../layer";
+export interface IDepthCameraHandlerParams extends IControlParams {
+    depthCameras?: DepthCamera[];
+}
+export declare class DepthCameraHandler extends Control {
+    protected _depthCameras: DepthCamera[];
+    readonly cameraFootprintLayer: Vector;
+    readonly cameraFrustumLayer: Vector;
+    constructor(params?: IDepthCameraHandlerParams);
+    get depthCameras(): DepthCamera[];
+    add(depthCamera: DepthCamera): DepthCamera;
+    remove(): void;
+    remove(depthCamera: DepthCamera): boolean;
+    clear(): void;
+    oninit(): void;
+    onactivate(): void;
+    ondeactivate(): void;
+    onremove(): void;
+    protected _initDepthCamera(depthCamera: DepthCamera): void;
+    protected _addDepthCameraEntities(depthCamera: DepthCamera): void;
+    protected _removeDepthCameraEntities(depthCamera: DepthCamera): void;
+    protected _onDraw: () => void;
+}

package/lib/control/depthCamera/depth_camera.d.ts

@@ -0,0 +1,2 @@
+import { ShaderProgram } from "../../webgl";
+export declare function depth_camera(): ShaderProgram;