@openglobus/og 0.28.7 → 1.0.0-rc10

package/lib/scene/AltitudeNearPlaneStrategy.d.ts

@@ -0,0 +1,17 @@
+import type { PlanetCamera } from "../camera/PlanetCamera";
+export interface INearPlaneStrategy {
+    applyNear(camera: PlanetCamera): void;
+}
+export interface IAltitudeNearPlaneRule {
+    maxAltitude: number;
+    near: number;
+}
+export interface IAltitudeNearPlaneStrategyParams {
+    rules?: IAltitudeNearPlaneRule[];
+}
+export declare class AltitudeNearPlaneStrategy implements INearPlaneStrategy {
+    protected readonly _rules: IAltitudeNearPlaneRule[];
+    constructor(params?: IAltitudeNearPlaneStrategyParams);
+    applyNear(camera: PlanetCamera): void;
+    protected _resolveNear(altitude: number): number;
+}

package/lib/scene/Axes.d.ts

@@ -1,12 +1,13 @@
-import { RenderNode } from './RenderNode';
+import { Scene } from "./Scene";
 import type { WebGLBufferExt } from "../webgl/Handler";
-declare class Axes extends RenderNode {
+declare class Axes extends Scene {
     size: number;
     axesBuffer: WebGLBufferExt | null;
     axesColorBuffer: WebGLBufferExt | null;
     constructor(size?: number);
     init(): void;
-    frame(): void;
+    onremove(): void;
+    forward: () => void;
     createAxesBuffer(gridSize: number): void;
 }
 export { Axes };

package/lib/scene/Planet.d.ts

@@ -20,17 +20,19 @@ import { IPlanetFlyCartesianParams, PlanetCamera } from "../camera/PlanetCamera"
 import { Quat } from "../math/Quat";
 import { QuadTreeStrategy } from "../quadTree/QuadTreeStrategy";
 import { Ray } from "../math/Ray";
-import { RenderNode } from "./RenderNode";
+import { type INearPlaneStrategy } from "./AltitudeNearPlaneStrategy";
+import { Scene } from "./Scene";
 import { Sun } from "../control/Sun";
 import { TerrainWorker } from "../utils/TerrainWorker";
 import { Vec2, Vec3 } from "../math/index";
-import type { NumberArray2, NumberArray3, NumberArray4 } from "../math/index";
+import type { NumberArray2, NumberArray4 } from "../math/index";
 import { Vector } from "../layer/Vector";
 import { VectorTileCreator } from "../utils/VectorTileCreator";
 import type { WebGLBufferExt, WebGLTextureExt, IDefaultTextureParams } from "../webgl/Handler";
-import { Program } from "../webgl/Program";
+import { ShaderProgram } from "../webgl/ShaderProgram";
 import { Segment } from "../segment/Segment";
 import type { AtmosphereParameters } from "../shaders/atmos/atmos";
+import { type ShadeMode, type ShadeModeInput } from "../shadeModeConstants";
 export interface IPlanetParams {
     name?: string;
     ellipsoid?: Ellipsoid;
@@ -41,10 +43,6 @@ export interface IPlanetParams {
     minEqualZoomAltitude?: number;
     minEqualZoomCameraSlope?: number;
     quadTreeStrategyPrototype?: typeof QuadTreeStrategy;
-    ambient?: string | NumberArray3 | Vec3;
-    diffuse?: string | NumberArray3 | Vec3;
-    specular?: string | NumberArray3 | Vec3;
-    shininess?: number;
     nightTextureSrc?: string | null;
     specularTextureSrc?: string | null;
     maxGridSize?: number;
@@ -53,9 +51,13 @@ export interface IPlanetParams {
     transitionOpacityEnabled?: boolean;
     atmosphereParameters?: IAtmosphereParams;
     minDistanceBeforeMemClear?: number;
+    disableMemClear?: boolean;
     vectorTileSize?: number;
     maxNodesCount?: number;
     transparentBackground?: boolean;
+    nearPlaneStrategy?: INearPlaneStrategy;
+    shadeMode?: ShadeModeInput;
+    reverseDepth?: boolean;
 }
 export type PlanetEventsList = [
     "draw",
@@ -71,24 +73,45 @@ type IndexBufferCacheData = {
     buffer: WebGLBufferExt | null;
 };
 /**
- * Main class for rendering planet
+ * Main class for rendering a planet.
  * @class
- * @extends {RenderNode}
- * @param {string} [options.name="Earth"] - Planet name(Earth by default)
- * @param {Ellipsoid} [options.ellipsoid] - Planet ellipsoid(WGS84 by default)
- * @param {Number} [options.maxGridSize=128] - Segment maximal grid size
- * @param {Number} [options.maxEqualZoomAltitude=15000000.0] - Maximal altitude since segments on the screen become the same zoom level
- * @param {Number} [options.minEqualZoomAltitude=10000.0] - Minimal altitude since segments on the screen become the same zoom level
- * @param {Number} [options.minEqualZoomCameraSlope=0.8] - Minimal camera slope above te globe where segments on the screen become the same zoom level
+ * @extends {Scene}
+ * @param {IPlanetParams} [options={}] - Planet configuration parameters.
+ * @param {string} [options.name] - Planet name.
+ * @param {Ellipsoid} [options.ellipsoid=wgs84] - Planet ellipsoid.
+ * @param {number} [options.minAltitude] - Minimum camera altitude above terrain.
+ * @param {number} [options.maxAltitude] - Maximum camera altitude above terrain.
+ * @param {Array.<Array.<number>>} [options.frustums] - Planet camera frustum configuration.
+ * @param {number} [options.maxGridSize=256] - Maximum terrain segment grid size.
+ * @param {number} [options.maxLoadingRequests=12] - Maximum concurrent tile loading requests.
+ * @param {number} [options.maxNodesCount=400] - Maximum number of created quadtree nodes.
+ * @param {number} [options.maxEqualZoomAltitude=15000000.0] - Max altitude where visible segments keep the same zoom.
+ * @param {number} [options.minEqualZoomAltitude=10000.0] - Min altitude where visible segments keep the same zoom.
+ * @param {number} [options.minEqualZoomCameraSlope=0.8] - Min camera slope for equal-zoom segment strategy.
+ * @param {Function} [options.quadTreeStrategyPrototype=EarthQuadTreeStrategy] - Quadtree strategy class.
+ * @param {string|null} [options.nightTextureSrc] - Night lights texture URL (`null` disables texture loading).
+ * @param {string|null} [options.specularTextureSrc] - Water/specular mask texture URL (`null` disables texture loading).
+ * @param {boolean} [options.atmosphereEnabled=false] - Enables atmosphere rendering.
+ * @param {boolean} [options.transitionOpacityEnabled] - Enables terrain transition opacity blending.
+ * @param {IAtmosphereParams} [options.atmosphereParameters] - Atmosphere model parameters.
+ * @param {number} [options.minDistanceBeforeMemClear] - Camera travel distance threshold before automatic memory cleanup.
+ * @param {boolean} [options.disableMemClear=false] - Disables automatic memory cleanup via memClear().
+ * @param {number} [options.vectorTileSize] - Vector tile texture size for vector layer baking.
+ * @param {boolean} [options.transparentBackground=false] - Enables transparent renderer background.
+ * @param {INearPlaneStrategy} [options.nearPlaneStrategy] - Near-plane strategy implementation.
+ * @param {number|string} [options.shadeMode=0.5] - Terrain shading mode: `0|none|unlit`, `0.5|phong`, `1|pbr`.
+ * @param {boolean} [options.reverseDepth=true] - Enables reverse-Z depth for the default planet camera in perspective mode.
  *
- * @fires EventsHandler<PlanetEventList>#draw
- * @fires EventsHandler<PlanetEventList>#layeradd
- * @fires EventsHandler<PlanetEventList>#baselayerchange
- * @fires EventsHandler<PlanetEventList>#layerremove
- * @fires EventsHandler<PlanetEventList>#layervisibilitychange
- * @fires EventsHandler<PlanetEventList>#geoimageadd
+ * @fires draw - Triggered before globe frame begins to render.
+ * @fires layeradd - Triggered when a layer is added to the planet.
+ * @fires baselayerchange - Triggered when the base layer changes.
+ * @fires layerremove - Triggered when a layer is removed from the planet.
+ * @fires layervisibilitychange - Triggered when layer visibility changes.
+ * @fires rendercompleted - Triggered when all data is loaded.
+ * @fires terraincompleted - Triggered when terrain data is loaded.
+ * @fires layerloadend - Triggered when layer data finishes loading.
  */
-export declare class Planet extends RenderNode {
+export declare class Planet extends Scene {
     events: EventsHandler<PlanetEventsList>;
     _createdNodesCount: number;
     /**
@@ -96,12 +119,6 @@ export declare class Planet extends RenderNode {
      * @type {Ellipsoid}
      */
     ellipsoid: Ellipsoid;
-    /**
-     * @public
-     * @override
-     * @type {Boolean}
-     */
-    lightEnabled: boolean;
     /**
      * Squared ellipsoid radius.
      * @public
@@ -158,12 +175,7 @@ export declare class Planet extends RenderNode {
      * @type {PlanetCamera}
      */
     camera: PlanetCamera;
-    /**
-     * Screen mouse pointer projected to planet cartesian position.
-     * @public
-     * @type {Vec3}
-     */
-    mousePositionOnEarth: Vec3;
+    nearPlaneStrategy: INearPlaneStrategy;
     emptyTexture: WebGLTextureExt | null;
     transparentTexture: WebGLTextureExt | null;
     defaultTexture: WebGLTextureExt | null;
@@ -212,9 +224,6 @@ export declare class Planet extends RenderNode {
      * @protected
      */
     protected _specularTexture: WebGLTextureExt | null;
-    _ambient: Float32Array;
-    _diffuse: Float32Array;
-    _specular: Float32Array;
     protected _maxGridSize: number;
     /**
      * Segment multiple textures size.(4 - convenient value for the most devices)
@@ -258,10 +267,16 @@ export declare class Planet extends RenderNode {
      * @type {number}
      */
     nightTextureCoefficient: number;
-    protected _renderScreenNodesPASS: () => void;
-    protected _renderScreenNodesWithHeightPASS: () => void;
+    /**
+     * Global terrain shading for segment (forward + deferred): 0 unlit, 0.5 Phong, 1 PBR.
+     * @public
+     */
+    protected _shadeMode: ShadeMode;
     protected _atmosphereEnabled: boolean;
     protected _atmosphereMaxMinOpacity: Float32Array;
+    _atmosphereCurrentMaxMinOpacity: Float32Array;
+    atmosphereFadeDist: Float32Array;
+    protected _atmosphereBottomRadius: number;
     solidTextureOne: WebGLTextureExt | null;
     solidTextureTwo: WebGLTextureExt | null;
     protected _nightTextureSrc: string | null;
@@ -269,45 +284,146 @@ export declare class Planet extends RenderNode {
     transitionTime: number;
     protected _atmosphere: Atmosphere;
     private _minDistanceBeforeMemClear;
+    disableMemClear: boolean;
     private _maxNodes;
     protected _transparentBackground: boolean;
     constructor(options?: IPlanetParams);
     /**
-     * Returns true if current terrain data set is loaded
+     * Returns true if the current terrain data set is loaded
+     * @public
      */
     get terrainReady(): boolean;
+    /**
+     * Returns max segment grid size used by the quadtree.
+     * @public
+     * @returns {number} - Max grid size.
+     */
     get maxGridSize(): number;
+    /**
+     * Returns local north frame rotation for a cartesian point.
+     * @public
+     * @param {Vec3} cartesian - Cartesian point.
+     * @returns {Quat} - Rotation from world frame to local north frame.
+     */
     getNorthFrameRotation(cartesian: Vec3): Quat;
+    /**
+     * Returns local frame rotation for a cartesian point.
+     * @public
+     * @param {Vec3} cartesian - Cartesian point.
+     * @returns {Quat} - Rotation from world frame to local frame.
+     */
     getFrameRotation(cartesian: Vec3): Quat;
+    /**
+     * Sets maximum atmosphere opacity.
+     * @public
+     * @param {number} opacity - Opacity value in range `[0..1]`.
+     */
     set atmosphereMaxOpacity(opacity: number);
+    /**
+     * Gets maximum atmosphere opacity.
+     * @public
+     * @returns {number} - Max opacity.
+     */
     get atmosphereMaxOpacity(): number;
+    /**
+     * Sets minimum atmosphere opacity.
+     * @public
+     * @param {number} opacity - Opacity value in range `[0..1]`.
+     */
     set atmosphereMinOpacity(opacity: number);
+    /**
+     * Gets minimum atmosphere opacity.
+     * @public
+     * @returns {number} - Min opacity.
+     */
     get atmosphereMinOpacity(): number;
+    /**
+     * Sets atmosphere opacity interpolation curve shift.
+     * @public
+     * @param {number} curveShift - Curve shift. Zero produces linear interpolation.
+     */
+    set atmosphereOpacityCurveShift(curveShift: number);
+    /**
+     * Gets atmosphere opacity interpolation curve shift.
+     * @public
+     * @returns {number} - Curve shift.
+     */
+    get atmosphereOpacityCurveShift(): number;
+    /**
+     * Gets target atmosphere opacity parameters `[max, min, curveShift]`.
+     * @public
+     * @returns {Float32Array} - Opacity parameters at maximum camera altitude.
+     */
+    get atmosphereMaxMinOpacity(): Float32Array;
+    protected _calcAtmosphereFadeDist(): void;
+    protected _updateAtmosphereMaxMinOpacity(): void;
+    /**
+     * Enables or disables atmosphere rendering and related programs.
+     * @public
+     * @param {boolean} enabled - Atmosphere activity flag.
+     */
     set atmosphereEnabled(enabled: boolean);
+    /**
+     * Returns atmosphere activity flag.
+     * @public
+     * @returns {boolean} - `true` when atmosphere is enabled.
+     */
     get atmosphereEnabled(): boolean;
-    set diffuse(rgb: string | NumberArray3 | Vec3);
-    set ambient(rgb: string | NumberArray3 | Vec3);
-    set specular(rgb: string | NumberArray3 | Vec3);
-    set shininess(v: number);
+    /**
+     * Returns active terrain shade mode.
+     * @public
+     * @returns {number} - Shade mode id.
+     */
+    get shadeMode(): ShadeMode;
+    /**
+     * Sets terrain shade mode.
+     * @public
+     * @param {number|string} m - Shade mode id (`0|0.5|1` or `none|phong|pbr`).
+     */
+    set shadeMode(m: ShadeModeInput);
+    protected _restoreSurfaceDepthMask(): void;
+    protected _enableTransparentSurfaceBlend(): void;
+    /**
+     * Returns normal-map generator used by the planet.
+     * @public
+     * @returns {NormalMapCreator} - Normal map creator.
+     */
     get normalMapCreator(): NormalMapCreator;
+    /**
+     * Returns current layers snapshot.
+     * @public
+     * @returns {Layer[]} - Layer array copy.
+     */
     get layers(): Layer[];
+    /**
+     * Returns Sun control instance if attached to the renderer.
+     * @public
+     * @returns {Sun | undefined} - Sun control.
+     */
     get sun(): Sun | undefined;
+    /**
+     * Returns current sun world position.
+     * @public
+     * @returns {Vec3} - Sun position.
+     */
     get sunPos(): Vec3;
     /**
      * Add the given control to the renderer of the planet scene.
+     * @public
      * @param {Control} control - Control.
      */
     addControl(control: Control): void;
     /**
      * Add the given controls array to the renderer of the planet.
+     * @public
      * @param {Array.<Control>} cArr - Control array.
      */
     addControls(cArr: Control[]): void;
     /**
-     * Return layer by it name
-     * @param {string} name - Name of the layer. og.Layer.prototype.name
+     * Returns a layer by name.
+     * @param {string} name - Layer name.
      * @public
-     * @returns {Layer} -
+     * @returns {Layer | undefined} -
      */
     getLayerByName(name: string): Layer | undefined;
     /**
@@ -335,7 +451,7 @@ export declare class Planet extends RenderNode {
      */
     removeLayer(layer: Layer): void;
     /**
-     *
+     * Clears material resources related to a layer in quadtree segments.
      * @public
      * @param {Layer} layer - Material layer.
      */
@@ -346,35 +462,67 @@ export declare class Planet extends RenderNode {
      * @public
      */
     setBaseLayer(layer: Layer): void;
+    protected _applyBaseLayerLighting(layer: Layer): void;
     /**
      * Sets elevation scale. 1.0 is default.
+     * @public
      * @param {number} factor - Elevation scale.
      */
     setHeightFactor(factor: number): void;
     /**
      * Gets elevation scale.
+     * @public
      * @returns {number} Terrain elevation scale
      */
     getHeightFactor(): number;
+    /**
+     * Sets LOD thresholds for quadtree terrain rendering.
+     * Proxy to {@link QuadTreeStrategy.setLodSize}.
+     * @public
+     * @param {number} currentLodSize - Current LOD size target.
+     * @param {number} [minLodSize] - Minimum LOD size.
+     * @param {number} [maxLodSize] - Maximum LOD size.
+     */
+    setLodSize(currentLodSize: number, minLodSize?: number, maxLodSize?: number): void;
     /**
      * Sets terrain provider
      * @public
      * @param {EmptyTerrain} terrain - Terrain provider.
      */
     setTerrain(terrain: EmptyTerrain): void;
+    /**
+     * Reinitializes terrain forward/deferred shaders for atmosphere mode.
+     * @public
+     * @param {AtmosphereParameters} [atmosParams] - Optional atmosphere shader parameters.
+     */
     initAtmosphereShader(atmosParams?: AtmosphereParameters): void;
+    /**
+     * Returns atmosphere control instance bound to the planet.
+     * @public
+     * @returns {Atmosphere} - Atmosphere control.
+     */
     get atmosphereControl(): Atmosphere;
     protected _initializeAtmosphere(): void;
+    protected _swapDeferredShadingPass(atmosParams?: AtmosphereParameters): void;
+    protected _restoreDefaultDeferredShadingPass(): void;
     protected _initializeShaders(): void;
     protected _onLayerLoadend(layer: Layer): void;
+    /**
+     * Initializes render resources, workers, shaders, and layer state.
+     * @public
+     */
     init(): void;
+    /**
+     * Reattaches already registered layers to apply initialization logic.
+     * @public
+     */
     initLayers(): void;
     protected _clearIndexesCache(): void;
     /**
      * Creates default textures first for the North Pole and whole globe and second for the South Pole.
      * @public
-     * @param{IDefaultTextureParams} param0 -
-     * @param{IDefaultTextureParams} param1 -
+     * @param {IDefaultTextureParams} param0 - Default texture params for the first texture.
+     * @param {IDefaultTextureParams} param1 - Default texture params for the second texture.
      */
     createDefaultTextures(param0: IDefaultTextureParams, param1: IDefaultTextureParams): void;
     protected _getLayerAttributionHTML(layer: Layer): string;
@@ -383,6 +531,10 @@ export declare class Planet extends RenderNode {
      * @public
      */
     updateAttributionsList(): void;
+    /**
+     * Schedules visible layers list refresh for the next frame.
+     * @public
+     */
     updateVisibleLayers(): void;
     protected _updateVisibleLayers(): void;
     /**
@@ -395,46 +547,58 @@ export declare class Planet extends RenderNode {
      * @protected
      */
     protected _sortLayers(): void;
-    protected _renderScreenNodesPASSNoAtmos(): void;
-    protected _renderScreenNodesPASSAtmos(): void;
+    protected _renderOpaqueScreenNodesDeferredPASS(): void;
+    protected _renderOpaqueScreenNodesForwardPASSNoAtmos(): void;
+    protected _renderOpaqueScreenNodesForwardPASSAtmos(): void;
+    protected _renderTransparentScreenNodesPASSNoAtmos(): void;
     protected _renderScreenNodesWithHeightPASSNoAtmos(): void;
+    protected _renderTransparentScreenNodesPASSAtmos(): void;
     protected _renderScreenNodesWithHeightPASSAtmos(): void;
-    protected _globalPreDraw(): void;
+    protected onPreDraw: () => void;
     /**
      * Render node callback.
      * @public
      */
-    preFrame(): void;
+    onDraw: () => void;
     /**
-     * Render node callback.
-     * Frame function is called for each renderer activrCamera frustum.
+     * Pauses quadtree render-node collection and disables camera terrain collision checks.
      * @public
-     * @override
      */
-    frame(): void;
     lockQuadTree(): void;
+    applyNear(camera?: PlanetCamera): void;
+    /**
+     * Resumes quadtree render-node collection and enables camera terrain collision checks.
+     * @public
+     */
     unlockQuadTree(): void;
-    protected _setUniformsNoAtmos(cam: PlanetCamera): Program;
-    protected _setUniformsAtmos(cam: PlanetCamera): Program;
-    protected _renderingFadingNodes: (quadTreeStrategy: QuadTreeStrategy, nodes: Map<number, boolean>, sh: Program, currentNode: Node, sl: Layer[], sliceIndex: number, outTransparentSegments?: Segment[], outOpaqueSegments?: Segment[]) => void;
-    protected _renderingFadingNodesNoDepth: (quadTreeStrategy: QuadTreeStrategy, nodes: Map<number, boolean>, sh: Program, currentNode: Node, sl: Layer[], sliceIndex: number, outOpaqueSegments?: Segment[]) => void;
+    protected _setUniformsDeferred(cam: PlanetCamera, program: ShaderProgram): ShaderProgram;
+    protected _setUniformsNoAtmos(cam: PlanetCamera, program: ShaderProgram, disableBlend: boolean): ShaderProgram;
+    protected _setUniformsAtmos(cam: PlanetCamera, program: ShaderProgram, disableBlend: boolean): ShaderProgram;
+    protected _renderingFadingNodes: (camera: PlanetCamera, quadTreeStrategy: QuadTreeStrategy, nodes: Map<number, boolean>, sh: ShaderProgram, currentNode: Node, sl: Layer[], sliceIndex: number, outTransparentSegments?: Segment[], outOpaqueSegments?: Segment[], forcedOpacity?: number, transparentSurface?: boolean) => void;
     protected static __refreshLayersFadingOpacity__(layersRef: Layer[], minCurrZoom: number, maxCurrZoom: number): void;
     /**
      * Drawing nodes
      */
-    protected _renderingScreenNodes(quadTreeStrategy: QuadTreeStrategy, sh: Program, cam: PlanetCamera, renderedNodes: Node[]): void;
-    protected _renderingScreenNodesWithHeight(quadTreeStrategy: QuadTreeStrategy, sh: Program, cam: PlanetCamera, renderedNodes: Node[]): void;
+    protected _renderingOpaqueScreenNodes(cam: PlanetCamera, quadTreeStrategy: QuadTreeStrategy, sh: ShaderProgram, renderedNodes: Node[]): void;
+    protected _renderingTransparentScreenNodes(camera: PlanetCamera, quadTreeStrategy: QuadTreeStrategy, sh: ShaderProgram): void;
+    protected _renderingScreenNodesWithHeight(camera: PlanetCamera, quadTreeStrategy: QuadTreeStrategy, sh: ShaderProgram, renderedNodes: Node[]): void;
     protected _renderColorPickingFramebufferPASS(): void;
+    /**
+     * Renders terrain depth and frustum id into the depth framebuffer.
+     * @public
+     * @param {PlanetCamera} cam - Camera used for rendering.
+     * @param {QuadTreeStrategy} quadTreeStrategy - Quadtree strategy with rendered node lists.
+     */
     renderDepthFramebuffer(cam: PlanetCamera, quadTreeStrategy: QuadTreeStrategy): void;
     protected _collectVectorLayerCollections(): void;
     /**
-     * Starts clear memory thread.
+     * Starts a clear memory thread.
      * @public
      */
-    memClear(): void;
+    memClear(force?: boolean): void;
     /**
      * Returns ray vector hit ellipsoid coordinates.
-     * If the ray doesn't hit ellipsoid it returns 'undefined'.
+     * If the ray doesn't hit ellipsoid, it returns 'undefined'.
      * @public
      * @param {Ray} ray - Ray.
      * @returns {Vec3 | undefined} -
@@ -450,7 +614,7 @@ export declare class Planet extends RenderNode {
     /**
      * Project screen coordinates to the planet ellipsoid.
      * @public
-     * @param {Vec2 | IBaseInputState} px - Screen coordinates.
+     * @param {Vec2} px - Screen coordinates.
      * @returns {LonLat | undefined} - Geodetic coordinates.
      */
     getLonLatFromPixelEllipsoid(px: Vec2): LonLat | undefined;
@@ -464,7 +628,7 @@ export declare class Planet extends RenderNode {
      * Returns screen coordinates cartesian coordinates on the current terrain.
      * position or null if input coordinates is outside the planet.
      * @public
-     * @param {Vec2} px - Pixel screen 2d coordinates.
+     * @param {Vec2 | IBaseInputState} px - Pixel screen 2d coordinates.
      * @returns {Vec3 | undefined} -
      */
     getCartesianFromPixelTerrain(px: Vec2 | IBaseInputState): Vec3 | undefined;
@@ -493,15 +657,15 @@ export declare class Planet extends RenderNode {
     /**
      * Returns distance from an active (screen) camera to the planet ellipsoid.
      * @public
-     * @param {Vec2} px - Screen coordinates.
-     * @returns {number} -
+     * @param {Vec2 | IBaseInputState} px - Screen coordinates.
+     * @returns {number | undefined} -
      */
     getDistanceFromPixelEllipsoid(px: Vec2 | IBaseInputState): number | undefined;
     /**
      * Returns distance from active (screen) camera to the planet terrain by screen coordinates.
      * @public
      * @param {Vec2 | IBaseInputState} px - Screen coordinates.
-     * @returns {number | undefined} -
+     * @returns {number} -
      */
     getDistanceFromPixel(px: Vec2 | IBaseInputState): number;
     /**
@@ -523,6 +687,11 @@ export declare class Planet extends RenderNode {
      * @returns {Extent} -
      */
     getExtent(): Extent;
+    /**
+     * Returns currently cached quadtree view extent.
+     * @public
+     * @returns {Extent} - Cached view extent.
+     */
     getViewExtent(): Extent;
     /**
      * Sets camera to the planet geographical position.
@@ -559,10 +728,37 @@ export declare class Planet extends RenderNode {
      * @public
      */
     stopFlying(): void;
+    /**
+     * Refreshes billboard texture coordinates for all visible entity collections.
+     * @public
+     */
     updateBillboardsTexCoords(): void;
+    /**
+     * Finds terrain point under an entity in currently rendered segments.
+     * @public
+     * @param {Entity} entity - Entity to test.
+     * @param {Vec3} res - Output vector for terrain point.
+     * @returns {Vec3 | undefined} - Terrain point if found.
+     */
     getEntityTerrainPoint(entity: Entity, res: Vec3): number | undefined;
+    /**
+     * Returns terrain height at the given coordinates in default terrain datum.
+     * @public
+     * @param {LonLat} lonLat - Geodetic coordinates.
+     * @returns {Promise<number>} - Height value.
+     */
     getHeightDefault(lonLat: LonLat): Promise<number>;
+    /**
+     * Returns terrain height above ellipsoid at the given coordinates.
+     * @public
+     * @param {LonLat} lonLat - Geodetic coordinates.
+     * @returns {Promise<number>} - Height above ellipsoid.
+     */
     getHeightAboveELL(lonLat: LonLat): Promise<number>;
+    /**
+     * Handles node detachment and frees runtime terrain data.
+     * @public
+     */
     onremove(): void;
     /**
      * Destroy planet.