@openglobus/og 0.17.2 → 0.18.0

package/src/{og/scene/Planet.js → scene/Planet.ts}

@@ -1,31 +1,74 @@
-"use strict";
-
-import { PlanetCamera } from "../camera/PlanetCamera.js";
-import { Atmosphere } from "../control/Atmosphere.js";
-import { SimpleSkyBackground } from "../control/SimpleSkyBackground.js";
-import { wgs84 } from "../ellipsoid/wgs84.js";
-import { Extent } from "../Extent.js";
-import { Vector } from "../layer/Vector.js";
-import { Key, Lock } from "../Lock.js";
-import { LonLat } from "../LonLat.js";
-import * as math from "../math.js";
-import { decodeFloatFromRGBAArr } from "../math/coder.js";
-import { Quat, Vec3, Vec4 } from "../math/index.js";
-import { EarthQuadTreeStrategy } from "../quadTree/EarthQuadTreeStrategy.js";
-import { NIGHT, SPECULAR } from "../res/images.js";
-import * as segmentHelper from "../segment/segmentHelper.js";
-import * as shaders from "../shaders/drawnode.js";
-import { Geoid } from "../terrain/Geoid.js";
-import { GeoImageCreator } from "../utils/GeoImageCreator.js";
-import { Loader } from "../utils/Loader.js";
-import { NormalMapCreator } from "../utils/NormalMapCreator.js";
-import { PlainSegmentWorker } from "../utils/PlainSegmentWorker.js";
-import * as utils from "../utils/shared.js";
-import { createColorRGB, isUndef } from "../utils/shared.js";
-import { TerrainWorker } from "../utils/TerrainWorker.js";
-import { VectorTileCreator } from "../utils/VectorTileCreator.js";
-import { Framebuffer } from "../webgl/Framebuffer.js";
-import { RenderNode } from "./RenderNode.js";
+import * as math from "../math";
+import * as segmentHelper from "../segment/segmentHelper";
+import * as shaders from "../shaders/drawnode";
+import * as utils from "../utils/shared";
+import {Atmosphere} from "../control/Atmosphere";
+import {Control} from "../control/Control";
+import {createColorRGB, isUndef} from "../utils/shared";
+import {createEvents, EventsHandler} from "../Events";
+import {decodeFloatFromRGBAArr} from "../math/coder";
+import {EarthQuadTreeStrategy} from "../quadTree/EarthQuadTreeStrategy";
+import {EmptyTerrain} from "../terrain/EmptyTerrain";
+import {Extent} from "../Extent";
+import {Entity} from "../entity/Entity";
+import {Ellipsoid} from "../ellipsoid/Ellipsoid";
+import {EntityCollection} from "../entity/EntityCollection";
+import {Geoid, GeoidModel} from "../terrain/Geoid";
+import {GeoImageCreator} from "../utils/GeoImageCreator";
+import {IBaseInputState} from "../renderer/RendererEvents";
+import {Key, Lock} from "../Lock";
+import {Layer} from "../layer/Layer";
+import {Loader} from "../utils/Loader";
+import {LonLat} from "../LonLat";
+import {Node} from "../quadTree/Node";
+import {NormalMapCreator} from "../utils/NormalMapCreator";
+import {PlainSegmentWorker} from "../utils/PlainSegmentWorker";
+import {PlanetCamera} from "../camera/PlanetCamera";
+import {Quat} from "../math/Quat";
+import {QuadTreeStrategy} from "../quadTree/QuadTreeStrategy";
+import {Ray} from "../math/Ray";
+import {RenderNode} from "./RenderNode";
+import {SimpleSkyBackground} from "../control/SimpleSkyBackground";
+import {Sun} from "../control/Sun";
+import {TerrainWorker} from "../utils/TerrainWorker";
+import {Vec2, Vec3, Vec4, NumberArray2, NumberArray3, NumberArray4} from "../math/index";
+import {Vector} from "../layer/Vector";
+import {VectorTileCreator} from "../utils/VectorTileCreator";
+import {wgs84} from "../ellipsoid/wgs84";
+import {WebGLBufferExt, WebGLTextureExt, IDefaultTextureParams} from "../webgl/Handler";
+import Constructor = jest.Constructor;
+
+export interface IPlanetParams {
+    name?: string;
+    ellipsoid?: Ellipsoid;
+    minAltitude?: number;
+    maxAltitude?: number;
+    frustums?: NumberArray2[];
+    maxEqualZoomAltitude?: number;
+    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;
+    maxLoadingRequests?: number;
+    atmosphereEnabled?: boolean;
+}
+
+export type PlanetEventsList = [
+    "draw",
+    "layeradd",
+    "baselayerchange",
+    "layerremove",
+    "layervisibilitychange",
+    "rendercompleted",
+    "terraincompleted",
+    "layerloadend"
+];
 
 const CUR_LOD_SIZE = 250; //px
 const MIN_LOD_SIZE = 312; //px
@@ -46,290 +89,411 @@ const MAX_NODES = 200;
 
 const HORIZON_TANGENT = 0.81;
 
