@openglobus/og 0.22.2 → 0.23.0

package/lib/js/renderer/RendererEvents.d.ts

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

package/lib/js/renderer/RendererEvents.js

@@ -95,7 +95,7 @@ class RendererEvents extends Events {
             pickingObject: null,
             renderer: renderer
         };
-        this._isMouseInside = false;
+        this._isMouseInside = true;
         this._entityPickingEventsActive = true;
         this._dblTchCoords = new Vec2();
         this._oneTouchStart = false;
@@ -703,6 +703,7 @@ class RendererEvents extends Events {
     }
 }
 const RENDERER_EVENTS = [
+    "changerelativecenter",
     /**
      * Triggered before scene frame is rendered(before render nodes).
      * @event og.RendererEvents#draw

package/lib/js/scene/Planet.d.ts

@@ -20,8 +20,10 @@ import { Quat } from "../math/Quat";
 import { QuadTreeStrategy } from "../quadTree/QuadTreeStrategy";
 import { Ray } from "../math/Ray";
 import { RenderNode } from "./RenderNode";
+import { Sun } from "../control/Sun";
 import { TerrainWorker } from "../utils/TerrainWorker";
 import { Vec2, Vec3, NumberArray2, NumberArray3, NumberArray4 } from "../math/index";
+import { Vector } from "../layer/Vector";
 import { VectorTileCreator } from "../utils/VectorTileCreator";
 import { WebGLBufferExt, WebGLTextureExt, IDefaultTextureParams } from "../webgl/Handler";
 import { Program } from "../webgl/Program";
@@ -122,14 +124,15 @@ export declare class Planet extends RenderNode {
      * @protected
      * @type {Array.<Layer>}
      */
-    protected visibleVectorLayers: Layer[];
+    protected visibleVectorLayers: Vector[];
+    protected _visibleVectorLayersByDepthOrder: Vector[][];
     protected _visibleTileLayerSlices: Layer[][];
     /**
      * Vector layers visible nodes with collections.
      * @protected
-     * @type {Array.<EntityCollection>}
+     * @type {EntityCollection[][]}
      */
-    protected _frustumEntityCollections: EntityCollection[];
+    protected _visibleEntityCollections: EntityCollection[][];
     /**
      * There is only one base layer on the globe when layer.isBaseLayer is true.
      * @public
@@ -184,6 +187,7 @@ export declare class Planet extends RenderNode {
     _renderedNodesInFrustum: Node[][];
     _fadingNodes: Map<number, Node>;
     _fadingNodesInFrustum: Node[][];
+    protected _fadingOpaqueSegments: Segment[];
     /**
      * Layers activity lock.
      * @public
@@ -308,6 +312,7 @@ export declare class Planet extends RenderNode {
     get terrainReady(): boolean;
     get maxGridSize(): number;
     getNorthFrameRotation(cartesian: Vec3): Quat;
+    getFrameRotation(cartesian: Vec3): Quat;
     set atmosphereMaxOpacity(opacity: number);
     get atmosphereMaxOpacity(): number;
     set atmosphereMinOpacity(opacity: number);
@@ -327,6 +332,7 @@ export declare class Planet extends RenderNode {
      * @public
      */
     getLayers(): Layer[];
+    get sun(): Sun | undefined;
     get sunPos(): Vec3;
     /**
      * Add the given control to the renderer of the planet scene.
@@ -466,18 +472,16 @@ export declare class Planet extends RenderNode {
     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[]) => void;
-    protected _renderingFadingNodesNoDepth: (nodes: Map<number, boolean>, sh: Program, currentNode: Node, sl: Layer[], sliceIndex: number) => void;
+    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;
     /**
      * Drawing nodes
      */
     protected _renderingScreenNodes(sh: Program, cam: PlanetCamera, renderedNodes: Node[]): void;
     protected _renderingScreenNodesWithHeight(sh: Program, cam: PlanetCamera, renderedNodes: Node[]): void;
-    protected _renderDistanceFramebufferPASS(): void;
     protected _renderColorPickingFramebufferPASS(): void;
     protected _renderDepthFramebufferPASS(): void;
     protected _collectVectorLayerCollections(): void;
-    protected _frustumEntityCollectionPickingCallback(): void;
     /**
      * Starts clear memory thread.
      * @public

package/lib/js/scene/Planet.js

@@ -5,7 +5,6 @@ import * as utils from "../utils/shared";
 import { Atmosphere } from "../control/Atmosphere";
 import { createColorRGB } from "../utils/shared";
 import { createEvents } from "../Events";
-import { decodeFloatFromRGBAArr } from "../math/coder";
 import { EarthQuadTreeStrategy } from "../quadTree/earth/EarthQuadTreeStrategy";
 import { Extent } from "../Extent";
 import { Geoid } from "../terrain/Geoid";
@@ -19,16 +18,13 @@ import { PlanetCamera } from "../camera/PlanetCamera";
 import { RenderNode } from "./RenderNode";
 import { SimpleSkyBackground } from "../control/SimpleSkyBackground";
 import { TerrainWorker } from "../utils/TerrainWorker";
-import { Vec3, Vec4 } from "../math/index";
+import { Vec2, Vec3 } from "../math/index";
 import { Vector } from "../layer/Vector";
 import { VectorTileCreator } from "../utils/VectorTileCreator";
 import { wgs84 } from "../ellipsoid/wgs84";
 const CUR_LOD_SIZE = 250; //px
 const MIN_LOD_SIZE = 312; //px
 const MAX_LOD_SIZE = 190; //px
-let _tempPickingPix_ = new Uint8Array(4);
-let _tempDepthColor_ = new Uint8Array(4);
-const DEPTH_DISTANCE = 11; //m
 /**
  * Maximum created nodes count. The more nodes count the more memory usage.
  * @const
@@ -58,7 +54,7 @@ const HORIZON_TANGENT = 0.81;
 export class Planet extends RenderNode {
     constructor(options = {}) {
         super(options.name);
-        this._renderingFadingNodes = (nodes, sh, currentNode, sl, sliceIndex, outTransparentSegments) => {
+        this._renderingFadingNodes = (nodes, sh, currentNode, sl, sliceIndex, outTransparentSegments, outOpaqueSegments) => {
             let isFirstPass = sliceIndex === 0;
             let isEq = this.terrain.equalizeVertices;
             for (let j = 0, len = currentNode._fadingNodes.length; j < len; j++) {
@@ -73,6 +69,7 @@ export class Planet extends RenderNode {
                             isEq && f.equalize();
                             f.readyToEngage && f.engage();
                             f.screenRendering(sh, sl, sliceIndex);
+                            outOpaqueSegments.push(f);
                         }
                         else {
                             f.screenRendering(sh, sl, sliceIndex, this.transparentTexture, true);
@@ -81,7 +78,7 @@ export class Planet extends RenderNode {
                 }
             }
         };
-        this._renderingFadingNodesNoDepth = (nodes, sh, currentNode, sl, sliceIndex) => {
+        this._renderingFadingNodesNoDepth = (nodes, sh, currentNode, sl, sliceIndex, outOpaqueSegments) => {
             let isFirstPass = sliceIndex === 0;
             let isEq = this.terrain.equalizeVertices;
             let gl = sh.gl;
@@ -94,6 +91,7 @@ export class Planet extends RenderNode {
                         isEq && f.equalize();
                         f.readyToEngage && f.engage();
                         f.screenRendering(sh, sl, sliceIndex);
+                        outOpaqueSegments.push(f);
                     }
                     else {
                         f.screenRendering(sh, sl, sliceIndex, this.transparentTexture, true);
@@ -113,8 +111,9 @@ export class Planet extends RenderNode {
         this._updateLayer = false;
         this.visibleTileLayers = [];
         this.visibleVectorLayers = [];
+        this._visibleVectorLayersByDepthOrder = [];
         this._visibleTileLayerSlices = [];
-        this._frustumEntityCollections = [];
+        this._visibleEntityCollections = [[]];
         this.baseLayer = null;
         this.terrain = null;
         this.camera = new PlanetCamera(this, {
@@ -142,6 +141,7 @@ export class Planet extends RenderNode {
         this._renderedNodesInFrustum = [];
         this._fadingNodes = new Map;
         this._fadingNodesInFrustum = [];
+        this._fadingOpaqueSegments = [];
         this.layerLock = new Lock();
         this.terrainLock = new Lock();
         this._heightFactor = 1.0;
@@ -191,7 +191,7 @@ export class Planet extends RenderNode {
         this._renderScreenNodesPASS = this._renderScreenNodesPASSNoAtmos;
         this._renderScreenNodesWithHeightPASS = this._renderScreenNodesWithHeightPASSNoAtmos;
         this._atmosphereEnabled = options.atmosphereEnabled || false;
-        this._atmosphereMaxMinOpacity = new Float32Array([1.0, 0.41]);
+        this._atmosphereMaxMinOpacity = new Float32Array([0.95, 0.28]);
         this.solidTextureOne = null;
         this.solidTextureTwo = null;
         this._nightTextureSrc = options.nightTextureSrc || null;
@@ -208,6 +208,9 @@ export class Planet extends RenderNode {
         return this._maxGridSize;
     }
     getNorthFrameRotation(cartesian) {
+        return this.getFrameRotation(cartesian);
+    }
+    getFrameRotation(cartesian) {
         return this.ellipsoid.getNorthFrameRotation(cartesian);
     }
     set atmosphereMaxOpacity(opacity) {
@@ -261,8 +264,12 @@ export class Planet extends RenderNode {
     getLayers() {
         return this.layers;
     }
+    get sun() {
+        if (this.renderer && this.renderer.controls.sun)
+            return this.renderer.controls.sun;
+    }
     get sunPos() {
-        return this.renderer.controls.sun.sunlight.getPosition();
+        return this.sun.sunlight.getPosition();
     }
     /**
      * Add the given control to the renderer of the planet scene.
@@ -485,7 +492,6 @@ export class Planet extends RenderNode {
         h.addProgram(shaders.drawnode_heightPicking(), true);
         this.renderer.addPickingCallback(this, this._renderColorPickingFramebufferPASS);
         this.renderer.addDepthCallback(this, this._renderDepthFramebufferPASS);
-        this.renderer.addDistanceCallback(this, this._renderDistanceFramebufferPASS);
     }
     _onLayerLoadend(layer) {
         this.events.dispatch(this.events.layerloadend, layer);
@@ -552,7 +558,6 @@ export class Planet extends RenderNode {
         this._initializeShaders();
         this._initializeAtmosphere();
         this._updateVisibleLayers();
-        this.renderer.addPickingCallback(this, this._frustumEntityCollectionPickingCallback);
         // loading Earth night glowing texture
         if (this._nightTextureSrc) {
             let img = new Image();
@@ -720,6 +725,18 @@ export class Planet extends RenderNode {
      */
     _sortLayers() {
         this.visibleVectorLayers.sort((a, b) => (a.getZIndex() - b.getZIndex()) || (a.getHeight() - b.getHeight()));
+        let grouped = { 0: [] };
+        for (const vi of this.visibleVectorLayers) {
+            if (!grouped[vi.depthOrder]) {
+                grouped[vi.depthOrder] = [];
+            }
+            grouped[vi.depthOrder].push(vi);
+        }
+        this._visibleVectorLayersByDepthOrder.length = 0;
+        this._visibleVectorLayersByDepthOrder = [];
+        this._visibleVectorLayersByDepthOrder = Object.keys(grouped)
+            .sort((a, b) => Number(a) - Number(b))
+            .map(key => grouped[Number(key)]);
         this._visibleTileLayerSlices = [];
         this._visibleTileLayerSlices.length = 0;
         if (this.visibleTileLayers.length) {
@@ -857,9 +874,6 @@ export class Planet extends RenderNode {
     }
     _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._distBeforeMemClear += this._prevCamEye.distance(cam.eye);
         this._prevCamEye.copy(cam.eye);
         cam.checkFly();
@@ -887,7 +901,7 @@ export class Planet extends RenderNode {
                 this._collectRenderNodes(this.camera);
             }
             this._skipPreRender = true;
-            this.transformLights();
+            //this.transformLights();
             // creates terrain normal maps
             this._normalMapCreator.frame();
             // Creating geoImages textures.
@@ -902,7 +916,9 @@ export class Planet extends RenderNode {
             // Collect entity collections from vector layers
             this._collectVectorLayerCollections();
         }
-        this.drawEntityCollections(this._frustumEntityCollections);
+        for (let i = 0; i < this._visibleEntityCollections.length; i++) {
+            this.drawEntityCollections(this._visibleEntityCollections[i], i);
+        }
     }
     /**
      * Render node callback.
@@ -954,7 +970,7 @@ export class Planet extends RenderNode {
             h.programs.drawnode_screen_wl.activate();
             sh = h.programs.drawnode_screen_wl._program;
             shu = sh.uniforms;
-            gl.uniform3fv(shu.lightsPositions, this._lightsPositions);
+            gl.uniform3fv(shu.lightPosition, this._lightPosition);
             gl.uniformMatrix4fv(shu.viewMatrix, false, cam.getViewMatrix());
             gl.uniformMatrix4fv(shu.projectionMatrix, false, cam.getProjectionMatrix());
             if (this.baseLayer) {
@@ -1002,7 +1018,7 @@ export class Planet extends RenderNode {
             h.programs.drawnode_screen_wl.activate();
             sh = h.programs.drawnode_screen_wl._program;
             shu = sh.uniforms;
-            gl.uniform3fv(shu.lightsPositions, this._lightsPositions);
+            gl.uniform3fv(shu.lightPosition, this._lightPosition);
             gl.uniformMatrix4fv(shu.viewMatrix, false, cam.getViewMatrix());
             gl.uniformMatrix4fv(shu.projectionMatrix, false, cam.getProjectionMatrix());
             if (this.baseLayer) {
@@ -1068,21 +1084,30 @@ export class Planet extends RenderNode {
         let transparentSegments = [];
         let isEq = this.terrain.equalizeVertices;
         let i = renderedNodes.length;
+        //
+        // Collect fading opaque segments, because we need them in the framebuffer passes,
+        // as the segments with equalized sides, which means that there are no gaps
+        // between currently rendered neighbours
+        //
+        this._fadingOpaqueSegments = [];
         if (cam.slope > 0.8 || !this.terrain || this.terrain.isEmpty /*|| cam.getAltitude() > 10000*/) {
             while (i--) {
                 let ri = renderedNodes[i];
                 let s = ri.segment;
-                this._renderingFadingNodesNoDepth(nodes, sh, ri, sl[0], 0);
+                this._renderingFadingNodesNoDepth(nodes, sh, ri, sl[0], 0, this._fadingOpaqueSegments);
                 isEq && s.equalize();
                 s.readyToEngage && s.engage();
                 s.screenRendering(sh, sl[0], 0);
             }
         }
         else {
+            //
+            // Render opaque segments on the first pass, remove transparent ones into second pass
+            //
             while (i--) {
                 let ri = renderedNodes[i];
                 let s = ri.segment;
-                this._renderingFadingNodes(nodes, sh, ri, sl[0], 0, transparentSegments);
+                this._renderingFadingNodes(nodes, sh, ri, sl[0], 0, transparentSegments, this._fadingOpaqueSegments);
                 if (s._transitionOpacity < 1) {
                     transparentSegments.push(s);
                 }
@@ -1092,6 +1117,9 @@ export class Planet extends RenderNode {
                     s.screenRendering(sh, sl[0], 0);
                 }
             }
+            //
+            // Render transparent segments
+            //
             for (let j = 0; j < transparentSegments.length; j++) {
                 let tj = transparentSegments[j];
                 isEq && tj.equalize();
@@ -1132,29 +1160,6 @@ export class Planet extends RenderNode {
         gl.disable(gl.POLYGON_OFFSET_FILL);
         gl.enable(gl.CULL_FACE);
     }
-    _renderDistanceFramebufferPASS() {
-        if (!this.terrain.isEmpty) {
-            let sh;
-            let renderer = this.renderer;
-            let h = renderer.handler;
-            let gl = h.gl;
-            let cam = renderer.activeCamera;
-            h.programs.drawnode_heightPicking.activate();
-            sh = h.programs.drawnode_heightPicking._program;
-            let shu = sh.uniforms;
-            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);
-            // drawing planet nodes
-            let rn = this._renderedNodesInFrustum[cam.currentFrustumIndex];
-            let sl = this._visibleTileLayerSlices;
-            let i = rn.length;
-            while (i--) {
-                rn[i].segment.heightPickingRendering(sh, sl[0]);
-            }
-        }
-    }
     _renderColorPickingFramebufferPASS() {
         let sh;
         let renderer = this.renderer;
@@ -1174,7 +1179,12 @@ export class Planet extends RenderNode {
         let sl = this._visibleTileLayerSlices;
         let i = rn.length;
         while (i--) {
-            rn[i].segment.colorPickingRendering(sh, sl[0], 0);
+            if (rn[i].segment._transitionOpacity >= 1) {
+                rn[i].segment.colorPickingRendering(sh, sl[0], 0);
+            }
+        }
+        for (let i = 0; i < this._fadingOpaqueSegments.length; ++i) {
+            this._fadingOpaqueSegments[i].colorPickingRendering(sh, sl[0], 0);
         }
         // Here is set blending for transparent overlays
         renderer.enableBlendDefault();
@@ -1203,31 +1213,43 @@ export class Planet extends RenderNode {
         gl.uniformMatrix4fv(shu.projectionMatrix, false, cam.getProjectionMatrix());
         gl.uniform3fv(shu.eyePositionHigh, cam.eyeHigh);
         gl.uniform3fv(shu.eyePositionLow, cam.eyeLow);
-        gl.uniform3fv(shu.frustumPickingColor, cam.frustum._pickingColorU);
+        gl.uniform1f(shu.frustumPickingColor, cam.frustumColorIndex);
         // drawing planet nodes
         let rn = this._renderedNodesInFrustum[cam.getCurrentFrustum()], sl = this._visibleTileLayerSlices;
         let i = rn.length;
         while (i--) {
-            rn[i].segment.depthRendering(sh, sl[0]);
+            if (rn[i].segment._transitionOpacity >= 1) {
+                rn[i].segment.depthRendering(sh, sl[0]);
+            }
+        }
+        for (let i = 0; i < this._fadingOpaqueSegments.length; ++i) {
+            this._fadingOpaqueSegments[i].depthRendering(sh, sl[0]);
         }
         gl.enable(gl.BLEND);
     }
     _collectVectorLayerCollections() {
-        this._frustumEntityCollections.length = 0;
-        this._frustumEntityCollections = [];
-        let i = this.visibleVectorLayers.length;
-        while (i--) {
-            let vi = this.visibleVectorLayers[i];
-            if (vi._fading && vi._refreshFadingOpacity()) {
-                this.visibleVectorLayers.splice(i, 1);
+        let k = this._visibleVectorLayersByDepthOrder.length;
+        this._visibleEntityCollections.length = 0;
+        this._visibleEntityCollections = new Array(k);
+        for (let i = 0; i < this._visibleEntityCollections.length; i++) {
+            this._visibleEntityCollections[i] = [];
+        }
+        while (k--) {
+            let group = this._visibleVectorLayersByDepthOrder[k];
+            let j = group.length;
+            while (j--) {
+                let vi = group[j];
+                if (vi._fading && vi._refreshFadingOpacity()) {
+                    group.splice(j, 1);
+                    if (group.length === 0) {
+                        this._visibleVectorLayersByDepthOrder.splice(k, 1);
+                    }
+                }
+                vi.collectVisibleCollections(this._visibleEntityCollections[k]);
+                vi.update();
             }
-            vi.collectVisibleCollections(this._frustumEntityCollections);
-            vi.update();
         }
     }
-    _frustumEntityCollectionPickingCallback() {
-        this.drawPickingEntityCollections(this._frustumEntityCollections);
-    }
     /**
      * Starts clear memory thread.
      * @public
@@ -1358,34 +1380,11 @@ export class Planet extends RenderNode {
      * @returns {number | undefined} -
      */
     getDistanceFromPixel(px) {
-        if (this.terrain.isEmpty) {
-            return this.getDistanceFromPixelEllipsoid(px) || 0;
-        }
-        else {
-            let r = this.renderer;
-            let cnv = r.handler.canvas;
-            let spx = px.x / cnv.width;
-            let spy = (cnv.height - px.y) / cnv.height;
-            _tempPickingPix_[0] = _tempPickingPix_[1] = _tempPickingPix_[2] = 0.0;
-            let dist = 0;
-            r.readDistanceColor(spx, spy, _tempPickingPix_);
-            dist = decodeFloatFromRGBAArr(_tempPickingPix_);
-            if (!(_tempPickingPix_[0] || _tempPickingPix_[1] || _tempPickingPix_[2])) {
-                dist = this.getDistanceFromPixelEllipsoid(px) || 0;
-            }
-            else if (dist < DEPTH_DISTANCE) {
-                r.screenDepthFramebuffer.activate();
-                //if (r.screenDepthFramebuffer.isComplete()) {
-                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 || r.activeCamera.unproject(px.x, px.y);
-                dist = -(viewPosition.z / viewPosition.w) / dir.dot(r.activeCamera.getForward());
-                //}
-                r.screenDepthFramebuffer.deactivate();
-            }
-            return dist;
-        }
+        // if (this.terrain!.isEmpty) {
+        //     return this.getDistanceFromPixelEllipsoid(px) || 0;
+        // } else {
+        return this.renderer.getDistanceFromPixel(px) || this.getDistanceFromPixelEllipsoid(px) || 0;
+        //}
     }
     /**
      * Sets camera to the planet geographical extent.
@@ -1415,6 +1414,29 @@ export class Planet extends RenderNode {
      * @returns {Extent} -
      */
     getViewExtent() {
+        if (this.renderer) {
+            let w = this.renderer.handler.getWidth(), h = this.renderer.handler.getHeight();
+            let extent = [
+                this.getLonLatFromPixelTerrain(new Vec2(0, 0)),
+                this.getLonLatFromPixelTerrain(new Vec2(w, 0)),
+                this.getLonLatFromPixelTerrain(new Vec2(w, h)),
+                this.getLonLatFromPixelTerrain(new Vec2(0, h))
+            ];
+            if (extent[0] && extent[1] && extent[2] && extent[3]) {
+                let min_lon = extent[0].lon, min_lat = extent[2].lat, max_lon = extent[1].lon, max_lat = extent[0].lat;
+                for (let i = 0; i < extent.length; i++) {
+                    if (extent[i].lon > max_lon)
+                        max_lon = extent[i].lon;
+                    if (extent[i].lat > max_lat)
+                        max_lat = extent[i].lat;
+                    if (extent[i].lon < min_lon)
+                        min_lon = extent[i].lon;
+                    if (extent[i].lat < min_lat)
+                        min_lat = extent[i].lat;
+                }
+                return new Extent(new LonLat(min_lon, min_lat), new LonLat(max_lon, max_lat));
+            }
+        }
         return this._viewExtent;
     }
     /**

package/lib/js/scene/RenderNode.d.ts

@@ -2,6 +2,8 @@ import { BaseNode } from "./BaseNode";
 import { Renderer } from "../renderer/Renderer";
 import { LightSource } from "../light/LightSource";
 import { EntityCollection } from "../entity/EntityCollection";
+import { Quat } from "../math/Quat";
+import { Vec3 } from "../math/Vec3";
 /**
  * Render node is a logical part of a render mechanism. Represents scene rendering.
  * For example one scene node for rendering the Earth, another one for rendering the Moon, another node for rendering stars etc.
@@ -37,19 +39,19 @@ declare class RenderNode extends BaseNode {
      * @public
      * @type {Array.<LightSource>}
      */
-    _lights: LightSource[];
-    _lightsNames: string[];
-    _lightsPositions: number[];
-    _lightsParamsv: number[];
-    _lightsParamsf: number[];
+    _lightPosition: Float32Array;
+    _lightParams: Float32Array;
+    _lightShininess: number;
     /**
      * Entity collection array.
      * @public
      * @type {Array.<EntityCollection>}
      */
     entityCollections: EntityCollection[];
+    protected _entityCollectionsByDepthOrder: EntityCollection[][];
     protected _pickingId: number;
     constructor(name?: string);
+    getFrameRotation(cartesian: Vec3): Quat;
     /**
      * Adds node to the current hierarchy.
      * @public
@@ -73,13 +75,14 @@ declare class RenderNode extends BaseNode {
      * @param {boolean} [isHidden] - If it's true that this collection has specific rendering.
      * @returns {RenderNode} -
      */
-    addEntityCollection(entityCollection: EntityCollection, isHidden?: boolean): RenderNode;
+    addEntityCollection(entityCollection: EntityCollection, isHidden?: boolean): void;
     /**
      * Removes entity collection.
      * @public
      * @param {EntityCollection} entityCollection - Entity collection for remove.
      */
     removeEntityCollection(entityCollection: EntityCollection): void;
+    updateEntityCollectionsDepthOrder(): void;
     /**
      * Adds point light source.
      * @public
@@ -87,19 +90,6 @@ declare class RenderNode extends BaseNode {
      * @returns {RenderNode}
      */
     addLight(light: LightSource): RenderNode;
-    /**
-     * Gets light object by its name.
-     * @public
-     * @param {string} name - Point light name.
-     * @returns {LightSource}
-     */
-    getLightByName(name: string): LightSource | undefined;
-    /**
-     * Removes light source.
-     * @public
-     * @param {LightSource} light - Light source object.
-     */
-    removeLight(light: LightSource): void;
     /**
      * Calls render frame node's callback. Used in renderer.
      * @public
@@ -128,17 +118,12 @@ declare class RenderNode extends BaseNode {
      * @param {Number} mode - Draw mode, such as gl.TRIANGLES, gl.TRIANGLE_STRIP, gl.LINES etc.
      */
     setDrawMode(mode: number): void;
-    /**
-     * IMPORTANT: This function have to be called manually in each render node frame callback, before drawing scene geometry.
-     * @public
-     */
-    transformLights(): void;
     updateBillboardsTexCoords(): void;
     frame(): void;
     preFrame(): void;
     protected _preDrawNodes(): void;
     protected _drawNodes(): void;
-    drawEntityCollections(ec: EntityCollection[]): void;
+    drawEntityCollections(ec: EntityCollection[], depthOrder?: number): void;
     /**
      * Draw entity collections picking frame.
      * @public