@openglobus/og 1.0.0-rc2 → 1.0.0-rc21

package/lib/ui/Dialog.d.ts

@@ -2,6 +2,7 @@ import { Button } from "./Button";
 import { View } from "./View";
 import type { IViewParams, ViewEventsList } from "./View";
 import type { EventsHandler } from "../Events";
+import type { DockSide } from "./Dock";
 export interface IDialogParams extends IViewParams {
     title?: string;
     visible?: boolean;
@@ -16,8 +17,39 @@ export interface IDialogParams extends IViewParams {
     minWidth?: number;
     maxWidth?: number;
     useHide?: boolean;
+    dock?: DockSide;
+    hideToolbar?: boolean;
 }
 export type DialogEventsList = ["resize", "focus", "visibility", "dragstart", "dragend"];
+/** Carries the dialog back from its element, the way a Button does. */
+export interface DialogElement extends HTMLElement {
+    __og_dialog__?: Dialog<any>;
+}
+/** Preferred side of the anchor element a dialog opens on. */
+export type DialogPlacement = "right" | "below";
+/**
+ * Floating dialog window with a draggable header, a resizable body and a close button.
+ * Dragged by its header to an edge of its container, the dialog docks to that side when a
+ * {@link DockManager} watches the container, and the `dock` option opens it docked at once.
+ * @class
+ * @extends {View}
+ * @param {IDialogParams} [options] - Options:
+ * @param {string} [options.title=""] - Header title.
+ * @param {boolean} [options.visible=true] - Initial visibility.
+ * @param {boolean} [options.resizable=true] - Resize handle flag.
+ * @param {number} [options.width=300] - Dialog width in pixels.
+ * @param {number} [options.height=200] - Dialog height in pixels. Fits the content when it is not set.
+ * @param {number} [options.left=0] - Offset from the left edge of the container in pixels.
+ * @param {number} [options.right] - Offset from the right edge of the container in pixels, applied instead of the left one.
+ * @param {number} [options.top=0] - Offset from the top edge of the container in pixels.
+ * @param {number} [options.minHeight] - Minimal height in pixels.
+ * @param {number} [options.maxHeight] - Maximal height in pixels.
+ * @param {number} [options.minWidth] - Minimal width in pixels.
+ * @param {number} [options.maxWidth] - Maximal width in pixels.
+ * @param {boolean} [options.useHide=false] - Hides the dialog on close instead of removing it.
+ * @param {DockSide} [options.dock] - Side to open docked to the first time the dialog is shown, if a dock manager is there.
+ * @param {boolean} [options.hideToolbar=false] - Hides the bar the dialog is dragged by. Without it the dialog cannot be moved.
+ */
 declare class Dialog<M> extends View<M> {
     static __zIndex__: number;
     events: EventsHandler<DialogEventsList> & EventsHandler<ViewEventsList>;
@@ -42,7 +74,11 @@ declare class Dialog<M> extends View<M> {
     protected _touchDragPointerId: number | null;
     protected _touchResizePointerId: number | null;
     protected _titleText: string;
+    protected _dock: DockSide | null;
+    protected _hideToolbar: boolean;
     constructor(options?: IDialogParams);
+    /** Side this dialog asks to open docked to. */
+    get dock(): DockSide | null;
     setContainer(htmlStr: string): void;
     get container(): HTMLElement | null;
     get width(): number;
@@ -55,8 +91,17 @@ declare class Dialog<M> extends View<M> {
     close(): void;
     setVisibility(visibility: boolean): void;
     getVisibility(): boolean;
-    positionNearElementOnFirstOpen(anchorEl: HTMLElement | null, rootEl?: HTMLElement | null, gap?: number): void;
+    /**
+     * Places the dialog next to an anchor element, once, on its first open.
+     * @param anchorEl - Element to place the dialog against, e.g. the control toggle button.
+     * @param rootEl - Container the dialog is kept inside of, the dialog parent by default.
+     * @param gap - Distance between the anchor and the dialog in pixels.
+     * @param placement - "right" opens the dialog right of the anchor, mirrored to its left when the
+     * anchor sits in the right half of the container; "below" opens it underneath the anchor.
+     */
+    positionNearElementOnFirstOpen(anchorEl: HTMLElement | null, rootEl?: HTMLElement | null, gap?: number, placement?: DialogPlacement): void;
     protected _initButtons(): void;
+    afterRender(parentNode: HTMLElement): void;
     protected _initEvents(): void;
     protected _onCloseBtnClick: () => void;
     protected _onMouseDownAll: () => void;

package/lib/ui/Dock.d.ts

@@ -0,0 +1,151 @@
+import type { EventsHandler } from "../Events";
+import type { Dialog } from "./Dialog";
+export type DockSide = "top" | "bottom" | "left" | "right" | "center";
+/** How a side lays its dialogs out. */
+export type DockDirection = "row" | "column";
+/** Which third of a side a dialog was dropped on, and so where it goes. */
+export type DockPlacement = "start" | "middle" | "end";
+export interface IDockManagerParams {
+    host: HTMLElement;
+    /** How close to an edge a dragged dialog has to come before that side offers itself. */
+    edgeThreshold?: number;
+    /** Size a side takes when nothing better is known. */
+    defaultSize?: number;
+}
+type DockEventsList = ["dock", "undock", "layout"];
+interface Rect {
+    x: number;
+    y: number;
+    width: number;
+    height: number;
+}
+interface DockZone {
+    side: DockSide;
+    direction: DockDirection;
+    size: number;
+    rect: Rect;
+    el: HTMLElement;
+    items: Dialog<any>[];
+    shares: number[];
+}
+/** A draggable edge: the side's own when `after` is null, otherwise a seam inside its stack. */
+interface DockSplitter {
+    el: HTMLElement;
+    zone: DockZone;
+    after: number | null;
+}
+interface FloatingState {
+    left: string;
+    top: string;
+    width: string;
+    height: string;
+    position: string;
+}
+interface DialogState {
+    attached: boolean;
+    opened: boolean;
+    floating: FloatingState | null;
+}
+/**
+ * Docks dialogs to the sides of a host element. Sides claim bands in first-use
+ * order, while dialogs on the same side stack and share its length.
+ *
+ * Draggable edges render in a separate layer, keeping panels flush and preventing
+ * clipped seams or thickness-related layout adjustments.
+ */
+export declare class DockManager {
+    readonly events: EventsHandler<DockEventsList>;
+    protected _host: HTMLElement;
+    protected _edgeThreshold: number;
+    protected _defaultSize: number;
+    protected _zones: DockZone[];
+    protected _splitters: DockSplitter[];
+    protected _splitterLayer: HTMLElement;
+    protected _grab: number;
+    protected _dialogs: Map<Dialog<any>, DialogState>;
+    protected _hint: HTMLElement;
+    protected _free: Rect;
+    protected _resizeObserver: ResizeObserver;
+    protected _domObserver: MutationObserver;
+    protected _dragging: Dialog<any> | null;
+    protected _drop: {
+        side: DockSide;
+        placement: DockPlacement;
+    } | null;
+    protected _pointer: {
+        x: number;
+        y: number;
+    };
+    constructor(params: IDockManagerParams);
+    /** The rectangle no side has taken, in host coordinates. */
+    get freeRect(): Rect;
+    getSide(dialog: Dialog<any>): DockSide | null;
+    isDocked(dialog: Dialog<any>): boolean;
+    attach(dialog: Dialog<any>): void;
+    detach(dialog: Dialog<any>): void;
+    protected _state(dialog: Dialog<any>): DialogState;
+    dock(dialog: Dialog<any>, side: DockSide, placement?: DockPlacement): void;
+    undock(dialog: Dialog<any>): void;
+    /** Recomputes every side from the host rectangle, taking a band off it in dock order. */
+    layout(): void;
+    destroy(): void;
+    /** What a side opens at for this dialog: its width standing on end, or its height. */
+    protected _dockSize(dialog: Dialog<any> | null, side: DockSide): number;
+    protected _applyZoneRect(zone: DockZone, rect: Rect): void;
+    /** The band a side takes off a rectangle, and what the sides after it will see. */
+    protected _band(rect: Rect, side: DockSide, size: number): {
+        zone: Rect;
+        rest: Rect;
+        size: number;
+    };
+    /**
+     * Returns a newcomer's stack share: the existing average, normalized to 1 / (count + 1).
+     */
+    protected _slot(rect: Rect, direction: DockDirection, atStart: boolean, count: number): Rect;
+    protected _attachElement(node: Node): void;
+    protected _onMutations: (records: MutationRecord[]) => void;
+    /**
+     * A dialog can ask to open docked, and it takes its side as soon as it turns up - a
+     * dialog created hidden would otherwise let a later one claim the corner first. A side
+     * with nothing shown in it costs no room until something is.
+     */
+    protected _openDocked(dialog: Dialog<any>): void;
+    protected _onDialogVisibility: (visible: boolean, dialog: Dialog<any>) => void;
+    protected _getZone(side: DockSide): DockZone;
+    protected _removeZone(zone: DockZone): void;
+    protected _averageShare(zone: DockZone): number;
+    protected _normalize(zone: DockZone): void;
+    protected _shares(zone: DockZone): {
+        visible: number[];
+        total: number;
+    };
+    protected _visibleItems(zone: DockZone): number[];
+    protected _refresh(zone: DockZone): void;
+    protected _renderZone(zone: DockZone): void;
+    protected _rebuildSplitters(): void;
+    protected _createSplitter(zone: DockZone, after: number | null): HTMLElement;
+    protected _positionSplitters(): void;
+    protected _itemOffset(zone: DockZone, item: number): number;
+    protected _onSplitterDown: (event: PointerEvent, zone: DockZone, after: number | null) => void;
+    protected _zoneResizer(zone: DockZone, start: PointerEvent): (event: PointerEvent) => void;
+    protected _stackResizer(zone: DockZone, after: number, start: PointerEvent): (event: PointerEvent) => void;
+    protected _remember(dialog: Dialog<any>): void;
+    protected _restore(dialog: Dialog<any>): void;
+    protected _onPointerDown: (event: PointerEvent) => void;
+    protected _onDragStart: (dialog: Dialog<any>) => void;
+    protected _onDragMove: (event: MouseEvent | PointerEvent) => void;
+    protected _onDragEnd: (dialog: Dialog<any>) => void;
+    protected _shownZone(side: DockSide): DockZone | null;
+    protected _sideAt(clientX: number, clientY: number, host: DOMRect): DockSide | null;
+    /** The band a side would occupy, whether it is in use yet or not. */
+    protected _sideRect(side: DockSide): Rect;
+    protected _dropAt(clientX: number, clientY: number): {
+        side: DockSide;
+        placement: DockPlacement;
+    } | null;
+    protected _showHint(drop: {
+        side: DockSide;
+        placement: DockPlacement;
+    } | null): void;
+}
+export {};

package/lib/ui/Input.d.ts

@@ -25,13 +25,26 @@ declare class Input extends View<null> {
     render(params: any): this;
     protected _onResize: () => void;
     set value(val: string | number);
-    protected _setValue(val: string | number): void;
+    protected _setCommittedValue(value: string, forceSync?: boolean): void;
     get value(): string;
+    protected _formatValue(val: string | number): string;
+    protected _formatNumber(val: number): string;
+    protected _getMaxFixed(): number;
+    protected _clampNumber(value: number): number;
+    protected _parseNumber(value: string): number | null;
+    protected _normalizeUserValue(value: string): string | null;
+    protected _syncInputValue(): void;
+    afterRender(parentNode: HTMLElement): void;
     protected _initEvents(): void;
     protected _clearEvents(): void;
     protected _onMouseWheel: (e: WheelEvent) => void;
     protected _onMouseWheelFF: (e: WheelEvent) => void;
     protected _onInput: (e: Event) => void;
+    protected _onChange: (e: Event) => void;
+    protected _onKeyDown: (e: KeyboardEvent) => void;
+    protected _onBlur: () => void;
+    protected _commitUserInput(): void;
+    protected _stepValue(direction: number): void;
     remove(): void;
     set visibility(visibility: boolean);
 }

package/lib/ui/Slider.d.ts

@@ -28,6 +28,7 @@ declare class Slider extends View<null> {
     protected _syncUiFromValue(): void;
     set value(val: number);
     get value(): number;
+    afterRender(parentNode: HTMLElement): void;
     protected _initEvents(): void;
     protected _clearEvents(): void;
     protected _onMouseWheel: (e: WheelEvent) => void;

package/lib/ui/TitleBarView.d.ts

@@ -0,0 +1,21 @@
+import type { EventsHandler } from "../Events";
+import { View, type IViewParams, type ViewEventsList } from "./View";
+interface ITitleBarViewParams extends IViewParams {
+    title: string;
+    isCollapsed?: boolean;
+}
+type TitleBarViewEventsList = ["change"];
+export declare class TitleBarView extends View<null> {
+    events: EventsHandler<TitleBarViewEventsList> & EventsHandler<ViewEventsList>;
+    protected _title: string;
+    protected _isCollapsed: boolean;
+    protected _toggleBtn: HTMLButtonElement | null;
+    constructor(params: ITitleBarViewParams);
+    get isCollapsed(): boolean;
+    setCollapsed(isCollapsed: boolean, stopPropagation?: boolean): void;
+    render(params?: unknown): this;
+    remove(): void;
+    protected _syncToggleButton(): void;
+    protected _onToggleClick: (e: MouseEvent) => void;
+}
+export {};

package/lib/ui/index.d.ts

@@ -3,7 +3,9 @@ export * from "./ButtonGroup";
 export * from "./Checkbox";
 export * from "./Color";
 export * from "./Dialog";
+export * from "./Dock";
 export * from "./Input";
 export * from "./Slider";
 export * from "./ToggleButton";
+export * from "./TitleBarView";
 export * from "./View";

package/lib/utils/FontAtlas.d.ts

@@ -1,6 +1,6 @@
 import { Deferred } from "../Deferred";
 import { Rectangle } from "../Rectangle";
-import { TextureAtlas, TextureAtlasNode } from "./TextureAtlas";
+import { TextureAtlasNode } from "./TextureAtlas";
 import type { WebGLTextureExt } from "../webgl/Handler";
 import { Handler } from "../webgl/Handler";
 import type { HTMLImageElementExt } from "./ImagesCacheManager";
@@ -77,16 +77,18 @@ export interface IMSDFAtlasParams {
     glyphs: IMSDFGlyph[];
     kerning: IMSDFKerning[];
 }
-declare class FontTextureAtlas extends TextureAtlas {
+declare class FontTextureAtlas {
     width: number;
     height: number;
     gliphSize: number;
     distanceRange: number;
     isMtsdf: boolean;
+    sourceImage: HTMLImageElementExt | null;
     nodes: Map<number, FontTextureAtlasNode>;
     kernings: Record<number, Record<number, number>>;
-    constructor(width?: number, height?: number);
+    constructor();
     get(key: number): FontTextureAtlasNode | undefined;
+    createTexture(img?: HTMLImageElementExt | null): void;
 }
 interface IMetrics extends IChar {
     nChar: string;

package/lib/utils/GeoImageCreator.d.ts

@@ -26,6 +26,13 @@ export declare class GeoImageCreator {
      * @return{WebGLBuffer} Grid coordinates buffer.
      */
     createGridBuffer(c: LonLat[], toMerc?: boolean): [WebGLBufferExt, WebGLBufferExt];
+    /**
+     * Returns true when there is nothing left to rasterize and no animated
+     * geo images(i.e. GeoVideo) are being played.
+     * @public
+     * @returns {boolean}
+     */
+    get isIdle(): boolean;
     frame(): void;
     add(geoImage: BaseGeoImage): void;
     remove(geoImage: BaseGeoImage): void;

package/lib/utils/Loader.d.ts

@@ -61,6 +61,12 @@ export declare class Loader<T extends Obj<T>> {
     abort(sender: T): void;
     abortAll(): void;
     get loading(): number;
+    /**
+     * Returns true when there is nothing being loaded and nothing left in the queue.
+     * @public
+     * @returns {boolean}
+     */
+    get isFree(): boolean;
     get queue(): QueueData<T>[];
 }
 export {};

package/lib/utils/NormalMapCreator.d.ts

@@ -33,6 +33,12 @@ export declare class NormalMapCreator {
     protected _drawNormalMapNoBlur(segment: Segment): boolean;
     protected _drawNormalMap(segment: Segment): boolean;
     drawSingle(segment: Segment): void;
+    /**
+     * Returns true when there is nothing left to rasterize.
+     * @public
+     * @returns {boolean}
+     */
+    get isIdle(): boolean;
     frame(): void;
     get queueSize(): number;
     queue(segment: Segment): void;

package/lib/utils/TerrainWorker.d.ts

@@ -15,6 +15,7 @@ export interface ITerrainWorkerData {
     terrainVerticesLow: Float32Array | null;
     noDataVertices: Uint8Array | null;
     bounds: NumberArray6;
+    radiusRange: number[] | null;
     relativeCenter: NumberArray3;
 }
 type MessageEventExt = MessageEvent & {

package/lib/utils/VectorTileCreator.d.ts

@@ -11,6 +11,12 @@ export declare class VectorTileCreator {
     protected _handler: Handler | null;
     constructor(planet: Planet, width?: number, height?: number);
     init(): void;
+    /**
+     * Returns true when there is nothing left to rasterize.
+     * @public
+     * @returns {boolean}
+     */
+    get isIdle(): boolean;
     frame(): void;
     add(material: Material): void;
     remove(material: Material): void;

package/lib/utils/cameraFootprint.d.ts

@@ -0,0 +1,72 @@
+import { Ellipsoid } from "../ellipsoid/Ellipsoid";
+import type { PlanetCamera } from "../camera/PlanetCamera";
+import { Vec3 } from "../math/Vec3";
+/**
+ * Points under the screen corners, as [leftTop, rightTop, leftBottom, rightBottom].
+ */
+export type CameraFootprintCorners = [Vec3 | undefined, Vec3 | undefined, Vec3 | undefined, Vec3 | undefined];
+export interface ICameraFootprintParams {
+    screenMargin?: number;
+    terrainHeightStep?: number;
+    drop?: number;
+}
+/**
+ * Reference surface points under the four screen corners, as [leftTop, rightTop, leftBottom, rightBottom].
+ *
+ * @param {PlanetCamera} camera - Camera to take the footprint of.
+ * @param {number} [screenMargin=100] - Border of the screen, in screen pixels, the corners are sampled inside of.
+ * @param {Ellipsoid} [ellipsoid] - Reference surface, the planet ellipsoid by default. See CameraFootprint
+ * for one raised to the terrain under the camera.
+ */
+export declare function getCameraFootprint(camera: PlanetCamera, screenMargin?: number, ellipsoid?: Ellipsoid): CameraFootprintCorners;
+/**
+ * The ground area a camera sees: the four screen corners cast onto a reference surface and dropped onto the
+ * rendered terrain, plus the center, surface normals and radius derived from them.
+ *
+ * The reference surface is the planet ellipsoid raised to the terrain right under the camera, so that a
+ * camera on a mountain does not measure its footprint against sea level. Only the height under the camera
+ * is used, which keeps the footprint independent of how far the surrounding tiles have loaded.
+ */
+export declare class CameraFootprint {
+    /** Border of the screen, in screen pixels, the corners are sampled inside of. */
+    screenMargin: number;
+    /**
+     * Terrain height under the camera is quantized to this step, in world units, before the reference
+     * ellipsoid is rebuilt, so that the footprint does not jitter while flying over rough terrain.
+     */
+    terrainHeightStep: number;
+    /** Lowers the reference ellipsoid by this many world units. */
+    drop: number;
+    /** Camera the current footprint was taken of. */
+    camera: PlanetCamera | null;
+    /** Reference surface, the planet ellipsoid raised to the terrain under the camera. */
+    ellipsoid: Ellipsoid | null;
+    /** Height the reference ellipsoid is raised by, in world units. */
+    ellipsoidHeight: number;
+    /** Whether the last update found all four corners. */
+    isValid: boolean;
+    /** Reference surface corners in screen order, as [leftTop, rightTop, leftBottom, rightBottom]. */
+    corners: CameraFootprintCorners;
+    /** Reference surface corners in contour order. */
+    surfacePoints: Vec3[];
+    /** Corners dropped onto the rendered terrain, in contour order. */
+    points: Vec3[];
+    /** Reference surface normals under the ground points. */
+    normals: Vec3[];
+    center: Vec3;
+    /** Distance from the center to the farthest ground point. */
+    radius: number;
+    constructor(params?: ICameraFootprintParams);
+    /**
+     * Takes the footprint of the camera.
+     *
+     * @param {PlanetCamera} camera - Camera to take the footprint of.
+     * @returns {boolean} - False when the screen misses the planet, which leaves the previous points in place.
+     */
+    update(camera: PlanetCamera): boolean;
+    /**
+     * Level the reference ellipsoid is raised to: the terrain right under the camera, and nothing else.
+     */
+    protected _getTerrainHeight(camera: PlanetCamera): number;
+    protected _updateEllipsoid(camera: PlanetCamera): void;
+}

package/lib/utils/gltf/types.d.ts

@@ -1,4 +1,5 @@
 import { Object3d } from "../../Object3d";
+import type { TypedArray } from "../shared";
 export interface GltfData {
     bin: ArrayBuffer[];
     gltf: GltfMetadata;
@@ -156,10 +157,10 @@ export interface Mesh {
 }
 export interface Primitive {
     name: string;
-    indices?: ArrayBufferLike;
-    vertices: ArrayBufferLike;
-    normals?: ArrayBufferLike;
-    texCoords?: ArrayBufferLike;
+    indices?: TypedArray;
+    vertices: TypedArray;
+    normals?: TypedArray;
+    texCoords?: TypedArray;
     material?: Material;
     mode: PrimitiveMode;
     object3d?: Object3d;

package/lib/utils/shadowCameraFit.d.ts

@@ -0,0 +1,175 @@
+import type { DepthCamera } from "../control/depthCamera/DepthCamera";
+import type { Planet } from "../scene/Planet";
+import type { CameraFootprint } from "./cameraFootprint";
+import { Vec3 } from "../math/Vec3";
+export interface ILightSpaceBounds {
+    minX: number;
+    maxX: number;
+    minY: number;
+    maxY: number;
+    minZ: number;
+    maxZ: number;
+}
+export interface IOrthoBounds {
+    left: number;
+    right: number;
+    bottom: number;
+    top: number;
+}
+interface ITerrainRelief {
+    up: number;
+    down: number;
+    depthUp: number;
+    depthDown: number;
+    cornerSpread: number;
+}
+export interface IShadowCameraFitParams {
+    /**
+     * Adds proportional padding to each side of the fitted bounds.
+     * 0.01 adds 1% per side. This keeps curved ground between the four
+     * sampled screen corners inside the shadow map.
+     */
+    orthoMarginFactor?: number;
+    /**
+     * Extends caster coverage toward the Sun:
+     * max(casterClearance, casterHeight * casterClearanceFactor)
+     */
+    casterClearance?: number;
+    casterClearanceFactor?: number;
+    /**
+     * Minimum view-ray slope used when adjusting the footprint for terrain relief.
+     * 0.1 limits sideways movement to 10 metres per metre of relief.
+     * This prevents near-horizontal rays from greatly expanding the shadow map.
+     */
+    minFootprintRaySlope?: number;
+    /**
+     * Limits sideways footprint expansion caused by terrain below the reference level.
+     * 0.5 allows expansion up to half the footprint radius.
+     * Higher values improve downhill coverage but reduce shadow resolution.
+     */
+    reliefLateralFactor?: number;
+    /** Upper limits on the terrain relief the fit takes from the quad tree, in world units. */
+    maxReliefUp?: number;
+    maxReliefDown?: number;
+    /**
+     * Aligns the fitted bounds to a texel grid fixed in the world, so that shadow edges stop crawling while
+     * the camera moves. See _snapOrthographicBounds.
+     */
+    snapToTexelGrid?: boolean;
+    /**
+     * How the shadow rectangle is turned around the sun direction: along the local horizon under the
+     * footprint, or along the world axes. The camera aims at the sun either way, only the roll changes.
+     * Horizon aligned wastes less of the map, but then the rectangle turns as the camera moves and its
+     * texel grid stops holding still. See getStableLightUp.
+     */
+    horizonAlignedLightUp?: boolean;
+    /**
+     * Pads each side of the shadow map by the distance the camera travels in one frame, times this number.
+     *
+     * The fit always runs a frame behind the view, so while flying fast the ground right in front of the
+     * camera can fall outside the map and lose its shadow - this is what covers it. In exchange the map size
+     * follows the camera speed and the shadow edges start crawling, so it is off by default.
+     */
+    motionMarginFrames?: number;
+    /**
+     * Shadow depth bias, counted in shadow map texels so that it follows its resolution, plus a flat
+     * offset in metres:
+     *
+     *     depthBiasWorld = texelWorldSize * depthBiasTexels + depthBiasOffset
+     *
+     * Too little and surfaces shadow themselves, too much and the shadow comes away from the foot of its
+     * caster by depthBiasWorld * cos(sunElevation). The shader adds a slope term of its own, also
+     * counted in texels, see SHADOW_MAP_SLOPE_DEPTH_BIAS.
+     */
+    depthBiasTexels?: number;
+    depthBiasOffset?: number;
+    /**
+     * Renders the depth pass from the depth camera's own quad tree traversal rather than from the planet's.
+     * The planet's one covers only the near band of the view and drops tiles while they fade. Above a main
+     * camera height of about 136 km DepthCamera takes the planet's traversal whatever this says.
+     */
+    pinOwnQuadTreeTraversal?: boolean;
+}
+/** Last fit measurements, for readouts and debugging. */
+export interface IShadowCameraFitStats {
+    /** Shadow texel size in world units, the way ShadowManager measures it. */
+    texelWorldSize: number;
+    footprintRadius: number;
+    /** Spread of the footprint ground points in geocentric radius. */
+    cornerHeightSpread: number;
+    /** Terrain relief above and below the footprint corners, as the main camera traversal reports it. */
+    reliefUp: number;
+    reliefDown: number;
+    /** The same, with the depth camera traversal taken into account. Only the down side is used, by the far plane. */
+    depthReliefUp: number;
+    depthReliefDown: number;
+    casterHeight: number;
+    /** Main camera displacement since the previous fit, in world units. */
+    cameraStep: number;
+    orthoWidth: number;
+    orthoHeight: number;
+    orthoBounds: IOrthoBounds;
+    near: number;
+    far: number;
+}
+/**
+ * Places and sizes an orthographic depth camera over a camera footprint, so that the shadow map covers the
+ * ground the main camera sees, and everything that casts onto it, at the tightest texel the footprint allows.
+ *
+ * The fit holds state between frames - the texel grid step and the camera displacement - so one instance
+ * belongs to one depth camera.
+ */
+export declare class ShadowCameraFit {
+    orthoMarginFactor: number;
+    casterClearance: number;
+    casterClearanceFactor: number;
+    minFootprintRaySlope: number;
+    reliefLateralFactor: number;
+    maxReliefUp: number;
+    maxReliefDown: number;
+    snapToTexelGrid: boolean;
+    horizonAlignedLightUp: boolean;
+    motionMarginFrames: number;
+    depthBiasTexels: number;
+    depthBiasOffset: number;
+    pinOwnQuadTreeTraversal: boolean;
+    readonly stats: IShadowCameraFitStats;
+    protected _lastCameraEye: Vec3;
+    protected _cameraStep: number;
+    protected _orthoTexelSizeX: number;
+    protected _orthoTexelSizeY: number;
+    constructor(params?: IShadowCameraFitParams);
+    /** Drops the state carried between frames, for a camera that has been teleported. */
+    reset(): void;
+    /**
+     * Places the depth camera over the footprint and sets its orthographic projection and depth biases.
+     *
+     * @param {DepthCamera} depthCamera - Orthographic depth camera to fit.
+     * @param {CameraFootprint} footprint - Ground area to cover, taken of the main camera this frame.
+     * @param {Vec3} sunPos - Sun position.
+     * @returns {boolean} - False when the footprint is incomplete or gives no usable bounds.
+     */
+    fit(depthCamera: DepthCamera, footprint: CameraFootprint, sunPos: Vec3): boolean;
+    /** Returns how much higher and how much lower the terrain goes than the four footprint corners. */
+    protected _getTerrainRelief(depthCamera: DepthCamera, footprint: CameraFootprint): ITerrainRelief;
+    /**
+     * Returns the points the bounds are fitted to: the four footprint corners, plus the relief they hide,
+     * reached by walking each corner along its own view ray. Along the ray, because that is where the hidden
+     * terrain lies - pushing the corners sideways instead would widen the bounds for relief that is only ever
+     * an estimate.
+     */
+    protected _getReceiverBoundsPoints(footprint: CameraFootprint, relief: ITerrainRelief): Vec3[];
+    /**
+     * Returns the caster height, rounded to a coarse step. It decides where the shadow camera stands, and a
+     * camera that jumps every time the terrain range is revised makes the whole map blink.
+     */
+    protected _getCasterHeight(planet: Planet, footprintRadius: number, terrainRelief: number): number;
+    protected _expandOrthographicBounds(bounds: ILightSpaceBounds, textureWidth: number, textureHeight: number): IOrthoBounds;
+    /**
+     * Returns the texel size to fit the extent onto, keeping the previous one while it is still large enough.
+     */
+    protected _quantizeOrthoTexelSize(extent: number, resolution: number, prevTexelSize: number): number;
+    protected _snapOrthographicBounds(bounds: IOrthoBounds, right: Vec3, up: Vec3, anchor: Vec3, resolutionX: number, resolutionY: number): IOrthoBounds;
+    protected _updateDepthBiases(depthCamera: DepthCamera, orthoBounds: IOrthoBounds, textureWidth: number): void;
+}
+export {};