-const EVENT_NAMES = [
+type IndexBufferCacheData = { buffer: WebGLBufferExt | null };
+
+/**
+ * Main class for rendering 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
+ *
+ * @fires EventsHandler<PlanetEventList>#draw
+ * @fires EventsHandler<PlanetEventList>#layeradd
+ * @fires EventsHandler<PlanetEventList>#baselayerchange
+ * @fires EventsHandler<PlanetEventList>#layerremove
+ * @fires EventsHandler<PlanetEventList>#layervisibilitychange
+ * @fires EventsHandler<PlanetEventList>#geoimageadd
+ */
+export class Planet extends RenderNode {
+
+    public events: EventsHandler<PlanetEventsList>;
+
     /**
-     * Triggered before globe frame begins to render.
-     * @event og.scene.Planet#draw
+     * @public
+     * @type {Ellipsoid}
      */
-    "draw",
+    public ellipsoid: Ellipsoid;
 
     /**
-     * Triggered when layer has added to the planet.
-     * @event og.scene.Planet#layeradd
+     * @public
+     * @override
+     * @type {Boolean}
      */
-    "layeradd",
+    public override lightEnabled: boolean;
 
     /**
-     * Triggered when base layer changed.
-     * @event og.scene.Planet#baselayerchange
+     * Squared ellipsoid radius.
+     * @public
+     * @type {number}
      */
-    "baselayerchange",
+    public _planetRadius2: number;
 
     /**
-     * Triggered when layer has removed from the planet.
-     * @event og.scene.Planet#layerremove
+     * Layers array.
+     * @public
+     * @type {Array.<Layer>}
      */
-    "layerremove",
+    public _layers: Layer[];
 
     /**
-     * Triggered when some layer visibility changed.
-     * @event og.scene.Planet#layervisibilitychange
+     * Flag to trigger layer update in a next frame
+     * @type {boolean}
+     * @protected
      */
-    "layervisibilitychange",
+    protected _updateLayer: boolean;
 
     /**
-     * Triggered when all data is loaded
-     * @event og.scene.Planet#rendercompleted
+     * Current visible imagery tile layers array.
+     * @public
+     * @type {Array.<Layer>}
      */
-    "rendercompleted",
+    public visibleTileLayers: Layer[];
 
     /**
-     * Triggered when all data is loaded
-     * @event og.scene.Planet#terraincompleted
+     * Current visible vector layers array.
+     * @protected
+     * @type {Array.<Layer>}
      */
-    "terraincompleted",
+    protected visibleVectorLayers: Layer[];
+
+    protected _visibleTileLayerSlices: Layer[][];
 
     /**
-     * Triggered when layer data is laded
-     * @event og.scene.Planet#terraincompleted
+     * Vector layers visible nodes with collections.
+     * @protected
+     * @type {Array.<EntityCollection>}
      */
-    "layerloadend"
-];
+    protected _frustumEntityCollections: EntityCollection[];
 
-/**
- * Main class for rendering 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 bacame the same zoom level
- * @param {Number} [options.minEqualZoomAltitude=10000.0] - Minimal altitude since segments on the screen bacame the same zoom level
- * @param {Number} [options.minEqualZoomCameraSlope=0.8] - Minimal camera slope above te globe where segments on the screen bacame the same zoom level
- * @fires og.scene.Planet#draw
- * @fires og.scene.Planet#layeradd
- * @fires og.scene.Planet#baselayerchange
- * @fires og.scene.Planet#layerremove
- * @fires og.scene.Planet#layervisibilitychange
- * @fires og.scene.Planet#geoimageadd
- */
-export class Planet extends RenderNode {
-    constructor(options = {}) {
+    /**
+     * There is only one base layer on the globe when layer.isBaseLayer is true.
+     * @public
+     * @type {Layer}
+     */
+    public baseLayer: Layer | null;
+
+    /**
+     * Terrain provider.
+     * @public
+     * @type {EmptyTerrain}
+     */
+    public terrain: EmptyTerrain | null;
+
+    /**
+     * Camera is this.renderer.activeCamera pointer.
+     * @public
+     * @type {PlanetCamera}
+     */
+    public camera: PlanetCamera;
+
+    public maxEqualZoomAltitude: number;
+    public minEqualZoomAltitude: number;
+    public minEqualZoomCameraSlope: number;
+
+    /**
+     * Screen mouse pointer projected to planet cartesian position.
+     * @public
+     * @type {Vec3}
+     */
+    public mousePositionOnEarth: Vec3;
+
+    public emptyTexture: WebGLTextureExt | null;
+    public transparentTexture: WebGLTextureExt | null;
+    public defaultTexture: WebGLTextureExt | null;
+
+    /**
+     * Current visible minimal zoom index planet segment.
+     * @public
+     * @type {number}
+     */
+    public minCurrZoom: number;
+
+    /**
+     * Current visible maximal zoom index planet segment.
+     * @public
+     * @type {number}
+     */
+    public maxCurrZoom: number;
+
+    public _viewExtent: Extent;
+
+    protected _initialViewExtent: Extent | null;
+
+    public _createdNodesCount: number;
+
+    /**
+     * Planet's segments collected for rendering frame.
+     * @public
+     * @type {Node}
+     */
+    public _renderedNodes: Node[];
+
+    public _renderedNodesInFrustum: Node[][];
+
+    /**
+     * Current visible mercator segments tree nodes array.
+     * @public
+     * @type {Node}
+     *
+     * @todo
+     * _visibleNodes, _visibleNodesNorth and _visibleNodesSouth should
+     * be replaced to strategy and Vector layer reworked in collecting methods.
+     * _visibleNodes, and _visibleNodesNorth and South are used in Vector
+     * layer only, for entity terrain collision
+     *
+     */
+    public _visibleNodes: Record<number, Node>;
+
+    /**
+     * Current visible north pole nodes tree nodes array.
+     * @public
+     * @type {Node}
+     * @todo
+     */
+    public _visibleNodesNorth: Record<number, Node>;
+
+    /**
+     * Current visible south pole nodes tree nodes array.
+     * @public
+     * @type {Node}
+     * @todo
+     */
+    public _visibleNodesSouth: Record<number, Node>;
+
+    /**
+     * Layers activity lock.
+     * @public
+     * @type {Lock}
+     */
+    public layerLock: Lock;
+
+    /**
+     * Terrain providers activity lock.
+     * @public
+     * @type {Lock}
+     */
+    public terrainLock: Lock;
+
+    /**
+     * Height scale factor. 1 - is normal elevation scale.
+     * @public
+     * @type {number}
+     */
+    public _heightFactor: number;
+
+    /**
+     * Precomputed indexes array for different grid size segments.
+     * @protected
+     * @type {Array.<Array.<number>>}
+     */
+    public _indexesCache: IndexBufferCacheData[][][][][];
+
+    protected _indexesCacheToRemove: IndexBufferCacheData[];
+    public _indexesCacheToRemoveCounter: number;
+
+    /**
+     * Precomputed texture coordinates buffers for different grid size segments.
+     * @public
+     * @type {Array.<Array.<number>>}
+     */
+    public _textureCoordsBufferCache: WebGLBufferExt[];
+
+    public quadTreeStrategy: QuadTreeStrategy;
+
+    /**
+     * Night glowing gl texture.
+     * @protected
+     */
+    protected _nightTexture: WebGLTextureExt | null;
+
+    /**
+     * Specular mask gl texture.
+     * @protected
+     */
+    protected _specularTexture: WebGLTextureExt | null;
+
+
+    public _ambient: Float32Array;
+    public _diffuse: Float32Array;
+    public _specular: Float32Array;
+
+    protected _maxGridSize: number;
+
+    /**
+     * Segment multiple textures size.(4 - convenient value for the most devices)
+     * @const
+     * @public
+     */
+    public SLICE_SIZE: number;
+    public SLICE_SIZE_4: number;
+    public SLICE_SIZE_3: number;
+
+    /**
+     * Level of details of visible segments.
+     * @protected
+     * @type {number}
+     */
+    protected _lodSize: number;
+    protected _curLodSize: number;
+    protected _minLodSize: number;
+    public _maxLodSize: number;
+
+    public _pickingColorArr: Float32Array;
+    public _samplerArr: Int32Array;
+    public _pickingMaskArr: Int32Array;
+
+    /**
+     * GeoImage creator.
+     * @public
+     * @type{GeoImageCreator}
+     */
+    public _geoImageCreator: GeoImageCreator;
+
+    /**
+     * VectorTileCreator creator.
+     * @public
+     * @type{VectorTileCreator}
+     */
+    public _vectorTileCreator: VectorTileCreator;
+
+    /**
+     * NormalMapCreator creator.
+     * @public
+     * @type{NormalMapCreator}
+     */
+    public _normalMapCreator: NormalMapCreator;
+
+    public _terrainWorker: TerrainWorker;
+
+    public _plainSegmentWorker: PlainSegmentWorker;
+
+    public _tileLoader: Loader<Layer>;
+
+    protected _memKey: Key;
+
+    public _distBeforeMemClear: number;
+
+    protected _prevCamEye: Vec3;
+
+    protected _initialized: boolean;
+
+    protected always: any[];
+
+    public _renderCompleted: boolean
+    public _renderCompletedActivated: boolean;
+
+    public _terrainCompleted: boolean;
+    public _terrainCompletedActivated: boolean;
+
+    protected _collectRenderNodesIsActive: boolean;
+
+    /**
+     * Night texture brightness coefficient
+     * @type {number}
+     */
+    public nightTextureCoefficient: number;
+
+    protected _renderScreenNodesPASS: Function;
+
+    protected _atmosphereEnabled: boolean;
+    protected _atmosphereMaxMinOpacity: Float32Array;
+
+    public solidTextureOne: WebGLTextureExt | null;
+    public solidTextureTwo: WebGLTextureExt | null;
+
+    protected _skipPreRender: boolean;
+
+    protected _nightTextureSrc: string | null;
+    protected _specularTextureSrc: string | null;
+
+    constructor(options: IPlanetParams = {}) {
         super(options.name);
 
-        /**
-         * @public
-         * @type {Ellipsoid}
-         */
         this.ellipsoid = options.ellipsoid || wgs84;
 
-        /**
-         * @public
-         * @type {Boolean}
-         */
         this.lightEnabled = true;
 
-        /**
-         * Squared ellipsoid radius.
-         * @protected
-         * @type {number}
-         */
         this._planetRadius2 = this.ellipsoid.getPolarSize() * this.ellipsoid.getPolarSize();
 
-        /**
-         * Layers array.
-         * @protected
-         * @type {Array.<Layer>}
-         */
         this._layers = [];
 
-        /**
-         * Flag to trigger layer update in a next frame
-         * @type {boolean}
-         * @private
-         */
         this._updateLayer = false;
 
-        /**
-         * Current visible imagery tile layers array.
-         * @public
-         * @type {Array.<Layer>}
-         */
         this.visibleTileLayers = [];
 
-        /**
-         * Current visible vector layers array.
-         * @protected
-         * @type {Array.<layer.Vector>}
-         */
         this.visibleVectorLayers = [];
 
         this._visibleTileLayerSlices = [];
 
-        /**
-         * Vector layers visible nodes with collections.
-         * @protected
-         * @type {Array.<EntityCollection>}
-         */
         this._frustumEntityCollections = [];
 
-        /**
-         * There is only one base layer on the globe when layer.isBaseLayer is true.
-         * @public
-         * @type {Layer}
-         */
         this.baseLayer = null;
 
-        /**
-         * Terrain provider.
-         * @public
-         * @type {Terrain}
-         */
         this.terrain = null;
 
-        /**
-         * Terrain provider Pool.
-         * @public
-         * @type {Terrain}
-         */
-        this._terrainPool = null;
-
-        this._minAltitude = options.minAltitude;
-        this._maxAltitude = options.maxAltitude;
-
-        /**
-         * Camera is this.renderer.activeCamera pointer.
-         * @public
-         * @type {PlanetCamera}
-         */
         this.camera = new PlanetCamera(this, {
             frustums: options.frustums,
             eye: new Vec3(25000000, 0, 0),
             look: Vec3.ZERO,
             up: Vec3.NORTH,
-            minAltitude: this._minAltitude,
-            maxAltitude: this._maxAltitude
+            minAltitude: options.minAltitude,
+            maxAltitude: options.maxAltitude
         });
 
         this.maxEqualZoomAltitude = options.maxEqualZoomAltitude || 15000000.0;
         this.minEqualZoomAltitude = options.minEqualZoomAltitude || 10000.0;
         this.minEqualZoomCameraSlope = options.minEqualZoomCameraSlope || 0.8;
 
-        /**
-         * Screen mouse pointer projected to planet cartesian position.
-         * @public
-         * @type {Vec3}
-         */
         this.mousePositionOnEarth = new Vec3();
 
         this.emptyTexture = null;
         this.transparentTexture = null;
         this.defaultTexture = null;
 
-        /**
-         * Current visible minimal zoom index planet segment.
-         * @public
-         * @type {number}
-         */
         this.minCurrZoom = math.MAX;
 
-        /**
-         * Current visible maximal zoom index planet segment.
-         * @public
-         * @type {number}
-         */
         this.maxCurrZoom = math.MIN;
 
         this._viewExtent = new Extent(new LonLat(180, 180), new LonLat(-180, -180));
 
+        this._skipPreRender = false;
+
         this._initialViewExtent = null;
 
-        /**
-         * @protected
-         */
         this._createdNodesCount = 0;
 
-        /**
-         * Planet's segments collected for rendering frame.
-         * @protected
-         * @type {quadTree.Node}
-         */
         this._renderedNodes = [];
         this._renderedNodesInFrustum = [];
 
-        /**
-         * Current visible mercator segments tree nodes array.
-         * @protected
-         * @type {quadTree.Node}
-         */
         this._visibleNodes = {};
 
-        /**
-         * Current visible north pole nodes tree nodes array.
-         * @protected
-         * @type {quadTree.Node}
-         */
         this._visibleNodesNorth = {};
 
-        /**
-         * Current visible south pole nodes tree nodes array.
-         * @protected
-         * @type {quadTree.Node}
-         */
         this._visibleNodesSouth = {};
 
-        /**
-         * Layers activity lock.
-         * @public
-         * @type {idle.Lock}
-         */
         this.layerLock = new Lock();
 
-        /**
-         * Terrain providers activity lock.
-         * @public
-         * @type {idle.Lock}
-         */
         this.terrainLock = new Lock();
 
-        /**
-         * Height scale factor. 1 - is normal elevation scale.
-         * @protected
-         * @type {number}
-         */
         this._heightFactor = 1.0;
 
-        /**
-         * Precomputed indexes array for differrent grid size segments.
-         * @protected
-         * @type {Array.<Array.<number>>}
-         */
         this._indexesCache = [];
         this._indexesCacheToRemove = [];
         this._indexesCacheToRemoveCounter = 0;
 
-        /**
-         * Precomputed texture coordinates buffers for differrent grid size segments.
-         * @protected
-         * @type {Array.<Array.<number>>}
-         */
         this._textureCoordsBufferCache = [];
 
-        this.quadTreeStrategy = options.quadTreeStrategyPrototype ? new options.quadTreeStrategyPrototype({ planet: this }) : new EarthQuadTreeStrategy({ planet: this });
+        this.quadTreeStrategy = options.quadTreeStrategyPrototype ? new options.quadTreeStrategyPrototype(this) : new EarthQuadTreeStrategy(this);
 
-        /**
-         * Night glowing gl texture.
-         * @protected
-         */
         this._nightTexture = null;
 
-        /**
-         * Specular mask gl texture.
-         * @protected
-         */
         this._specularTexture = null;
 
-        //TODO: replace to a function
         let a = utils.createColorRGB(options.ambient, new Vec3(0.2, 0.2, 0.3));
         let d = utils.createColorRGB(options.diffuse, new Vec3(1.0, 1.0, 1.0));
         let s = utils.createColorRGB(options.specular, new Vec3(0.00063, 0.00055, 0.00032));
@@ -339,36 +503,12 @@ export class Planet extends RenderNode {
         this._diffuse = new Float32Array([d.x, d.y, d.z]);
         this._specular = new Float32Array([s.x, s.y, s.z, shininess]);
 
-        /**
-         * True for rendering night glowing texture.
-         * @protected
-         * @type {boolean}
-         */
-        this._useNightTexture = isUndef(options.useNightTexture) ? true : options.useNightTexture;
-
-        /**
-         * True for rendering specular mask texture.
-         * @protected
-         * @type {boolean}
-         */
-        this._useSpecularTexture = isUndef(options.useSpecularTexture) ? true : options.useSpecularTexture;
-
         this._maxGridSize = Math.log2(options.maxGridSize || 128);
 
-        /**
-         * Segment multiple textures size.(4 - convinient value for the most devices)
-         * @const
-         * @public
-         */
         this.SLICE_SIZE = 4;
         this.SLICE_SIZE_4 = this.SLICE_SIZE * 4;
         this.SLICE_SIZE_3 = this.SLICE_SIZE * 3;
 
-        /**
-         * Level of the visible segment detalization.
-         * @public
-         * @type {number}
-         */
         this._lodSize = CUR_LOD_SIZE;
         this._curLodSize = CUR_LOD_SIZE;
         this._minLodSize = MIN_LOD_SIZE;
@@ -378,25 +518,10 @@ export class Planet extends RenderNode {
         this._samplerArr = new Int32Array(this.SLICE_SIZE);
         this._pickingMaskArr = new Int32Array(this.SLICE_SIZE);
 
-        /**
-         * GeoImage creator.
-         * @protected
-         * @type{GeoImageCreator}
-         */
         this._geoImageCreator = new GeoImageCreator(this);
 
-        /**
-         * VectorTileCreator creator.
-         * @protected
-         * @type{VectorTileCreator}
-         */
         this._vectorTileCreator = new VectorTileCreator(this);
 
-        /**
-         * NormalMapCreator creator.
-         * @protected
-         * @type{NormalMapCreator}
-         */
         this._normalMapCreator = new NormalMapCreator(this);
 
         this._terrainWorker = new TerrainWorker(3);
@@ -407,7 +532,7 @@ export class Planet extends RenderNode {
 
         this._memKey = new Key();
 
-        this.events.registerNames(EVENT_NAMES);
+        this.events = createEvents<PlanetEventsList>(PLANET_EVENTS);
 
         this._distBeforeMemClear = 0.0;
 
@@ -424,107 +549,123 @@ export class Planet extends RenderNode {
         this._terrainCompletedActivated = false;
         this._collectRenderNodesIsActive = true;
 
-        /**
-         * Night texture brightness coefficient
-         * @type {number}
-         */
         this.nightTextureCoefficient = 2.0;
 
         this._renderScreenNodesPASS = this._renderScreenNodesPASSNoAtmos;
 
         this._atmosphereEnabled = options.atmosphereEnabled || false;
         this._atmosphereMaxMinOpacity = new Float32Array([1.0, 0.41]);
+
+        this.solidTextureOne = null;
+        this.solidTextureTwo = null;
+
+        this._nightTextureSrc = options.nightTextureSrc || null;
+        this._specularTextureSrc = options.specularTextureSrc || null;
+    }
+
+    public get maxGridSize(): number {
+        return this._maxGridSize;
     }
 
-    getNorthFrameRotation(cartesian) {
+    public getNorthFrameRotation(cartesian: Vec3): Quat {
         return this.ellipsoid.getNorthFrameRotation(cartesian);
     }
 
-    set atmosphereMaxOpacity(opacity) {
+    public set atmosphereMaxOpacity(opacity: number) {
         this._atmosphereMaxMinOpacity[0] = opacity;
     }
 
-    get atmosphereMaxOpacity() {
+    public get atmosphereMaxOpacity(): number {
         return this._atmosphereMaxMinOpacity[0];
     }
 
-    set atmosphereMinOpacity(opacity) {
+    public set atmosphereMinOpacity(opacity: number) {
         this._atmosphereMaxMinOpacity[1] = opacity;
     }
 
-    get atmosphereMinOpacity() {
+    public get atmosphereMinOpacity(): number {
         return this._atmosphereMaxMinOpacity[1];
     }
 
-
-    set atmosphereEnabled(enabled) {
+    public set atmosphereEnabled(enabled: boolean) {
         if (enabled != this._atmosphereEnabled) {
             this._atmosphereEnabled = enabled;
             this._initializeAtmosphere();
         }
     }
 
-    get atmosphereEnabled() {
+    public get atmosphereEnabled(): boolean {
         return this._atmosphereEnabled;
     }
 
-    set diffuse(rgb) {
+    public set diffuse(rgb: string | NumberArray3 | Vec3) {
         let vec = createColorRGB(rgb);
         this._diffuse = new Float32Array(vec.toArray());
     }
 
-    set ambient(rgb) {
+    public set ambient(rgb: string | NumberArray3 | Vec3) {
         let vec = createColorRGB(rgb);
         this._ambient = new Float32Array(vec.toArray());
     }
 
-    set specular(rgb) {
+    public set specular(rgb: string | NumberArray3 | Vec3) {
         let vec = createColorRGB(rgb);
         this._specular = new Float32Array([vec.x, vec.y, vec.y, this._specular[3]]);
     }
 
-    set shininess(v) {
+    public set shininess(v: number) {
         this._specular[3] = v;
     }
 
-    get normalMapCreator() {
+    public get normalMapCreator(): NormalMapCreator {
         return this._normalMapCreator;
     }
 
-    get layers() {
+    public get layers(): Layer[] {
         return [...this._layers];
     }
 
-    get sunPos() {
-        return this.renderer.controls.sun.sunlight.getPosition();
+    /**
+     * @todo: remove after tests
+     * Get the collection of layers associated with this planet.
+     * @return {Array.<Layer>} Layers array.
+     * @public
+     */
+    public getLayers(): Layer[] {
+        return this.layers;
+    }
+
+
+    public get sunPos(): Vec3 {
+        return (this.renderer!.controls.sun as Sun).sunlight.getPosition();
     }
 
     /**
      * Add the given control to the renderer of the planet scene.
-     * @param {control.Control} control - Control.
+     * @param {Control} control - Control.
      */
-    addControl(control) {
+    public addControl(control: Control) {
         control.planet = this;
-        control.addTo(this.renderer);
+        control.addTo(this.renderer!);
     }
 
-    get lodSize() {
+    public get lodSize(): number {
         return this._lodSize;
     }
 
-    setLodSize(currentLodSize, minLodSize, maxLodSize) {
+    public setLodSize(currentLodSize: number, minLodSize?: number, maxLodSize?: number) {
         this._maxLodSize = maxLodSize || this._maxLodSize;
         this._minLodSize = minLodSize || this._minLodSize;
-        this._curLodSize = currentLodSize || this._curLodSize;
+        this._curLodSize = currentLodSize;
         this._renderCompletedActivated = false;
         this._terrainCompletedActivated = false;
     }
 
     /**
      * Add the given controls array to the renderer of the planet.
-     * @param {Array.<control.Control>} cArr - Control array.
+     * @param {Array.<Control>} cArr - Control array.
      */
-    addControls(cArr) {
+    public addControls(cArr: Control[]) {
         for (let i = 0; i < cArr.length; i++) {
             this.addControl(cArr[i]);
         }
@@ -536,7 +677,7 @@ export class Planet extends RenderNode {
      * @public
      * @returns {Layer} -
      */
-    getLayerByName(name) {
+    public getLayerByName(name: string): Layer | undefined {
         for (let i = 0, len = this._layers.length; i < len; i++) {
             if (name === this._layers[i].name) {
                 return this._layers[i];
@@ -545,20 +686,20 @@ export class Planet extends RenderNode {
     }
 
     /**
-     * Adds the given layer to the planet.
+     * Adds layer to the planet.
      * @param {Layer} layer - Layer object.
      * @public
      */
-    addLayer(layer) {
+    public addLayer(layer: Layer) {
         layer.addTo(this);
     }
 
     /**
      * Dispatch layer visibility changing event.
      * @param {Layer} layer - Changed layer.
-     * @protected
+     * @public
      */
-    _onLayerVisibilityChanged(layer) {
+    public _onLayerVisibilityChanged(layer: Layer) {
         this.events.dispatch(this.events.layervisibilitychange, layer);
     }
 
@@ -567,7 +708,7 @@ export class Planet extends RenderNode {
      * @param {Array.<Layer>} layers - Layers array.
      * @public
      */
-    addLayers(layers) {
+    public addLayers(layers: Layer[]) {
         for (let i = 0, len = layers.length; i < len; i++) {
             this.addLayer(layers[i]);
         }
@@ -576,38 +717,27 @@ export class Planet extends RenderNode {
     /**
      * Removes the given layer from the planet.
      * @param {Layer} layer - Layer to remove.
-     * @return {Layer|undefined} The removed layer or undefined if the layer was not found.
      * @public
      */
-    removeLayer(layer) {
-        return layer.remove();
+    public removeLayer(layer: Layer) {
+        layer.remove();
     }
 
     /**
      *
-     * @protected
+     * @public
      * @param {Layer} layer - Material layer.
      */
-    _clearLayerMaterial(layer) {
+    public _clearLayerMaterial(layer: Layer) {
         this.quadTreeStrategy.clearLayerMaterial(layer);
     }
 
-
-    /**
-     * Get the collection of layers associated with this planet.
-     * @return {Array.<Layer>} Layers array.
-     * @public
-     */
-    getLayers() {
-        return this.layers;
-    }
-
     /**
      * Sets base layer coverage to the planet.
      * @param {Layer} layer - Layer object.
      * @public
      */
-    setBaseLayer(layer) {
+    public setBaseLayer(layer: Layer) {
         if (this.baseLayer) {
             if (!this.baseLayer.isEqual(layer)) {
                 this.baseLayer.setVisibility(false);
@@ -626,13 +756,15 @@ export class Planet extends RenderNode {
      * Sets elevation scale. 1.0 is default.
      * @param {number} factor - Elevation scale.
      */
-    setHeightFactor(factor) {
+    public setHeightFactor(factor: number) {
         this._renderCompletedActivated = false;
         this._terrainCompletedActivated = false;
 
         if (this._heightFactor !== factor) {
             this._heightFactor = factor;
             this.quadTreeStrategy.destroyBranches();
+            this._clearRenderedNodeList();
+            this._clearRenderNodesInFrustum();
         }
     }
 
@@ -640,16 +772,16 @@ export class Planet extends RenderNode {
      * Gets elevation scale.
      * @returns {number} Terrain elevation scale
      */
-    getHeightFactor() {
+    public getHeightFactor(): number {
         return this._heightFactor;
     }
 
     /**
      * Sets terrain provider
      * @public
-     * @param {Terrain} terrain - Terrain provider.
+     * @param {EmptyTerrain} terrain - Terrain provider.
      */
-    setTerrain(terrain) {
+    public setTerrain(terrain: EmptyTerrain) {
         this._renderCompletedActivated = false;
         this._terrainCompletedActivated = false;
 
@@ -672,9 +804,9 @@ export class Planet extends RenderNode {
             this._plainSegmentWorker.setGeoid(terrain.getGeoid());
             terrain._isReady = true;
         } else {
-            Geoid.loadModel(terrain._geoid.src)
-                .then((m) => {
-                    terrain.getGeoid().setModel(m);
+            Geoid.loadModel(terrain.geoid.src)
+                .then((m: GeoidModel | null) => {
+                    terrain.geoid.setModel(m);
                     this._plainSegmentWorker.setGeoid(terrain.getGeoid());
                     terrain._isReady = true;
                 })
@@ -684,8 +816,8 @@ export class Planet extends RenderNode {
         }
     }
 
-    _initializeAtmosphere() {
-        let h = this.renderer.handler;
+    protected _initializeAtmosphere() {
+        let h = this.renderer!.handler;
         h.removeProgram("drawnode_screen_wl");
 
         if (this._atmosphereEnabled) {
@@ -698,29 +830,28 @@ export class Planet extends RenderNode {
                 h.addProgram(shaders.drawnode_screen_wl_webgl1NoAtmos(), true);
             }
 
-            if (!this.renderer.controls.Atmosphere) {
+            if (!this.renderer!.controls.Atmosphere) {
                 this.addControl(new Atmosphere());
             } else {
-                this.renderer.controls.Atmosphere.activate();
+                this.renderer!.controls.Atmosphere.activate();
             }
 
-            if (this.renderer.controls.SimpleSkyBackground) {
-                this.renderer.controls.SimpleSkyBackground.deactivate();
+            if (this.renderer!.controls.SimpleSkyBackground) {
+                this.renderer!.controls.SimpleSkyBackground.deactivate();
             }
 
         } else {
 
             this._renderScreenNodesPASS = this._renderScreenNodesPASSNoAtmos;
 
-
-            if (this.renderer.controls.Atmosphere) {
-                this.renderer.controls.Atmosphere.deactivate();
+            if (this.renderer!.controls.Atmosphere) {
+                this.renderer!.controls.Atmosphere.deactivate();
             }
 
-            if (!this.renderer.controls.SimpleSkyBackground) {
+            if (!this.renderer!.controls.SimpleSkyBackground) {
                 this.addControl(new SimpleSkyBackground());
             } else {
-                this.renderer.controls.SimpleSkyBackground.activate();
+                this.renderer!.controls.SimpleSkyBackground.activate();
             }
 
             if (h.isWebGl2()) {
@@ -731,37 +862,30 @@ export class Planet extends RenderNode {
         }
     }
 
-    /**
-     * @virtual
-     * @protected
-     */
-    _initializeShaders() {
-        let h = this.renderer.handler;
+    protected _initializeShaders() {
+        let h = this.renderer!.handler;
 
         h.addProgram(shaders.drawnode_screen_nl(), true);
         h.addProgram(shaders.drawnode_colorPicking(), true);
         h.addProgram(shaders.drawnode_depth(), true);
         h.addProgram(shaders.drawnode_heightPicking(), true);
 
-        this.renderer.addPickingCallback(this, this._renderColorPickingFramebufferPASS);
-        this.renderer.addDepthCallback(this, this._renderDepthFramebufferPASS);
-        this.renderer.addDistanceCallback(this, this._renderDistanceFramebufferPASS);
+        this.renderer!.addPickingCallback(this, this._renderColorPickingFramebufferPASS);
+        this.renderer!.addDepthCallback(this, this._renderDepthFramebufferPASS);
+        this.renderer!.addDistanceCallback(this, this._renderDistanceFramebufferPASS);
     }
 
-    _onLayerLoadend(layer) {
+    protected _onLayerLoadend(layer: Layer) {
         this.events.dispatch(this.events.layerloadend, layer);
     }
 
-    /**
-     * @virtual
-     * @public
-     */
-    init() {
+    public override init() {
 
         this._tileLoader.events.on("layerloadend", this._onLayerLoadend, this);
 
         // Initialization indexes table
         segmentHelper.getInstance().setMaxGridSize(this._maxGridSize);
+
         const TABLESIZE = this._maxGridSize;
 
         let kk = 0;
@@ -775,16 +899,14 @@ export class Planet extends RenderNode {
                     for (let m = 0; m <= TABLESIZE; m++) {
                         !this._indexesCache[i][j][k][m] && (this._indexesCache[i][j][k][m] = new Array(TABLESIZE));
                         for (let q = 0; q <= TABLESIZE; q++) {
-                            let ptr = {
+
+                            let ptr: IndexBufferCacheData = {
                                 buffer: null
                             };
 
                             if (i >= 1 && i === j && i === k && i === m && i === q) {
-                                let indexes = segmentHelper
-                                    .getInstance()
-                                    .createSegmentIndexes(i, [j, k, m, q]);
-                                ptr.buffer = this.renderer.handler.createElementArrayBuffer(indexes, 1);
-                                indexes = null;
+                                let indexes = segmentHelper.getInstance().createSegmentIndexes(i, [j, k, m, q]);
+                                ptr.buffer = this.renderer!.handler.createElementArrayBuffer(indexes, 1);
                             } else {
                                 this._indexesCacheToRemove[kk++] = ptr;
                             }
@@ -796,7 +918,7 @@ export class Planet extends RenderNode {
             }
         }
 
-        this.renderer.events.on("resize", () => {
+        this.renderer!.events.on("resize", () => {
             this._renderCompletedActivated = false;
             this._terrainCompletedActivated = false;
         });
@@ -807,19 +929,16 @@ export class Planet extends RenderNode {
         let texCoordCache = segmentHelper.getInstance().initTextureCoordsTable(TABLESIZE + 1);
 
         for (let i = 0; i <= TABLESIZE; i++) {
-            this._textureCoordsBufferCache[i] = this.renderer.handler.createArrayBuffer(texCoordCache[i], 2, ((1 << i) + 1) * ((1 << i) + 1));
+            this._textureCoordsBufferCache[i] = this.renderer!.handler.createArrayBuffer(texCoordCache[i], 2, ((1 << i) + 1) * ((1 << i) + 1));
         }
 
-        texCoordCache = null;
-
         // creating empty textures
-        var that = this;
-        this.renderer.handler.createDefaultTexture(null, function (t) {
-            that.solidTextureOne = t;
-            that.solidTextureTwo = t;
+        this.renderer!.handler.createDefaultTexture(null, (t: WebGLTextureExt) => {
+            this.solidTextureOne = t;
+            this.solidTextureTwo = t;
         });
 
-        this.transparentTexture = this.renderer.handler.transparentTexture;
+        this.transparentTexture = this.renderer!.handler.transparentTexture;
 
         this._renderedNodesInFrustum = new Array(this.camera.frustums.length);
         for (let i = 0, len = this._renderedNodesInFrustum.length; i < len; i++) {
@@ -829,7 +948,7 @@ export class Planet extends RenderNode {
         // Creating quad trees nodes
         this.quadTreeStrategy.init();
 
-        this.drawMode = this.renderer.handler.gl.TRIANGLE_STRIP;
+        this.drawMode = this.renderer!.handler.gl!.TRIANGLE_STRIP;
 
         // Applying shaders
         this._initializeShaders();
@@ -838,16 +957,35 @@ export class Planet extends RenderNode {
 
         this._updateVisibleLayers();
 
-        this.renderer.addPickingCallback(this, this._frustumEntityCollectionPickingCallback);
+        this.renderer!.addPickingCallback(this, this._frustumEntityCollectionPickingCallback);
 
         // loading Earth night glowing texture
-        if (this._useNightTexture) {
-            createImageBitmap(NIGHT).then((e) => (this._nightTexture = this.renderer.handler.createTextureDefault(e)));
+        if (this._nightTextureSrc) {
+
+            let img = new Image();
+            img.onload = () => {
+                this._nightTexture = this.renderer!.handler.createTextureDefault(img)!;
+                this._nightTexture.default = true;
+            };
+            img.src = this._nightTextureSrc;
+
+            // createImageBitmap(NIGHT).then((e: ImageBitmap) => {
+            //     this._nightTexture = this.renderer!.handler!.createTextureDefault(e);
+            // });
         }
 
         // load water specular mask
-        if (this._useSpecularTexture) {
-            createImageBitmap(SPECULAR).then((e) => (this._specularTexture = this.renderer.handler.createTexture_l(e)));
+        if (this._specularTextureSrc) {
+            let img = new Image();
+            img.onload = () => {
+                this._specularTexture = this.renderer!.handler.createTextureDefault(img)!;
+                this._specularTexture.default = true;
+            };
+            img.src = this._specularTextureSrc;
+
+            // createImageBitmap(SPECULAR).then((e: ImageBitmap) => {
+            //     this._specularTexture = this.renderer!.handler!.createTexture_l(e);
+            // });
         }
 
         this._geoImageCreator.init();
@@ -856,12 +994,12 @@ export class Planet extends RenderNode {
 
         this._normalMapCreator.init();
 
-        this.renderer.events.on("draw", this._globalPreDraw, this, -100);
+        this.renderer!.events.on("draw", this._globalPreDraw, this, -100);
 
         // Loading first nodes for better viewing if you have started on a lower altitude.
         this._preRender();
 
-        this.renderer.events.on("postdraw", () => {
+        this.renderer!.events.on("postdraw", () => {
             this._checkRendercompleted();
         });
 
@@ -869,7 +1007,6 @@ export class Planet extends RenderNode {
 
         this._initialized = true;
 
-
         //
         // after init
         //
@@ -877,12 +1014,12 @@ export class Planet extends RenderNode {
             this.viewExtent(this._initialViewExtent);
         }
 
-        this.renderer.activeCamera = this.camera;
-        this.camera.bindRenderer(this.renderer);
+        this.renderer!.activeCamera = this.camera;
+        this.camera.bindRenderer(this.renderer!);
         this.camera.update();
     }
 
-    initLayers() {
+    public initLayers() {
         let temp = [...this._layers];
         for (let i = 0; i < temp.length; i++) {
             this.removeLayer(temp[i]);
@@ -890,62 +1027,59 @@ export class Planet extends RenderNode {
         }
     }
 
-    clearIndexesCache() {
+    protected _clearIndexesCache() {
         this._indexesCacheToRemoveCounter = 0;
-        let c = this._indexesCacheToRemove, gl = this.renderer.handler.gl;
+        let c = this._indexesCacheToRemove,
+            gl = this.renderer!.handler.gl!;
         for (let i = 0, len = c.length; i < len; i++) {
             let ci = c[i];
-            gl.deleteBuffer(ci.buffer);
+            gl.deleteBuffer(ci.buffer as WebGLBuffer);
             ci.buffer = null;
         }
     }
 
-    _preRender() {
+    protected _preRender() {
         this.quadTreeStrategy.preRender();
-
         this._preLoad();
     }
 
-    _preLoad() {
+    protected _preLoad() {
         this._clearRenderedNodeList();
-
         this._skipPreRender = false;
-
         this.quadTreeStrategy.preLoad();
     }
 
     /**
-     * Creates default textures first for nirth pole and whole globe and second for south pole.
+     * Creates default textures first for the North Pole and whole globe and second for the South Pole.
      * @public
-     * @param{Object} param0 -
-     * @param{Object} param1 -
-     */
-    createDefaultTextures(param0, param1) {
-        this.renderer.handler.gl.deleteTexture(this.solidTextureOne);
-        this.renderer.handler.gl.deleteTexture(this.solidTextureTwo);
-        var that = this;
-        this.renderer.handler.createDefaultTexture(param0, function (t) {
-            that.solidTextureOne = t;
+     * @param{IDefaultTextureParams} param0 -
+     * @param{IDefaultTextureParams} param1 -
+     */
+    public createDefaultTextures(param0: IDefaultTextureParams, param1: IDefaultTextureParams) {
+        this.renderer!.handler.gl!.deleteTexture(this.solidTextureOne!);
+        this.renderer!.handler.gl!.deleteTexture(this.solidTextureTwo!);
+        this.renderer!.handler.createDefaultTexture(param0, (texture: WebGLTextureExt) => {
+            this.solidTextureOne = texture;
         });
-        this.renderer.handler.createDefaultTexture(param1, function (t) {
-            that.solidTextureTwo = t;
+        this.renderer!.handler.createDefaultTexture(param1, (texture: WebGLTextureExt) => {
+            this.solidTextureTwo = texture;
         });
     }
 
-    _getLayerAttributionHTML(layer) {
-        return `<div class="og-attribution__layer">${layer._attribution}</div>`;
+    protected _getLayerAttributionHTML(layer: Layer) {
+        return `<div class="og-attribution__layer">${layer.getAttribution()}</div>`;
     }
 
     /**
      * Updates attribution lists
      * @public
      */
-    updateAttributionsList() {
+    public updateAttributionsList() {
         let html = "";
         for (let i = 0, len = this._layers.length; i < len; i++) {
             let li = this._layers[i];
-            if (li._visibility) {
-                if (li._attribution.length) {
+            if (li.getVisibility()) {
+                if (li.getAttribution().length) {
                     html += this._getLayerAttributionHTML(li);
                 }
             }
@@ -953,15 +1087,11 @@ export class Planet extends RenderNode {
         this._applyAttribution(html)
     }
 
-    updateVisibleLayers() {
+    public updateVisibleLayers() {
         this._updateLayer = true;
     }
 
-    /**
-     * Updates visible layers.
-     * @public
-     */
-    _updateVisibleLayers() {
+    protected _updateVisibleLayers() {
         this.visibleTileLayers = [];
         this.visibleTileLayers.length = 0;
 
@@ -971,9 +1101,9 @@ export class Planet extends RenderNode {
         let html = "";
         for (let i = 0, len = this._layers.length; i < len; i++) {
             let li = this._layers[i];
-            if (li._visibility) {
-                if (li._isBaseLayer) {
-                    this.createDefaultTextures(li._defaultTextures[0], li._defaultTextures[1]);
+            if (li.getVisibility()) {
+                if (li.isBaseLayer()) {
+                    this.createDefaultTextures(li._defaultTextures[0]!, li._defaultTextures[1]!);
                     this.baseLayer = li;
                 }
 
@@ -985,7 +1115,7 @@ export class Planet extends RenderNode {
                     this.visibleVectorLayers.push(li);
                 }
 
-                if (li._attribution.length) {
+                if (li.getAttribution().length) {
                     html += this._getLayerAttributionHTML(li);
                 }
 
@@ -1007,18 +1137,16 @@ export class Planet extends RenderNode {
 
     /**
      * Apply to render list of layer attributions
-     * @private
+     * @protected
      */
-    _applyAttribution(html) {
-        if (this.renderer) {
+    protected _applyAttribution(html: string) {
+        if (this.renderer && this.renderer.div) {
             if (html.length) {
-                if (this.renderer.div.attributions.innerHTML !== html) {
-                    //this.renderer.div.attributions.style.display = "block";
-                    this.renderer.div.attributions.innerHTML = html;
+                if (this.renderer.div.attributions!.innerHTML !== html) {
+                    this.renderer.div.attributions!.innerHTML = html;
                 }
             } else {
-                //this.renderer.div.attributions.style.display = "none";
-                this.renderer.div.attributions.innerHTML = "";
+                this.renderer.div.attributions!.innerHTML = "";
             }
         }
     }
@@ -1027,35 +1155,35 @@ export class Planet extends RenderNode {
      * Sort visible layer - preparing for rendering.
      * @protected
      */
-    _sortLayers() {
-        this.visibleVectorLayers.sort((a, b) => (a._zIndex - b._zIndex) || (a._height - b._height));
+    protected _sortLayers() {
+
+        this.visibleVectorLayers.sort((a, b) => (a.getZIndex() - b.getZIndex()) || (a.getHeight() - b.getHeight()));
 
         this._visibleTileLayerSlices = [];
         this._visibleTileLayerSlices.length = 0;
 
         if (this.visibleTileLayers.length) {
-            this.visibleTileLayers.sort((a, b) => (a._height - b._height) || (a._zIndex - b._zIndex));
+            this.visibleTileLayers.sort((a, b) => (a.getHeight() - b.getHeight()) || (a.getZIndex() - b.getZIndex()));
 
-            var k = -1;
-            var currHeight = this.visibleTileLayers[0]._height;
+            let k = -1;
+            let currHeight = this.visibleTileLayers[0].getHeight();
             for (let i = 0, len = this.visibleTileLayers.length; i < len; i++) {
-                if (i % this.SLICE_SIZE === 0 || this.visibleTileLayers[i]._height !== currHeight) {
+                if (i % this.SLICE_SIZE === 0 || this.visibleTileLayers[i].getHeight() !== currHeight) {
                     k++;
                     this._visibleTileLayerSlices[k] = [];
-                    currHeight = this.visibleTileLayers[i]._height;
+                    currHeight = this.visibleTileLayers[i].getHeight();
                 }
                 this._visibleTileLayerSlices[k].push(this.visibleTileLayers[i]);
             }
         }
     }
 
-    _clearRenderedNodeList() {
-        // clearing all node list
+    protected _clearRenderedNodeList() {
         this._renderedNodes.length = 0;
         this._renderedNodes = [];
     }
 
-    _clearRenderNodesInFrustum() {
+    protected _clearRenderNodesInFrustum() {
         for (let i = 0, len = this._renderedNodesInFrustum.length; i < len; i++) {
             this._renderedNodesInFrustum[i].length = 0;
             this._renderedNodesInFrustum[i] = [];
@@ -1066,9 +1194,10 @@ export class Planet extends RenderNode {
      * Collects visible quad nodes.
      * @protected
      */
-    _collectRenderNodes() {
+    protected _collectRenderNodes() {
         let cam = this.camera;
         this._lodSize = math.lerp(cam.slope < 0.0 ? 0.0 : cam.slope, this._curLodSize, this._minLodSize);
+
         cam._insideSegment = null;
 
         // clear first
@@ -1097,7 +1226,7 @@ export class Planet extends RenderNode {
             this._renderedNodes = [];
 
             for (let i = 0, len = temp.length; i < len; i++) {
-                var ri = temp[i];
+                let ri = temp[i];
                 let ht = ri.segment.centerNormal.dot(cam._b);
                 if (ri.segment.tileZoom === this.maxCurrZoom || ht < HORIZON_TANGENT) {
                     this._renderedNodes.push(ri);
@@ -1120,12 +1249,12 @@ export class Planet extends RenderNode {
         }
     }
 
-    _globalPreDraw() {
+    protected _globalPreDraw() {
         let cam = this.camera;
 
         // Might be it's better to replace it in setTerrain,
         // but we have to be sure that setTerrain exists with renderer insttance
-        this.renderer.__useDistanceFramebuffer__ = !this.terrain.isEmpty;
+        this.renderer!.__useDistanceFramebuffer__ = !this.terrain!.isEmpty;
 
         this._distBeforeMemClear += this._prevCamEye.distance(cam.eye);
         this._prevCamEye.copy(cam.eye);
@@ -1133,12 +1262,12 @@ export class Planet extends RenderNode {
 
         // free memory
         if (this._createdNodesCount > MAX_NODES && this._distBeforeMemClear > 1000.0) {
-            this.terrain.clearCache();
+            this.terrain!.clearCache();
             this.memClear();
         }
 
         if (this._indexesCacheToRemoveCounter > 600) {
-            this.clearIndexesCache();
+            this._clearIndexesCache();
         }
     }
 
@@ -1146,7 +1275,7 @@ export class Planet extends RenderNode {
      * Render node callback.
      * @public
      */
-    preFrame() {
+    public override preFrame() {
 
         if (this._updateLayer) {
             this._updateLayer = false;
@@ -1159,6 +1288,7 @@ export class Planet extends RenderNode {
             if (this._skipPreRender && this._collectRenderNodesIsActive) {
                 this._collectRenderNodes();
             }
+
             this._skipPreRender = true;
 
             this.transformLights();
@@ -1169,14 +1299,14 @@ export class Planet extends RenderNode {
             // Creating geoImages textures.
             this._geoImageCreator.frame();
 
-            // Vector tiles rasteriazation
+            // Vector tiles rasterization
             this._vectorTileCreator.frame();
 
             this.camera.checkTerrainCollision();
             this.camera.update();
 
             // Here is the planet node dispatches a draw event before
-            // rendering begins and we have got render nodes.
+            // rendering begins, and we have got render nodes.
             this.events.dispatch(this.events.draw, this);
 
             // Collect entity collections from vector layers
@@ -1189,12 +1319,13 @@ export class Planet extends RenderNode {
     /**
      * Render node callback.
      * @public
+     * @override
      */
-    frame() {
+    public override frame() {
         this._renderScreenNodesPASS();
     }
 
-    _checkRendercompleted() {
+    protected _checkRendercompleted() {
         if (this._renderCompleted) {
             if (!this._renderCompletedActivated) {
                 this._renderCompletedActivated = true;
@@ -1217,23 +1348,23 @@ export class Planet extends RenderNode {
         this._terrainCompleted = true;
     }
 
-    lockQuadTree() {
+    public lockQuadTree() {
         this._collectRenderNodesIsActive = false;
         this.camera.setTerrainCollisionActivity(false);
     }
 
-    unlockQuadTree() {
+    public unlockQuadTree() {
         this._collectRenderNodesIsActive = true;
         this.camera.setTerrainCollisionActivity(true);
     }
 
-    _renderScreenNodesPASSNoAtmos() {
+    protected _renderScreenNodesPASSNoAtmos() {
 
         let sh, shu;
-        let renderer = this.renderer;
+        let renderer = this.renderer!;
         let h = renderer.handler;
-        let gl = h.gl;
-        let cam = renderer.activeCamera;
+        let gl = h.gl!;
+        let cam = (renderer.activeCamera as PlanetCamera)!;
         let firstPass = cam.isFirstPass;
         let frustumIndex = cam.currentFrustumIndex;
 
@@ -1266,11 +1397,11 @@ export class Planet extends RenderNode {
             // Night and specular
             //
             gl.activeTexture(gl.TEXTURE0 + this.SLICE_SIZE);
-            gl.bindTexture(gl.TEXTURE_2D, this._nightTexture || this.transparentTexture);
+            gl.bindTexture(gl.TEXTURE_2D, this._nightTexture as WebGLTextureExt || this.transparentTexture as WebGLTextureExt);
             gl.uniform1i(shu.nightTexture, this.SLICE_SIZE);
 
             gl.activeTexture(gl.TEXTURE0 + this.SLICE_SIZE + 1);
-            gl.bindTexture(gl.TEXTURE_2D, this._specularTexture || this.transparentTexture);
+            gl.bindTexture(gl.TEXTURE_2D, this._specularTexture as WebGLTextureExt || this.transparentTexture as WebGLTexture);
             gl.uniform1i(shu.specularTexture, this.SLICE_SIZE + 1);
 
             gl.uniform1f(shu.camHeight, cam.getHeight());
@@ -1302,8 +1433,8 @@ export class Planet extends RenderNode {
             }
         }
 
-        let isEq = this.terrain.equalizeVertices;
-        var i = rn.length;
+        let isEq = this.terrain!.equalizeVertices;
+        let i = rn.length;
         while (i--) {
             let s = rn[i].segment;
             isEq && s.equalize();
@@ -1332,16 +1463,13 @@ export class Planet extends RenderNode {
         gl.disable(gl.POLYGON_OFFSET_FILL);
     }
 
-    /**
-     * @protected
-     */
-    _renderScreenNodesPASSAtmos() {
+    protected _renderScreenNodesPASSAtmos() {
 
         let sh, shu;
-        let renderer = this.renderer;
+        let renderer = this.renderer!;
         let h = renderer.handler;
-        let gl = h.gl;
-        let cam = renderer.activeCamera;
+        let gl = h.gl!;
+        let cam = (renderer.activeCamera as PlanetCamera)!;
         let firstPass = cam.isFirstPass;
         let frustumIndex = cam.currentFrustumIndex;
 
@@ -1376,23 +1504,22 @@ export class Planet extends RenderNode {
             // Night and specular
             //
             gl.activeTexture(gl.TEXTURE0 + this.SLICE_SIZE);
-            gl.bindTexture(gl.TEXTURE_2D, this._nightTexture || this.transparentTexture);
+            gl.bindTexture(gl.TEXTURE_2D, this._nightTexture as WebGLTexture || this.transparentTexture as WebGLTexture);
             gl.uniform1i(shu.nightTexture, this.SLICE_SIZE);
 
             gl.activeTexture(gl.TEXTURE0 + this.SLICE_SIZE + 1);
-            gl.bindTexture(gl.TEXTURE_2D, this._specularTexture || this.transparentTexture);
+            gl.bindTexture(gl.TEXTURE_2D, this._specularTexture as WebGLTexture || this.transparentTexture as WebGLTexture);
             gl.uniform1i(shu.specularTexture, this.SLICE_SIZE + 1);
 
-
             //
             // atmos precomputed textures
             //
             gl.activeTexture(gl.TEXTURE0 + this.SLICE_SIZE + 4);
-            gl.bindTexture(gl.TEXTURE_2D, this.renderer.controls.Atmosphere._transmittanceBuffer.textures[0]);
+            gl.bindTexture(gl.TEXTURE_2D, (renderer.controls.Atmosphere as Atmosphere)._transmittanceBuffer!.textures[0]);
             gl.uniform1i(shu.transmittanceTexture, this.SLICE_SIZE + 4);
 
             gl.activeTexture(gl.TEXTURE0 + this.SLICE_SIZE + 5);
-            gl.bindTexture(gl.TEXTURE_2D, this.renderer.controls.Atmosphere._scatteringBuffer.textures[0]);
+            gl.bindTexture(gl.TEXTURE_2D, (renderer.controls.Atmosphere as Atmosphere)._scatteringBuffer!.textures[0]);
             gl.uniform1i(shu.scatteringTexture, this.SLICE_SIZE + 5);
 
             gl.uniform1f(shu.camHeight, cam.getHeight());
@@ -1424,8 +1551,8 @@ export class Planet extends RenderNode {
             }
         }
 
-        let isEq = this.terrain.equalizeVertices;
-        var i = rn.length;
+        let isEq = this.terrain!.equalizeVertices;
+        let i = rn.length;
         while (i--) {
             let s = rn[i].segment;
             isEq && s.equalize();
@@ -1452,24 +1579,21 @@ export class Planet extends RenderNode {
         gl.disable(gl.POLYGON_OFFSET_FILL);
     }
 
-    /**
-     * @protected
-     */
-    _renderDistanceFramebufferPASS() {
-        if (!this.terrain.isEmpty) {
+    protected _renderDistanceFramebufferPASS() {
+        if (!this.terrain!.isEmpty) {
 
             let sh;
-            let renderer = this.renderer;
+            let renderer = this.renderer!;
             let h = renderer.handler;
-            let gl = h.gl;
-            let cam = renderer.activeCamera;
+            let gl = h.gl!;
+            let cam = (renderer.activeCamera as PlanetCamera)!;
 
             h.programs.drawnode_heightPicking.activate();
             sh = h.programs.drawnode_heightPicking._program;
             let shu = sh.uniforms;
 
-            gl.uniformMatrix4fv(shu.viewMatrix, false, renderer.activeCamera.getViewMatrix());
-            gl.uniformMatrix4fv(shu.projectionMatrix, false, renderer.activeCamera.getProjectionMatrix());
+            gl.uniformMatrix4fv(shu.viewMatrix, false, cam.getViewMatrix());
+            gl.uniformMatrix4fv(shu.projectionMatrix, false, cam.getProjectionMatrix());
 
             gl.uniform3fv(shu.eyePositionHigh, cam.eyeHigh);
             gl.uniform3fv(shu.eyePositionLow, cam.eyeLow);
@@ -1485,18 +1609,15 @@ export class Planet extends RenderNode {
         }
     }
 
-    /**
-     * @protected
-     */
-    _renderColorPickingFramebufferPASS() {
+    protected _renderColorPickingFramebufferPASS() {
         let sh;
-        let renderer = this.renderer;
+        let renderer = this.renderer!;
         let h = renderer.handler;
-        let gl = h.gl;
+        let gl = h.gl!;
         h.programs.drawnode_colorPicking.activate();
         sh = h.programs.drawnode_colorPicking._program;
         let shu = sh.uniforms;
-        let cam = renderer.activeCamera;
+        let cam = renderer.activeCamera!;
 
         // Special blend
         // gl.enable(gl.BLEND);
@@ -1531,18 +1652,15 @@ export class Planet extends RenderNode {
         gl.disable(gl.POLYGON_OFFSET_FILL);
     }
 
-    /**
-     * @protected
-     */
-    _renderDepthFramebufferPASS() {
+    protected _renderDepthFramebufferPASS() {
         let sh;
-        let renderer = this.renderer;
+        let renderer = this.renderer!;
         let h = renderer.handler;
-        let gl = h.gl;
+        let gl = h.gl!;
         h.programs.drawnode_depth.activate();
         sh = h.programs.drawnode_depth._program;
         let shu = sh.uniforms;
-        let cam = renderer.activeCamera;
+        let cam = renderer.activeCamera!;
 
         gl.disable(gl.BLEND);
         gl.disable(gl.POLYGON_OFFSET_FILL);
@@ -1567,13 +1685,13 @@ export class Planet extends RenderNode {
         gl.enable(gl.BLEND);
     }
 
-    _collectVectorLayerCollections() {
+    protected _collectVectorLayerCollections() {
         this._frustumEntityCollections.length = 0;
         this._frustumEntityCollections = [];
 
         let i = this.visibleVectorLayers.length;
         while (i--) {
-            let vi = this.visibleVectorLayers[i];
+            let vi = this.visibleVectorLayers[i] as Vector;
 
             if (vi._fading && vi._refreshFadingOpacity()) {
                 this.visibleVectorLayers.splice(i, 1);
@@ -1584,11 +1702,7 @@ export class Planet extends RenderNode {
         }
     }
 
-    /**
-     * Vector layers picking pass.
-     * @protected
-     */
-    _frustumEntityCollectionPickingCallback() {
+    protected _frustumEntityCollectionPickingCallback() {
         this.drawPickingEntityCollections(this._frustumEntityCollections);
     }
 
@@ -1596,7 +1710,7 @@ export class Planet extends RenderNode {
      * Starts clear memory thread.
      * @public
      */
-    memClear() {
+    public memClear() {
         this._distBeforeMemClear = 0;
 
         this.camera._insideSegment = null;
@@ -1606,7 +1720,7 @@ export class Planet extends RenderNode {
         this._normalMapCreator.lock(this._memKey);
 
         this._normalMapCreator.clear();
-        this.terrain.abortLoading();
+        this.terrain!.abortLoading();
         this._tileLoader.abortAll();
 
         this.quadTreeStrategy.clear();
@@ -1619,141 +1733,130 @@ export class Planet extends RenderNode {
 
     /**
      * Returns ray vector hit ellipsoid coordinates.
-     * If the ray doesn't hit ellipsoit returns null.
+     * If the ray doesn't hit ellipsoid it returns 'undefined'.
      * @public
-     * @param {Ray} ray - Ray 3d.
-     * @returns {Vec3} -
+     * @param {Ray} ray - Ray.
+     * @returns {Vec3 | undefined} -
      */
-    getRayIntersectionEllipsoid(ray) {
+    public getRayIntersectionEllipsoid(ray: Ray): Vec3 | undefined {
         return this.ellipsoid.hitRay(ray.origin, ray.direction);
     }
 
     /**
-     * Returns 2d screen coordanates projection point to the planet ellipsoid 3d coordinates.
+     * Project screen coordinates to the planet ellipsoid.
      * @public
-     * @param {math.Pixel} px - 2D sreen coordinates.
-     * @returns {Vec3} -
+     * @param {Vec2 | IBaseInputState } px - Screen coordinates.
+     * @returns {Vec3 | undefined} - Cartesian coordinates.
      */
-    getCartesianFromPixelEllipsoid(px) {
-        var cam = this.renderer.activeCamera;
+    public getCartesianFromPixelEllipsoid(px: Vec2 | IBaseInputState): Vec3 | undefined {
+        let cam = this.renderer!.activeCamera!;
         return this.ellipsoid.hitRay(cam.eye, cam.unproject(px.x, px.y));
     }
 
     /**
-     * Returns 2d screen coordanates projection point to the planet ellipsoid geographical coordinates.
+     * Project screen coordinates to the planet ellipsoid.
      * @public
-     * @param {math.Pixel} px - 2D screen coordinates.
-     * @returns {LonLat} -
+     * @param {Vec2 | IBaseInputState} px - Screen coordinates.
+     * @returns {LonLat | undefined} - Geodetic coordinates.
      */
-    getLonLatFromPixelEllipsoid(px) {
-        var coords = this.getCartesianFromPixelEllipsoid(px);
+    public getLonLatFromPixelEllipsoid(px: Vec2): LonLat | undefined {
+        let coords = this.getCartesianFromPixelEllipsoid(px);
         if (coords) {
             return this.ellipsoid.cartesianToLonLat(coords);
         }
-        return null;
     }
 
     /**
-     * Returns 3d cartesian coordinates on the relief planet by mouse cursor
-     * position or null if mouse cursor is outside the planet.
+     * Returns mouse position cartesian coordinates on the current terrain.
      * @public
-     * @returns {Vec3} -
+     * @returns {Vec3 | undefined} -
      */
-    getCartesianFromMouseTerrain() {
-        var ms = this.renderer.events.mouseState;
-        var distance = this.getDistanceFromPixel(ms);
+    public getCartesianFromMouseTerrain(): Vec3 | undefined {
+        let ms = this.renderer!.events.mouseState;
+        let distance = this.getDistanceFromPixel(ms);
         if (distance) {
-            return ms.direction.scaleTo(distance).addA(this.renderer.activeCamera.eye);
+            return ms.direction.scaleTo(distance).addA(this.renderer!.activeCamera!.eye);
         }
-        return null;
     }
 
     /**
-     * Returns 3d cartesian coordinates on the relief planet by 2d screen coordinates.
+     * 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 {Boolean} [force=false] - Force framebuffer rendering.
-     * @returns {Vec3 | null} -
+     * @returns {Vec3 | undefined} -
      */
-    getCartesianFromPixelTerrain(px) {
-        var distance = this.getDistanceFromPixel(px);
+    public getCartesianFromPixelTerrain(px: Vec2 | IBaseInputState): Vec3 | undefined {
+        let distance = this.getDistanceFromPixel(px);
         if (distance) {
-            var direction = px.direction || this.renderer.activeCamera.unproject(px.x, px.y);
-            return direction.scaleTo(distance).addA(this.renderer.activeCamera.eye);
+            let direction = (px as IBaseInputState).direction || this.renderer!.activeCamera!.unproject(px.x, px.y);
+            return direction.scaleTo(distance).addA(this.renderer!.activeCamera!.eye);
         }
-        return null;
     }
 
     /**
-     * Returns geographical coordinates on the relief planet by 2d screen coordinates.
+     * Returns geodetic coordinates on the current terrain planet by its screen coordinates.
      * position or null if input coordinates is outside the planet.
      * @public
-     * @param {Vec2} px - Pixel screen 2d coordinates.
-     * @param {Boolean} [force=false] - Force framebuffer rendering.
-     * @returns {LonLat} -
+     * @param {Vec2 | IBaseInputState} px - Pixel screen 2d coordinates.
+     * @returns {LonLat | undefined} -
      */
-    getLonLatFromPixelTerrain(px) {
-        var coords = this.getCartesianFromPixelTerrain(px);
+    public getLonLatFromPixelTerrain(px: Vec2 | IBaseInputState): LonLat | undefined {
+        let coords = this.getCartesianFromPixelTerrain(px);
         if (coords) {
             return this.ellipsoid.cartesianToLonLat(coords);
         }
-        return null;
     }
 
     /**
-     * Returns projected 2d screen coordinates by 3d cartesian coordinates.
+     * Project cartesian coordinates to screen space.
      * @public
      * @param {Vec3} coords - Cartesian coordinates.
-     * @returns {Vec2} -
+     * @returns {Vec2} - Screen coordinates.
      */
-    getPixelFromCartesian(coords) {
-        return this.renderer.activeCamera.project(coords);
+    public getPixelFromCartesian(coords: Vec3): Vec2 {
+        return this.renderer!.activeCamera!.project(coords);
     }
 
     /**
-     * Returns projected 2d screen coordinates by geographical coordinates.
+     * Project geodetic coordinates to screen space.
      * @public
-     * @param {LonLat} lonlat - Geographical coordinates.
-     * @returns {Vec2} -
+     * @param {LonLat} lonlat - Geodetic coordinates.
+     * @returns {Vec2 | undefined} - Screen coordinates.
      */
-    getPixelFromLonLat(lonlat) {
-        var coords = this.ellipsoid.lonLatToCartesian(lonlat);
+    public getPixelFromLonLat(lonlat: LonLat): Vec2 | undefined {
+        let coords = this.ellipsoid.lonLatToCartesian(lonlat);
         if (coords) {
-            return this.renderer.activeCamera.project(coords);
+            return this.renderer!.activeCamera!.project(coords);
         }
-        return null;
     }
 
     /**
-     * Returns distance from active camera to the the planet ellipsoid
-     * coordinates unprojected by 2d screen coordinates, or null if screen coordinates outside the planet.
+     * Returns distance from an active (screen) camera to the planet ellipsoid.
      * @public
      * @param {Vec2} px - Screen coordinates.
      * @returns {number} -
      */
-    getDistanceFromPixelEllipsoid(px) {
-        var coords = this.getCartesianFromPixelEllipsoid(px);
-        return coords ? coords.distance(this.renderer.activeCamera.eye) : null;
+    public getDistanceFromPixelEllipsoid(px: Vec2 | IBaseInputState): number | undefined {
+        let coords = this.getCartesianFromPixelEllipsoid(px);
+        if (coords) {
+            return coords.distance(this.renderer!.activeCamera!.eye);
+        }
     }
 
     /**
-     * Returns distance from active camera to the the relief planet coordinates unprojected
-     * by 2d screen coordinates, or null if screen coordinates outside the planet.
-     * If screen coordinates inside the planet but relief is not exists in the
-     * point than function returns distance to the planet ellipsoid.
+     * Returns distance from active (screen) camera to the planet terrain by screen coordinates.
      * @public
-     * @param {Vec2} px - Screen coordinates.
-     * @param {Boolean} [force=false] - Force framebuffer rendering.
-     * @returns {number} -
+     * @param {Vec2 | IBaseInputState} px - Screen coordinates.
+     * @returns {number | undefined} -
      */
-    getDistanceFromPixel(px) {
-        if (this.terrain.isEmpty) {
+    public getDistanceFromPixel(px: Vec2 | IBaseInputState): number {
+        if (this.terrain!.isEmpty) {
             return this.getDistanceFromPixelEllipsoid(px) || 0;
         } else {
 
-            let r = this.renderer;
-            let cnv = this.renderer.handler.canvas;
+            let r = this.renderer!;
+            let cnv = r.handler!.canvas!;
 
             let spx = px.x / cnv.width;
             let spy = (cnv.height - px.y) / cnv.height;
@@ -1769,17 +1872,17 @@ export class Planet extends RenderNode {
             if (!(_tempPickingPix_[0] || _tempPickingPix_[1] || _tempPickingPix_[2])) {
                 dist = this.getDistanceFromPixelEllipsoid(px) || 0;
             } else if (dist < DEPTH_DISTANCE) {
-                r.screenDepthFramebuffer.activate();
+                r.screenDepthFramebuffer!.activate();
 
                 //if (r.screenDepthFramebuffer.isComplete()) {
-                r.screenDepthFramebuffer.readPixels(_tempDepthColor_, spx, spy);
+                r.screenDepthFramebuffer!.readPixels(_tempDepthColor_, spx, spy);
                 let screenPos = new Vec4(spx * 2.0 - 1.0, spy * 2.0 - 1.0, (_tempDepthColor_[0] / 255.0) * 2.0 - 1.0, 1.0 * 2.0 - 1.0);
-                let viewPosition = this.camera.frustums[0]._inverseProjectionMatrix.mulVec4(screenPos);
-                let dir = px.direction || this.renderer.activeCamera.unproject(px.x, px.y);
-                dist = -(viewPosition.z / viewPosition.w) / dir.dot(this.renderer.activeCamera.getForward());
+                let viewPosition = this.camera.frustums[0].inverseProjectionMatrix.mulVec4(screenPos);
+                let dir = (px as IBaseInputState).direction || r.activeCamera!.unproject(px.x, px.y);
+                dist = -(viewPosition.z / viewPosition.w) / dir.dot(r.activeCamera!.getForward());
                 //}
 
-                r.screenDepthFramebuffer.deactivate();
+                r.screenDepthFramebuffer!.deactivate();
             }
             return dist;
         }
@@ -1790,7 +1893,7 @@ export class Planet extends RenderNode {
      * @public
      * @param {Extent} extent - Geographical extent.
      */
-    viewExtent(extent) {
+    public viewExtent(extent: Extent) {
         if (this.camera) {
             this.camera.viewExtent(extent);
         } else {
@@ -1799,96 +1902,120 @@ export class Planet extends RenderNode {
     }
 
     /**
-     * Sets camera to the planet geographical extent.
+     * Fits camera position for the view extent.
      * @public
      * @param {Array.<number>} extentArr - Geographical extent array, (exactly 4 entries)
      * where index 0 - southwest longitude, 1 - latitude southwest, 2 - longitude northeast, 3 - latitude northeast.
      */
-    viewExtentArr(extentArr) {
+    public viewExtentArr(extentArr: NumberArray4) {
         this.viewExtent(new Extent(new LonLat(extentArr[0], extentArr[1]), new LonLat(extentArr[2], extentArr[3])));
     }
 
     /**
-     * Gets current viewing geographical extent.
+     * Gets current camera view extent.
      * @public
      * @returns {Extent} -
      */
-    getViewExtent() {
+    public getViewExtent(): Extent {
         return this._viewExtent;
     }
 
     /**
      * Sets camera to the planet geographical position.
      * @public
-     * @param {LonLat} lonlat - New geographical position.
-     * @param {Vec3} [up] - Camera UP vector.
+     * @param {LonLat} lonlat - Camera position.
+     * @param {LonLat} [lookLonLat] - Viewpoint.
+     * @param {Vec3} [up] - Camera up vector.
      */
-    viewLonLat(lonlat, up) {
-        this.renderer.activeCamera.setLonLat(lonlat, up);
+    public viewLonLat(lonlat: LonLat, lookLonLat?: LonLat, up?: Vec3) {
+        this.camera.setLonLat(lonlat, lookLonLat, up);
     }
 
     /**
-     * Fly camera to the planet geographical extent.
+     * Fly active camera to the view extent.
      * @public
      * @param {Extent} extent - Geographical extent.
      * @param {Number} [height] - Height on the end of the flight route.
      * @param {Vec3} [up] - Camera UP vector on the end of a flying.
      * @param {Number} [ampl] - Altitude amplitude factor.
-     * @param {cameraCallback} [startCallback] - Callback that calls after flying when flying is finished.
-     * @param {cameraCallback} [completeCallback] - Callback that calls befor the flying begins.
+     * @param {Function} [startCallback] - Callback that calls before the flying begins.
+     * @param {Function} [completeCallback] - Callback that calls after flying when flying is finished.
      */
-    flyExtent(extent, height, up, ampl, completeCallback, startCallback) {
+    public flyExtent(
+        extent: Extent,
+        height?: number,
+        up?: Vec3,
+        ampl?: number,
+        completeCallback?: Function,
+        startCallback?: Function
+    ) {
         this.camera.flyExtent(extent, height, up, ampl, completeCallback, startCallback);
     }
 
     /**
-     * Fly camera to the new point.
+     * Fly camera to the point.
      * @public
-     * @param {Vec3} cartesian - Fly coordinates.
+     * @param {Vec3} cartesian - Point coordinates.
      * @param {Vec3} [look] - Camera "look at" point.
      * @param {Vec3} [up] - Camera UP vector on the end of a flying.
      * @param {Number} [ampl] - Altitude amplitude factor.
-     * @param [completeCallback]
-     * @param [startCallback]
-     * @param [frameCallback]
+     * @param {Function} [completeCallback] - Call the function in the end of flight
+     * @param {Function} [startCallback] - Call the function in the beginning
+     * @param {Function} [frameCallback] - Each frame callback
      */
-    flyCartesian(cartesian, look, up, ampl, completeCallback, startCallback, frameCallback) {
+    public flyCartesian(
+        cartesian: Vec3,
+        look?: Vec3 | null,
+        up?: Vec3 | null,
+        ampl?: number,
+        completeCallback?: Function | null,
+        startCallback?: Function | null,
+        frameCallback?: Function | null
+    ) {
         this.camera.flyCartesian(cartesian, look, up, ampl, completeCallback, startCallback, frameCallback);
     }
 
     /**
-     * Fly camera to the new geographical position.
+     * Fly camera to the geodetic position.
      * @public
      * @param {LonLat} lonlat - Fly geographical coordinates.
-     * @param {Vec3} [look] - Camera "look at" point on the end of a flying.
+     * @param {Vec3 | LonLat} [look] - Camera viewpoint in the end of the flight.
      * @param {Vec3} [up] - Camera UP vector on the end of a flying.
      * @param {Number} [ampl] - Altitude amplitude factor.
      * @param [completeCallback]
      * @param [startCallback]
      * @param [frameCallback]
      */
-    flyLonLat(lonlat, look, up, ampl, completeCallback, startCallback, frameCallback) {
+    public flyLonLat(
+        lonlat: LonLat,
+        look?: Vec3 | LonLat,
+        up?: Vec3,
+        ampl?: number,
+        completeCallback?: Function,
+        startCallback?: Function,
+        frameCallback?: Function
+    ) {
         this.camera.flyLonLat(lonlat, look, up, ampl, completeCallback, startCallback, frameCallback);
     }
 
     /**
-     * Breaks the flight.
+     * Stop current flight.
      * @public
      */
-    stopFlying() {
+    public stopFlying() {
         this.camera.stopFlying();
     }
 
-    updateBillboardsTexCoords() {
+    public override updateBillboardsTexCoords() {
         for (let i = 0; i < this.entityCollections.length; i++) {
             this.entityCollections[i].billboardHandler.refreshTexCoordsArr();
         }
 
-        let readyCollections = {};
+        let readyCollections: Record<number, boolean> = {};
         for (let i = 0; i < this._layers.length; i++) {
             let li = this._layers[i];
             if (li instanceof Vector) {
-                li.each(function (e) {
+                (li as Vector).each(function (e: Entity) {
                     if (e._entityCollection && !readyCollections[e._entityCollection.id]) {
                         e._entityCollection.billboardHandler.refreshTexCoordsArr();
                         readyCollections[e._entityCollection.id] = true;
@@ -1898,7 +2025,7 @@ export class Planet extends RenderNode {
         }
     }
 
-    getEntityTerrainPoint(entity, res) {
+    public getEntityTerrainPoint(entity: Entity, res: Vec3) {
         let n = this._renderedNodes, i = n.length;
         while (i--) {
             if (n[i].segment.isEntityInside(entity)) {
@@ -1907,25 +2034,82 @@ export class Planet extends RenderNode {
         }
     }
 
-    async getHeightDefault(lonLat) {
-        return new Promise((resolve, reject) => {
-            this.terrain.getHeightAsync(lonLat.clone(), (alt) => {
-                resolve(alt);
-            });
+    public async getHeightDefault(lonLat: LonLat): Promise<number> {
+        return new Promise<number>((resolve: Function) => {
+            if (this.terrain) {
+                this.terrain.getHeightAsync(lonLat.clone(), (alt: number) => {
+                    resolve(alt);
+                });
+            }
+            resolve(0);
         });
     }
 
-    async getHeightAboveELL(lonLat) {
-        return new Promise((resolve, reject) => {
-            this.terrain.getHeightAsync(lonLat.clone(), (alt) => {
-                resolve(alt + this.terrain.geoid.getHeightLonLat(lonLat));
-            });
+    public async getHeightAboveELL(lonLat: LonLat): Promise<number> {
+        return new Promise<number>((resolve: Function) => {
+            if (this.terrain) {
+                this.terrain.getHeightAsync(lonLat.clone(), (alt: number) => {
+                    resolve(alt + this.terrain!.geoid.getHeightLonLat(lonLat));
+                });
+            }
+            resolve(0);
         });
     }
 
-    onremove() {
+    public override onremove() {
         this.memClear();
         this.quadTreeStrategy.destroyBranches();
         this._renderedNodes = [];
     }
 }
+
+const PLANET_EVENTS: PlanetEventsList = [
+    /**
+     * Triggered before globe frame begins to render.
+     * @event og.scene.Planet#draw
+     */
+    "draw",
+
+    /**
+     * Triggered when layer has added to the planet.
+     * @event og.scene.Planet#layeradd
+     */
+    "layeradd",
+
+    /**
+     * Triggered when base layer changed.
+     * @event og.scene.Planet#baselayerchange
+     */
+    "baselayerchange",
+
+    /**
+     * Triggered when layer has removed from the planet.
+     * @event og.scene.Planet#layerremove
+     */
+    "layerremove",
+
+    /**
+     * Triggered when some layer visibility changed.
+     * @event og.scene.Planet#layervisibilitychange
+     */
+    "layervisibilitychange",
+
+    /**
+     * Triggered when all data is loaded
+     * @event og.scene.Planet#rendercompleted
+     */
+    "rendercompleted",
+
+    /**
+     * Triggered when all data is loaded
+     * @event og.scene.Planet#terraincompleted
+     */
+    "terraincompleted",
+
+    /**
+     * Triggered when layer data is laded
+     * @event og.scene.Planet#terraincompleted
+     */
+    "layerloadend"
+];
+