@openglobus/og 0.26.6 → 0.27.1

package/lib/quadTree/EPSG4326/EPSG4326QuadTreeStrategy.d.ts

@@ -1,6 +1,6 @@
-import { Planet } from "../../scene/Planet";
-import { QuadTreeStrategy } from "../QuadTreeStrategy";
+import { QuadTreeStrategy, QuadTreeStrategyParams } from "../QuadTreeStrategy";
+import { PlanetCamera } from "../../camera";
 export declare class EPSG4326QuadTreeStrategy extends QuadTreeStrategy {
-    constructor(planet: Planet);
-    init(): void;
+    constructor(params: QuadTreeStrategyParams);
+    init(camera: PlanetCamera): void;
 }

package/lib/quadTree/EntityCollectionsTreeStrategy.d.ts

@@ -3,6 +3,7 @@ import { EntityCollectionNode } from "./EntityCollectionNode";
 import { Entity } from "../entity/Entity";
 import { EntityCollection } from "../entity/EntityCollection";
 import { QueueArray } from "../QueueArray";
+import { QuadTreeStrategy } from "./QuadTreeStrategy";
 export declare class EntityCollectionsTreeStrategy {
     _layer: Vector;
     /**
@@ -14,7 +15,8 @@ export declare class EntityCollectionsTreeStrategy {
     protected _counter: number;
     protected _deferredEntitiesPendingQueue: QueueArray<EntityCollectionNode>;
     _renderingNodes: Record<number, boolean>;
-    constructor(layer: Vector, nodeCapacity: number);
+    quadTreeStrategy: QuadTreeStrategy;
+    constructor(quadTreeStrategy: QuadTreeStrategy, layer: Vector, nodeCapacity: number);
     insertEntity(entity: Entity, rightNow?: boolean): void;
     setPickingEnabled(pickingEnabled: boolean): void;
     dispose(): void;

package/lib/quadTree/Node.d.ts

@@ -1,22 +1,22 @@
 import { Extent } from "../Extent";
-import { Planet } from "../scene/Planet";
 import { Segment } from "../segment/Segment";
+import { QuadTreeStrategy } from "./QuadTreeStrategy";
 import { PlanetCamera } from "../camera/PlanetCamera";
 /**
  * Quad tree planet segment node.
  * @constructor
  * @param {Segment} segmentPrototype - Planet segment node constructor.
- * @param {Planet} planet - Planet scene instance.
+ * @param {QuadTreeStrategy} quadTreeStrategy - Quad tree strategy handler.
  * @param {number} partId - NorthEast, SouthWest etc.
  * @param {Node} parent - Parent of this node.
  * @param {number} id - Tree node identifier (id * 4 + 1);
  * @param {number} tileZoom - Deep index of the quad tree.
- * @param {Extent} extent - Planet segment extent.
+ * @param {Extent} extent - Segment extent.
  */
 declare class Node {
     __id: number;
     SegmentPrototype: typeof Segment;
-    planet: Planet;
+    quadTreeStrategy: QuadTreeStrategy;
     parentNode: Node | null;
     partId: number;
     nodeId: number;
@@ -32,7 +32,7 @@ declare class Node {
     _cameraInside: boolean;
     inFrustum: number;
     _fadingNodes: Node[];
-    constructor(SegmentPrototype: typeof Segment, planet: Planet, partId: number, parent: Node | null, tileZoom: number, extent: Extent);
+    constructor(SegmentPrototype: typeof Segment, quadTreeStrategy: QuadTreeStrategy, partId: number, parent: Node | null, tileZoom: number, extent: Extent);
     createChildNodes(): void;
     createBounds(): void;
     getState(): number | null;

package/lib/quadTree/QuadTreeStrategy.d.ts

@@ -4,11 +4,29 @@ import { Node } from "../quadTree/Node";
 import { Planet } from "../scene/Planet";
 import { Proj } from "../proj/Proj";
 import { LonLat } from "../LonLat";
+import { Segment } from "../segment/Segment";
+import { Extent } from "../Extent";
 import { EntityCollectionsTreeStrategy } from "./EntityCollectionsTreeStrategy";
+import { PlanetCamera } from "../camera";
+import { EventsHandler } from "../Events";
+export type QuadTreeStrategyEventsList = [
+    "rendercompleted",
+    "terraincompleted"
+];
+export interface QuadTreeStrategyParams {
+    planet: Planet;
+    name?: string;
+    proj?: Proj;
+    maxEqualZoomAltitude?: number;
+    minEqualZoomAltitude?: number;
+    minEqualZoomCameraSlope?: number;
+    transitionOpacityEnabled?: boolean;
+}
 export declare class QuadTreeStrategy {
+    events: EventsHandler<QuadTreeStrategyEventsList>;
     name: string;
     projection: Proj;
-    protected _planet: Planet;
+    readonly planet: Planet;
     /**
      * grid tree list.
      * @protected
@@ -21,16 +39,72 @@ export declare class QuadTreeStrategy {
      * @type {Node}
      */
     _visibleNodes: Record<number, Node>;
-    constructor(planet: Planet, name?: string, proj?: Proj);
-    createEntitiCollectionsTreeStrategy(layer: Vector, nodeCapacity: number): EntityCollectionsTreeStrategy;
+    /**
+     * Planet's segments collected for rendering frame.
+     * @public
+     * @type {Node}
+     */
+    _renderedNodes: Node[];
+    _renderedNodesInFrustum: Node[][];
+    _fadingNodes: Map<number, Node>;
+    _fadingNodesInFrustum: Node[][];
+    _fadingOpaqueSegments: Segment[];
+    /**
+     * Current visible minimal zoom index planet segment.
+     * @public
+     * @type {number}
+     */
+    minCurrZoom: number;
+    /**
+     * Current visible maximal zoom index planet segment.
+     * @public
+     * @type {number}
+     */
+    maxCurrZoom: number;
+    protected _transitionOpacityEnabled: boolean;
+    _viewExtent: Extent;
+    /**
+     * Level of details of visible segments.
+     * @protected
+     * @type {number}
+     */
+    protected _lodSize: number;
+    protected _curLodSize: number;
+    protected _minLodSize: number;
+    _maxLodSize: number;
+    maxEqualZoomAltitude: number;
+    minEqualZoomAltitude: number;
+    minEqualZoomCameraSlope: number;
+    _renderCompleted: boolean;
+    _renderCompletedActivated: boolean;
+    _terrainCompleted: boolean;
+    _terrainCompletedActivated: boolean;
+    protected _skipPreRender: boolean;
+    constructor(params: QuadTreeStrategyParams);
+    get lodSize(): number;
+    setLodSize(currentLodSize: number, minLodSize?: number, maxLodSize?: number): void;
+    createEntityCollectionsTreeStrategy(layer: Vector, nodeCapacity: number): EntityCollectionsTreeStrategy;
     destroyBranches(): void;
     clearLayerMaterial(layer: Layer): void;
-    get planet(): Planet;
-    init(): void;
+    get terrainReady(): boolean;
+    protected _checkRendercompleted(): void;
+    protected _initEvents(): void;
+    init(camera: PlanetCamera): void;
+    clearRenderedNodes(): void;
+    protected _clearRenderedNodeList(): void;
+    protected _clearRenderNodesInFrustum(): void;
+    protected _collectRenderedNodesMaxZoom(cam: PlanetCamera): void;
+    set transitionOpacityEnabled(isEnabled: boolean);
+    get transitionOpacityEnabled(): boolean;
+    /**
+     * Collects visible quad nodes.
+     * @protected
+     */
+    collectRenderNodes(cam: PlanetCamera): void;
     preRender(): void;
     preLoad(): void;
     protected _clearVisibleNodes(): void;
-    collectRenderNodes(): void;
+    protected _collectRenderNodes(camera: PlanetCamera): void;
     clear(): void;
     get quadTreeList(): Node[];
     getTileXY(lonLat: LonLat, zoom: number): [number, number, number, number];

package/lib/quadTree/earth/EarthEntityCollectionsTreeStrategy.d.ts

@@ -4,13 +4,14 @@ import { Vector } from "../../layer/Vector";
 import { Entity } from "../../entity/Entity";
 import { EntityCollection } from "../../entity/EntityCollection";
 import { EntityCollectionsTreeStrategy } from "../EntityCollectionsTreeStrategy";
+import { QuadTreeStrategy } from "../QuadTreeStrategy";
 export declare class EarthEntityCollectionsTreeStrategy extends EntityCollectionsTreeStrategy {
     protected _entityCollectionsTree: EntityCollectionNode;
     protected _entityCollectionsTreeNorth: EarthEntityCollectionNodeLonLat;
     protected _entityCollectionsTreeSouth: EarthEntityCollectionNodeLonLat;
     _renderingNodesNorth: Record<number, boolean>;
     _renderingNodesSouth: Record<number, boolean>;
-    constructor(layer: Vector, nodeCapacity: number);
+    constructor(quadTreeStrategy: QuadTreeStrategy, layer: Vector, nodeCapacity: number);
     insertEntity(entity: Entity, rightNow?: boolean): void;
     setPickingEnabled(pickingEnabled: boolean): void;
     dispose(): void;

package/lib/quadTree/earth/EarthQuadTreeStrategy.d.ts

@@ -1,9 +1,9 @@
 import { Node } from "../Node";
-import { Planet } from "../../scene/Planet";
-import { QuadTreeStrategy } from "../QuadTreeStrategy";
+import { QuadTreeStrategy, QuadTreeStrategyParams } from "../QuadTreeStrategy";
 import { LonLat } from "../../LonLat";
 import { Vector } from "../../layer/Vector";
 import { EarthEntityCollectionsTreeStrategy } from "./EarthEntityCollectionsTreeStrategy";
+import { PlanetCamera } from "../../camera";
 export declare class EarthQuadTreeStrategy extends QuadTreeStrategy {
     /**
      * Current visible north pole nodes tree nodes array.
@@ -17,11 +17,11 @@ export declare class EarthQuadTreeStrategy extends QuadTreeStrategy {
      * @type {Node}
      */
     _visibleNodesSouth: Record<number, Node>;
-    constructor(planet: Planet);
+    constructor(params: QuadTreeStrategyParams);
     collectVisibleNode(node: Node): void;
     protected _clearVisibleNodes(): void;
-    createEntitiCollectionsTreeStrategy(layer: Vector, nodeCapacity: number): EarthEntityCollectionsTreeStrategy;
-    init(): void;
+    createEntityCollectionsTreeStrategy(layer: Vector, nodeCapacity: number): EarthEntityCollectionsTreeStrategy;
+    init(camera: PlanetCamera): void;
     getTileXY(lonLat: LonLat, zoom: number): [number, number, number, number];
     getLonLatTileOffset(lonLat: LonLat, x: number, y: number, z: number, gridSize: number): [number, number];
 }

package/lib/quadTree/equi/EquiEntityCollectionsTreeStrategy.d.ts

@@ -3,12 +3,13 @@ import { Entity } from "../../entity/Entity";
 import { EntityCollection } from "../../entity/EntityCollection";
 import { EntityCollectionsTreeStrategy } from "../EntityCollectionsTreeStrategy";
 import { EquiEntityCollectionNodeLonLat } from "./EquiEntityCollectionNodeLonLat";
+import { QuadTreeStrategy } from "../QuadTreeStrategy";
 export declare class EquiEntityCollectionsTreeStrategy extends EntityCollectionsTreeStrategy {
     protected _entityCollectionsTreeWest: EquiEntityCollectionNodeLonLat;
     protected _entityCollectionsTreeEast: EquiEntityCollectionNodeLonLat;
     _renderingNodesWest: Record<number, boolean>;
     _renderingNodesEast: Record<number, boolean>;
-    constructor(layer: Vector, nodeCapacity: number);
+    constructor(quadTreeStrategy: QuadTreeStrategy, layer: Vector, nodeCapacity: number);
     insertEntity(entity: Entity, rightNow?: boolean): void;
     setPickingEnabled(pickingEnabled: boolean): void;
     dispose(): void;

package/lib/quadTree/equi/EquiQuadTreeStrategy.d.ts

@@ -1,19 +1,19 @@
 import { Node } from "../Node";
-import { Planet } from "../../scene/Planet";
-import { QuadTreeStrategy } from "../QuadTreeStrategy";
+import { QuadTreeStrategy, QuadTreeStrategyParams } from "../QuadTreeStrategy";
 import { LonLat } from "../../LonLat";
 import { Vector } from "../../layer/Vector";
 import { EntityCollectionsTreeStrategy } from "../EntityCollectionsTreeStrategy";
+import { PlanetCamera } from "../../camera";
 export declare class EquiQuadTreeStrategy extends QuadTreeStrategy {
-    private _westExtent;
-    private _eastExtent;
+    private readonly _westExtent;
+    private readonly _eastExtent;
     _visibleNodesWest: Record<number, Node>;
     _visibleNodesEast: Record<number, Node>;
-    constructor(planet: Planet);
-    init(): void;
+    constructor(params: QuadTreeStrategyParams);
+    init(camera: PlanetCamera): void;
     getTileXY(lonLat: LonLat, zoom: number): [number, number, number, number];
     getLonLatTileOffset(lonLat: LonLat, x: number, y: number, z: number, gridSize: number): [number, number];
-    createEntitiCollectionsTreeStrategy(layer: Vector, nodeCapacity: number): EntityCollectionsTreeStrategy;
+    createEntityCollectionsTreeStrategy(layer: Vector, nodeCapacity: number): EntityCollectionsTreeStrategy;
     collectVisibleNode(node: Node): void;
     protected _clearVisibleNodes(): void;
 }

package/lib/quadTree/wgs84/Wgs84QuadTreeStrategy.d.ts

@@ -1,6 +1,6 @@
-import { Planet } from "../../scene/Planet";
-import { QuadTreeStrategy } from "../QuadTreeStrategy";
+import { QuadTreeStrategy, QuadTreeStrategyParams } from "../QuadTreeStrategy";
+import { PlanetCamera } from "../../camera";
 export declare class Wgs84QuadTreeStrategy extends QuadTreeStrategy {
-    constructor(planet: Planet);
-    init(): void;
+    constructor(params: QuadTreeStrategyParams);
+    init(camera: PlanetCamera): void;
 }

package/lib/renderer/Renderer.d.ts

@@ -314,7 +314,7 @@ declare class Renderer {
      */
     protected _drawPickingBuffer(depthOrder: number): void;
     protected _drawDepthBuffer(depthOrder: number): void;
-    protected _readDepthBuffer(): void;
+    protected _readDepthBuffer(callback?: () => void): void;
     protected _readPickingBuffer_webgl1(): void;
     protected _readPickingBuffer_webgl2(): void;
     readPickingColor(x: number, y: number, outColor: NumberArray3 | Uint8Array): void;
@@ -333,6 +333,8 @@ declare class Renderer {
      * @returns {Vec3 | undefined} -
      */
     getCartesianFromPixel(px: Vec2 | IBaseInputState): Vec3 | undefined;
+    getDepthMinDistance(): number;
+    setOrthographicProjection(isOrtho: boolean): void;
     /**
      * Function starts renderer
      * @public

package/lib/renderer/RendererEvents.d.ts

@@ -11,6 +11,7 @@ import { Vec3 } from "../math/Vec3";
 export type RendererEventsHandler = RendererEvents & EventsHandler<RendererEventsType>;
 export declare function createRendererEvents(renderer: Renderer): RendererEvents;
 export type RendererEventsType = [
+    "projchanged",
     "changerelativecenter",
     "draw",
     "drawtransparent",

package/lib/scene/Planet.d.ts

@@ -89,6 +89,7 @@ type IndexBufferCacheData = {
  */
 export declare class Planet extends RenderNode {
     events: EventsHandler<PlanetEventsList>;
+    _createdNodesCount: number;
     /**
      * @public
      * @type {Ellipsoid}
@@ -156,9 +157,6 @@ export declare class Planet extends RenderNode {
      * @type {PlanetCamera}
      */
     camera: PlanetCamera;
-    maxEqualZoomAltitude: number;
-    minEqualZoomAltitude: number;
-    minEqualZoomCameraSlope: number;
     /**
      * Screen mouse pointer projected to planet cartesian position.
      * @public
@@ -168,31 +166,7 @@ export declare class Planet extends RenderNode {
     emptyTexture: WebGLTextureExt | null;
     transparentTexture: WebGLTextureExt | null;
     defaultTexture: WebGLTextureExt | null;
-    /**
-     * Current visible minimal zoom index planet segment.
-     * @public
-     * @type {number}
-     */
-    minCurrZoom: number;
-    /**
-     * Current visible maximal zoom index planet segment.
-     * @public
-     * @type {number}
-     */
-    maxCurrZoom: number;
-    _viewExtent: Extent;
     protected _initialViewExtent: Extent | null;
-    _createdNodesCount: number;
-    /**
-     * Planet's segments collected for rendering frame.
-     * @public
-     * @type {Node}
-     */
-    _renderedNodes: Node[];
-    _renderedNodesInFrustum: Node[][];
-    _fadingNodes: Map<number, Node>;
-    _fadingNodesInFrustum: Node[][];
-    protected _fadingOpaqueSegments: Segment[];
     /**
      * Layers activity lock.
      * @public
@@ -225,6 +199,7 @@ export declare class Planet extends RenderNode {
      * @type {Array.<Array.<number>>}
      */
     _textureCoordsBufferCache: WebGLBufferExt[];
+    quadTreeStrategyPrototype: typeof QuadTreeStrategy;
     quadTreeStrategy: QuadTreeStrategy;
     /**
      * Night glowing gl texture.
@@ -248,15 +223,6 @@ export declare class Planet extends RenderNode {
     SLICE_SIZE: number;
     SLICE_SIZE_4: number;
     SLICE_SIZE_3: number;
-    /**
-     * Level of details of visible segments.
-     * @protected
-     * @type {number}
-     */
-    protected _lodSize: number;
-    protected _curLodSize: number;
-    protected _minLodSize: number;
-    _maxLodSize: number;
     _pickingColorArr: Float32Array;
     _samplerArr: Int32Array;
     _pickingMaskArr: Int32Array;
@@ -285,10 +251,6 @@ export declare class Planet extends RenderNode {
     _distBeforeMemClear: number;
     protected _prevCamEye: Vec3;
     protected _initialized: boolean;
-    _renderCompleted: boolean;
-    _renderCompletedActivated: boolean;
-    _terrainCompleted: boolean;
-    _terrainCompletedActivated: boolean;
     protected _collectRenderNodesIsActive: boolean;
     /**
      * Night texture brightness coefficient
@@ -301,11 +263,9 @@ export declare class Planet extends RenderNode {
     protected _atmosphereMaxMinOpacity: Float32Array;
     solidTextureOne: WebGLTextureExt | null;
     solidTextureTwo: WebGLTextureExt | null;
-    protected _skipPreRender: boolean;
     protected _nightTextureSrc: string | null;
     protected _specularTextureSrc: string | null;
     transitionTime: number;
-    protected _transitionOpacityEnabled: boolean;
     protected _atmosphere: Atmosphere;
     private _minDistanceBeforeMemClear;
     private _maxNodes;
@@ -329,13 +289,6 @@ export declare class Planet extends RenderNode {
     set shininess(v: number);
     get normalMapCreator(): NormalMapCreator;
     get layers(): Layer[];
-    /**
-     * @todo: remove after tests
-     * Get the collection of layers associated with this planet.
-     * @return {Array.<Layer>} Layers array.
-     * @public
-     */
-    getLayers(): Layer[];
     get sun(): Sun | undefined;
     get sunPos(): Vec3;
     /**
@@ -343,8 +296,6 @@ export declare class Planet extends RenderNode {
      * @param {Control} control - Control.
      */
     addControl(control: Control): void;
-    get lodSize(): number;
-    setLodSize(currentLodSize: number, minLodSize?: number, maxLodSize?: number): void;
     /**
      * Add the given controls array to the renderer of the planet.
      * @param {Array.<Control>} cArr - Control array.
@@ -417,8 +368,6 @@ export declare class Planet extends RenderNode {
     init(): void;
     initLayers(): void;
     protected _clearIndexesCache(): void;
-    protected _preRender(): void;
-    protected _preLoad(): void;
     /**
      * Creates default textures first for the North Pole and whole globe and second for the South Pole.
      * @public
@@ -444,16 +393,6 @@ export declare class Planet extends RenderNode {
      * @protected
      */
     protected _sortLayers(): void;
-    protected _clearRenderedNodeList(): void;
-    protected _clearRenderNodesInFrustum(): void;
-    protected _collectRenderedNodesMaxZoom(cam: PlanetCamera): void;
-    set transitionOpacityEnabled(isEnabled: boolean);
-    get transitionOpacityEnabled(): boolean;
-    /**
-     * Collects visible quad nodes.
-     * @protected
-     */
-    protected _collectRenderNodes(cam: PlanetCamera): void;
     protected _renderScreenNodesPASSNoAtmos(): void;
     protected _renderScreenNodesPASSAtmos(): void;
     protected _renderScreenNodesWithHeightPASSNoAtmos(): void;
@@ -471,20 +410,20 @@ export declare class Planet extends RenderNode {
      * @override
      */
     frame(): void;
-    protected _checkRendercompleted(): void;
     lockQuadTree(): void;
     unlockQuadTree(): void;
     protected _setUniformsNoAtmos(cam: PlanetCamera): Program;
     protected _setUniformsAtmos(cam: PlanetCamera): Program;
-    protected _renderingFadingNodes: (nodes: Map<number, boolean>, sh: Program, currentNode: Node, sl: Layer[], sliceIndex: number, outTransparentSegments?: Segment[], outOpaqueSegments?: Segment[]) => void;
-    protected _renderingFadingNodesNoDepth: (nodes: Map<number, boolean>, sh: Program, currentNode: Node, sl: Layer[], sliceIndex: number, outOpaqueSegments?: Segment[]) => void;
+    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 static __refreshLayersFadingOpacity__(layersRef: Layer[], minCurrZoom: number, maxCurrZoom: number): void;
     /**
      * Drawing nodes
      */
-    protected _renderingScreenNodes(sh: Program, cam: PlanetCamera, renderedNodes: Node[]): void;
-    protected _renderingScreenNodesWithHeight(sh: Program, cam: PlanetCamera, renderedNodes: Node[]): void;
+    protected _renderingScreenNodes(quadTreeStrategy: QuadTreeStrategy, sh: Program, cam: PlanetCamera, renderedNodes: Node[]): void;
+    protected _renderingScreenNodesWithHeight(quadTreeStrategy: QuadTreeStrategy, sh: Program, cam: PlanetCamera, renderedNodes: Node[]): void;
     protected _renderColorPickingFramebufferPASS(): void;
-    protected _renderDepthFramebufferPASS(): void;
+    renderDepthFramebuffer(cam: PlanetCamera, quadTreeStrategy: QuadTreeStrategy): void;
     protected _collectVectorLayerCollections(): void;
     /**
      * Starts clear memory thread.

package/lib/segment/Segment.d.ts

@@ -18,6 +18,7 @@ import type { NumberArray6 } from "../bv/Sphere";
 import { Slice } from "./Slice";
 import { Vec3 } from "../math/Vec3";
 import type { IPlainSegmentWorkerData } from "../utils/PlainSegmentWorker";
+import { QuadTreeStrategy } from "../quadTree";
 export declare function getTileCellIndex(coordinate: number, tileSize: number, worldEdge: number): number;
 export declare function getTileCellExtent(x: number, y: number, z: number, worldExtent: Extent): Extent;
 export declare const TILEGROUP_COMMON = 0;
@@ -126,12 +127,12 @@ declare class Segment {
      */
     initialized: boolean;
     /**
-     * Normal map is allready made.
+     * Normal map is already made.
      * @type {boolean}
      */
     normalMapReady: boolean;
     /**
-     * Terrain is allready applied flag.
+     * Terrain is already applied flag.
      * @type {boolean}
      */
     terrainReady: boolean;
@@ -182,7 +183,8 @@ declare class Segment {
     normalMapTexturePtr: WebGLTextureExt | null;
     _transitionOpacity: number;
     _transitionTimestamp: number;
-    constructor(node: Node, planet: Planet, tileZoom: number, extent: Extent);
+    quadTreeStrategy: QuadTreeStrategy;
+    constructor(node: Node, quadTreeStrategy: QuadTreeStrategy, tileZoom: number, extent: Extent);
     checkZoom(): boolean;
     /**
      * Returns entity terrain point.
@@ -273,7 +275,6 @@ declare class Segment {
     protected _getLayerExtentOffset(layer: Layer): [number, number, number, number];
     initSlice(sliceIndex: number): Slice;
     screenRendering(sh: Program, layerSlice: Layer[], sliceIndex: number, defaultTexture?: WebGLTextureExt | null, isOverlay?: boolean, forcedOpacity?: number): void;
-    heightPickingRendering(sh: Program, layerSlice: Layer[]): void;
     increaseTransitionOpacity(): void;
     fadingTransitionOpacity(): void;
     colorPickingRendering(sh: Program, layerSlice: Layer[], sliceIndex: number, defaultTexture?: WebGLTextureExt | null, isOverlay?: boolean): void;

package/lib/segment/SegmentLonLat.d.ts

@@ -1,12 +1,12 @@
 import { Extent } from "../Extent";
 import { Layer } from "../layer/Layer";
 import { Node } from "../quadTree/Node";
-import { Planet } from "../scene/Planet";
 import { Segment } from "./Segment";
 import { LonLat } from "../LonLat";
 import { Entity } from "../entity/Entity";
 import { PlanetCamera } from "../camera/PlanetCamera";
 import type { WebGLTextureExt } from "../webgl/Handler";
+import { QuadTreeStrategy } from "../quadTree";
 export declare const POLE_PIECE_SIZE: number;
 /**
  * Planet segment Web Mercator tile class that stored and rendered with quad tree.
@@ -14,7 +14,7 @@ export declare const POLE_PIECE_SIZE: number;
  * @extends {Segment}
  */
 declare class SegmentLonLat extends Segment {
-    constructor(node: Node, planet: Planet, tileZoom: number, extent: Extent);
+    constructor(node: Node, quadTreeStrategy: QuadTreeStrategy, tileZoom: number, extent: Extent);
     _setExtentLonLat(): void;
     projectNative(coords: LonLat): LonLat;
     getInsideLonLat(obj: Entity | PlanetCamera): LonLat;

package/lib/segment/SegmentLonLatEqui.d.ts

@@ -1,11 +1,11 @@
 import { Extent } from "../Extent";
 import { Node } from "../quadTree/Node";
-import { Planet } from "../scene/Planet";
 import { SegmentLonLat } from "./SegmentLonLat";
 import type { WebGLTextureExt } from "../webgl/Handler";
+import { QuadTreeStrategy } from "../quadTree";
 export declare const POLE_PIECE_SIZE: number;
 export declare class SegmentLonLatEqui extends SegmentLonLat {
-    constructor(node: Node, planet: Planet, tileZoom: number, extent: Extent);
+    constructor(node: Node, quadTreeStrategy: QuadTreeStrategy, tileZoom: number, extent: Extent);
     protected _getMaxZoom(): number;
     protected _assignTileYIndexes(extent: Extent): void;
     protected _assignTileXIndexes(extent: Extent): void;

package/lib/terrain/GlobusTerrain.d.ts

@@ -27,8 +27,6 @@ type TileData = {
     extent: Extent | null;
 };
 /**
- * @deprecated
- * Use GlobusRgbTerrain
  * Class that loads segment elevation data, converts it to the array and passes it to the planet segment.
  * @class
  * @extends {GlobusTerrain}

package/lib/utils/Loader.d.ts

@@ -1,6 +1,7 @@
 import type { EventsHandler } from '../Events';
 import { Planet } from "../scene/Planet";
 import { Segment } from "../segment/Segment";
+import { QuadTreeStrategy } from "../quadTree";
 type LoaderEventsList = ["loadend", "layerloadend"];
 export interface IResponse {
     status: string;
@@ -14,7 +15,8 @@ interface Obj<T> {
     isIdle: boolean;
     isEqual: (obj: T) => boolean;
     events: EventsHandler<any>;
-    _planet: Planet | null;
+    _planet?: Planet | null;
+    quadTreeStrategy?: QuadTreeStrategy | null;
 }
 type QueryParams<T> = {
     sender?: T;

package/lib/webgl/Handler.d.ts

@@ -317,10 +317,10 @@ declare class Handler {
      * Adds shader program to the handler.
      * @public
      * @param {Program} program - Shader program.
-     * @param {boolean} [notActivate] - If it's true program will not compile.
+     * @param {boolean} [activate] - If false program will not compile.
      * @return {Program} -
      */
-    addProgram(program: Program, notActivate?: boolean): Program;
+    addProgram(program: Program, activate?: boolean): Program;
     /**
      * Removes shader program from handler.
      * @public

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@openglobus/og",
-  "version": "0.26.6",
+  "version": "0.27.1",
   "description": "[openglobus](https://www.openglobus.org/) is a javascript/typescript library designed to display interactive 3d maps and planets with map tiles, imagery and vector data, markers, and 3D objects. It uses the WebGL technology, open source, and completely free.",
   "main": "lib/og.es.js",
   "types": "lib/index.d.ts",