@openglobus/og 0.14.10 → 0.15.0

package/src/og/scene/Planet.js

@@ -30,16 +30,17 @@ import { VectorTileCreator } from "../utils/VectorTileCreator.js";
 import { wgs84 } from "../ellipsoid/wgs84.js";
 import { NIGHT, SPECULAR } from "../res/images.js";
 import { Geoid } from "../terrain/Geoid.js";
-import { isUndef } from "../utils/shared.js";
+import { createColorRGB, isUndef } from "../utils/shared.js";
 import { MAX_RENDERED_NODES } from "../quadTree/quadTree.js";
 import { EarthQuadTreeStrategy } from "../quadTree/EarthQuadTreeStrategy.js";
+import { SimpleSkyBackground } from "../control/SimpleSkyBackground.js";
+import { Atmosphere } from "../control/Atmosphere.js";
 
 const CUR_LOD_SIZE = 250; //px
 const MIN_LOD_SIZE = 312; //px
 const MAX_LOD_SIZE = 190; //px
 
-let _tempPickingPix_ = new Uint8Array(4),
-    _tempDepthColor_ = new Uint8Array(4);
+let _tempPickingPix_ = new Uint8Array(4), _tempDepthColor_ = new Uint8Array(4);
 
 const DEPTH_DISTANCE = 11;//m
 
@@ -53,11 +54,10 @@ const MAX_NODES = 200;
 
 const HORIZON_TANGENT = 0.81;
 
-const EVENT_NAMES = [
-    /**
-     * Triggered before globe frame begins to render.
-     * @event og.scene.Planet#draw
-     */
+const EVENT_NAMES = [/**
+ * Triggered before globe frame begins to render.
+ * @event og.scene.Planet#draw
+ */
     "draw",
 
     /**
@@ -100,8 +100,7 @@ const EVENT_NAMES = [
      * Triggered when layer data is laded
      * @event og.scene.Planet#terraincompleted
      */
-    "layerloadend"
-];
+    "layerloadend"];
 
 /**
  * Main class for rendering planet
@@ -124,12 +123,7 @@ export class Planet extends RenderNode {
     constructor(options = {}) {
         super(options.name);
 
-        this._cameraFrustums = options.frustums || [
-            [1, 100 + 0.075],
-            [100, 1000 + 0.075],
-            [1000, 1e6 + 10000],
-            [1e6, 1e9]
-        ];
+        this._cameraFrustums = options.frustums || [[1, 100 + 0.075], [100, 1000 + 0.075], [1000, 1e6 + 10000], [1e6, 1e9]];
 
         /**
          * @public
@@ -350,8 +344,8 @@ export class Planet extends RenderNode {
         //TODO: replace to a function
         let a = utils.createColorRGB(options.ambient, new Vec3(0.2, 0.2, 0.2));
         let d = utils.createColorRGB(options.diffuse, new Vec3(0.8, 0.8, 0.8));
-        let s = utils.createColorRGB(options.specular, new Vec3(0.0003, 0.0003, 0.0003));
-        let shininess = options.shininess || 20.0;
+        let s = utils.createColorRGB(options.specular, new Vec3(0.013, 0.005, 0.0));
+        let shininess = options.shininess || 27.0;
 
         this._ambient = new Float32Array([a.x, a.y, a.z]);
         this._diffuse = new Float32Array([d.x, d.y, d.z]);
@@ -369,9 +363,7 @@ export class Planet extends RenderNode {
          * @protected
          * @type {boolean}
          */
-        this._useSpecularTexture = isUndef(options.useSpecularTexture)
-            ? true
-            : options.useSpecularTexture;
+        this._useSpecularTexture = isUndef(options.useSpecularTexture) ? true : options.useSpecularTexture;
 
         this._maxGridSize = Math.log2(options.maxGridSize || 128);
 
@@ -432,14 +424,76 @@ export class Planet extends RenderNode {
 
         this._terrainCompleted = false;
         this._terrainCompletedActivated = false;
+        this._collectRenderNodesIsActive = true;
+
+        /**
+         * Night texture brightness coefficient
+         * @type {number}
+         */
+        this.nightTextureCoefficient = 1.5;
+
+        this._renderScreenNodesPASS = this._renderScreenNodesPASSNoAtmos;
+
+        this._atmosphereEnabled = options.atmosphereEnabled || false;
+        this._atmosphereMaxMinOpacity = new Float32Array([1.0, 0.41]);
     }
 
     static getBearingNorthRotationQuat(cartesian) {
+        //
+        // TODO: fix normal for ellipsoid
+        //
         let n = cartesian.normal();
         let t = Vec3.proj_b_to_plane(Vec3.UNIT_Y, n);
         return Quat.getLookRotation(t, n);
     }
 
+    set atmosphereMaxOpacity(opacity) {
+        this._atmosphereMaxMinOpacity[0] = opacity;
+    }
+
+    get atmosphereMaxOpacity() {
+        return this._atmosphereMaxMinOpacity[0];
+    }
+
+    set atmosphereMinOpacity(opacity) {
+        this._atmosphereMaxMinOpacity[1] = opacity;
+    }
+
+    get atmosphereMinOpacity() {
+        return this._atmosphereMaxMinOpacity[1];
+    }
+
+
+    set atmosphereEnabled(enabled) {
+        if (enabled != this._atmosphereEnabled) {
+            this._atmosphereEnabled = enabled;
+            this._initializeAtmosphere();
+        }
+    }
+
+    get atmosphereEnabled() {
+        return this._atmosphereEnabled;
+    }
+
+    set diffuse(rgb) {
+        let vec = createColorRGB(rgb);
+        this._diffuse = new Float32Array(vec.toArray());
+    }
+
+    set ambient(rgb) {
+        let vec = createColorRGB(rgb);
+        this._ambient = new Float32Array(vec.toArray());
+    }
+
+    set specular(rgb) {
+        let vec = createColorRGB(rgb);
+        this._specular = new Float32Array([vec.x, vec.y, vec.y, this._specular[3]]);
+    }
+
+    set shininess(v) {
+        this._specular[3] = v;
+    }
+
     get normalMapCreator() {
         return this._normalMapCreator;
     }
@@ -448,6 +502,10 @@ export class Planet extends RenderNode {
         return [...this._layers];
     }
 
+    get sunPos() {
+        return this.renderer.controls.sun.sunlight.getPosition();
+    }
+
     /**
      * Add the given control to the renderer of the planet scene.
      * @param {control.Control} control - Control.
@@ -628,24 +686,66 @@ export class Planet extends RenderNode {
                     terrain._isReady = true;
                 })
                 .catch((err) => {
-                    console.log(err);
+                    console.warn(err);
                 });
         }
     }
 
+    _initializeAtmosphere() {
+        let h = this.renderer.handler;
+        h.removeProgram("drawnode_screen_wl");
+
+        if (this._atmosphereEnabled) {
+
+            this._renderScreenNodesPASS = this._renderScreenNodesPASSAtmos;
+
+            if (h.isWebGl2()) {
+                h.addProgram(shaders.drawnode_screen_wl_webgl2Atmos(), true);
+            } else {
+                h.addProgram(shaders.drawnode_screen_wl_webgl1NoAtmos(), true);
+            }
+
+            if (!this.renderer.controls.Atmosphere) {
+                this.addControl(new Atmosphere());
+            } else {
+                this.renderer.controls.Atmosphere.activate();
+            }
+
+            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.SimpleSkyBackground) {
+                this.addControl(new SimpleSkyBackground());
+            } else {
+                this.renderer.controls.SimpleSkyBackground.activate();
+            }
+
+            if (h.isWebGl2()) {
+                h.addProgram(shaders.drawnode_screen_wl_webgl2NoAtmos(), true);
+            } else {
+                h.addProgram(shaders.drawnode_screen_wl_webgl1NoAtmos(), true);
+            }
+        }
+    }
+
     /**
      * @virtual
      * @protected
      */
     _initializeShaders() {
-        var h = this.renderer.handler;
+        let h = this.renderer.handler;
 
         h.addProgram(shaders.drawnode_screen_nl(), true);
-        if (h.isWebGl2()) {
-            h.addProgram(shaders.drawnode_screen_wl_webgl2(), true);
-        } else {
-            h.addProgram(shaders.drawnode_screen_wl(), true);
-        }
         h.addProgram(shaders.drawnode_colorPicking(), true);
         h.addProgram(shaders.drawnode_depth(), true);
         h.addProgram(shaders.drawnode_heightPicking(), true);
@@ -655,8 +755,7 @@ export class Planet extends RenderNode {
         this.renderer.addDepthCallback(this, this._renderDepthFramebufferPASS);
 
         this._heightPickingFramebuffer = new Framebuffer(this.renderer.handler, {
-            width: 320,
-            height: 240
+            width: 320, height: 240
         });
 
         this._heightPickingFramebuffer.init();
@@ -686,11 +785,9 @@ export class Planet extends RenderNode {
             for (var j = 0; j <= TABLESIZE; j++) {
                 !this._indexesCache[i][j] && (this._indexesCache[i][j] = new Array(TABLESIZE));
                 for (var k = 0; k <= TABLESIZE; k++) {
-                    !this._indexesCache[i][j][k] &&
-                    (this._indexesCache[i][j][k] = new Array(TABLESIZE));
+                    !this._indexesCache[i][j][k] && (this._indexesCache[i][j][k] = new Array(TABLESIZE));
                     for (var m = 0; m <= TABLESIZE; m++) {
-                        !this._indexesCache[i][j][k][m] &&
-                        (this._indexesCache[i][j][k][m] = new Array(TABLESIZE));
+                        !this._indexesCache[i][j][k][m] && (this._indexesCache[i][j][k][m] = new Array(TABLESIZE));
                         for (var q = 0; q <= TABLESIZE; q++) {
                             let ptr = {
                                 buffer: null
@@ -700,10 +797,7 @@ export class Planet extends RenderNode {
                                 let indexes = segmentHelper
                                     .getInstance()
                                     .createSegmentIndexes(i, [j, k, m, q]);
-                                ptr.buffer = this.renderer.handler.createElementArrayBuffer(
-                                    indexes,
-                                    1
-                                );
+                                ptr.buffer = this.renderer.handler.createElementArrayBuffer(indexes, 1);
                                 indexes = null;
                             } else {
                                 this._indexesCacheToRemove[kk++] = ptr;
@@ -727,11 +821,7 @@ 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;
@@ -761,7 +851,6 @@ export class Planet extends RenderNode {
             this._renderedNodesInFrustum[i] = [];
         }
 
-
         // Creating quad trees nodes
         this.quadTreeStrategy.init();
 
@@ -770,22 +859,20 @@ export class Planet extends RenderNode {
         // Applying shaders
         this._initializeShaders();
 
+        this._initializeAtmosphere();
+
         this._updateVisibleLayers();
 
         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))
-            );
+            createImageBitmap(NIGHT).then((e) => (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))
-            );
+            createImageBitmap(SPECULAR).then((e) => (this._specularTexture = this.renderer.handler.createTexture_l(e)));
         }
 
         this._geoImageCreator = new GeoImageCreator(this);
@@ -812,8 +899,7 @@ export class Planet extends RenderNode {
 
     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);
@@ -947,17 +1033,13 @@ export class Planet extends RenderNode {
      * @protected
      */
     _sortLayers() {
-        this.visibleVectorLayers.sort(
-            (a, b) => (a._zIndex - b._zIndex) || (a._height - b._height)
-        );
+        this.visibleVectorLayers.sort((a, b) => (a._zIndex - b._zIndex) || (a._height - b._height));
 
         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._height - b._height) || (a._zIndex - b._zIndex));
 
             var k = -1;
             var currHeight = this.visibleTileLayers[0]._height;
@@ -976,8 +1058,9 @@ export class Planet extends RenderNode {
         // clearing all node list
         this._renderedNodes.length = 0;
         this._renderedNodes = [];
+    }
 
-        // clearing nodes in frustums
+    _clearRenderNodesInFrustum() {
         for (let i = 0, len = this._renderedNodesInFrustum.length; i < len; i++) {
             this._renderedNodesInFrustum[i].length = 0;
             this._renderedNodesInFrustum[i] = [];
@@ -990,13 +1073,12 @@ export class Planet extends RenderNode {
      */
     _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
         this._clearRenderedNodeList();
+        this._clearRenderNodesInFrustum();
 
         this._viewExtent.southWest.set(180, 180);
         this._viewExtent.northEast.set(-180, -180);
@@ -1008,32 +1090,23 @@ export class Planet extends RenderNode {
         this.minCurrZoom = math.MAX;
         this.maxCurrZoom = math.MIN;
 
-        if (cam.slope > this.minEqualZoomCameraSlope &&
-            cam._lonLat.height < this.maxEqualZoomAltitude &&
-            cam._lonLat.height > this.minEqualZoomAltitude
-        ) {
+        this.quadTreeStrategy.collectRenderNodes();
+
+        if (cam.slope > this.minEqualZoomCameraSlope && cam._lonLat.height < this.maxEqualZoomAltitude && cam._lonLat.height > this.minEqualZoomAltitude) {
 
             this.minCurrZoom = this.maxCurrZoom;
 
-            let temp = this._renderedNodes,
-                rf = this._renderedNodesInFrustum,
-                temp2 = [];
+            let temp = this._renderedNodes, rf = this._renderedNodesInFrustum, temp2 = [];
 
+            this._clearRenderNodesInFrustum();
             this._renderedNodes = [];
 
-            // clearing nodes in frustums
-            for (let i = 0, len = this._renderedNodesInFrustum.length; i < len; i++) {
-                this._renderedNodesInFrustum[i].length = 0;
-                this._renderedNodesInFrustum[i] = [];
-            }
-
             for (var i = 0, len = temp.length; i < len; i++) {
                 var ri = temp[i];
                 let ht = ri.segment.centerNormal.dot(cam._b);
                 if (ri.segment.tileZoom === this.maxCurrZoom || ht < HORIZON_TANGENT) {
                     this._renderedNodes.push(ri);
-                    let k = 0,
-                        inFrustum = ri.inFrustum;
+                    let k = 0, inFrustum = ri.inFrustum;
                     while (inFrustum) {
                         if (inFrustum & 1) {
                             rf[k].push(ri);
@@ -1050,8 +1123,6 @@ export class Planet extends RenderNode {
                 temp2[i].renderTree(cam, this.maxCurrZoom, null);
             }
         }
-
-        this.quadTreeStrategy.collectRenderNodes();
     }
 
     _globalPreDraw() {
@@ -1083,6 +1154,10 @@ export class Planet extends RenderNode {
             this._updateVisibleLayers();
         }
 
+        if (this.camera.isFirstPass) {
+            this._firstPASS();
+        }
+
         this._renderScreenNodesPASS();
 
         this._renderHeightPickingFramebufferPASS();
@@ -1113,43 +1188,160 @@ export class Planet extends RenderNode {
         this._terrainCompleted = true;
     }
 
-    /**
-     * @protected
-     */
-    _renderScreenNodesPASS() {
+    lockQuadTree() {
+        this._collectRenderNodesIsActive = false;
+        this.camera.setTerrainCollisionActivity(false);
+    }
+
+    unlockQuadTree() {
+        this._collectRenderNodesIsActive = true;
+        this.camera.setTerrainCollisionActivity(true);
+    }
+
+    _firstPASS() {
+
+        if (this._skipPreRender && this._collectRenderNodesIsActive) {
+            this._collectRenderNodes();
+        }
+        this._skipPreRender = true;
+
+        // Here is the planet node dispatches a draw event before
+        // rendering begins and we have got render nodes.
+        this.events.dispatch(this.events.draw, this);
+
+        this.transformLights();
+
+        this._normalMapCreator.frame();
+
+        // Creating geoImages textures.
+        this._geoImageCreator.frame();
+
+        // Collect entity collections from vector layers
+        this._collectVectorLayerCollections();
+
+        // Vector tiles rasteriazation
+        this._vectorTileCreator.frame();
+    }
+
+    _renderScreenNodesPASSNoAtmos() {
 
         let sh, shu;
         let renderer = this.renderer;
         let h = renderer.handler;
         let gl = h.gl;
         let cam = renderer.activeCamera;
-        let frustumIndex = cam.getCurrentFrustum(),
-            firstPass = frustumIndex === cam.FARTHEST_FRUSTUM_INDEX;
+        let firstPass = cam.isFirstPass;
+        let frustumIndex = cam.currentFrustumIndex;
 
-        if (firstPass) {
-            if (this._skipPreRender/* && (!this._renderCompletedActivated || cam.isMoved)*/) {
-                this._collectRenderNodes();
+        gl.enable(gl.CULL_FACE);
+
+        gl.enable(gl.BLEND);
+        gl.blendEquation(gl.FUNC_ADD);
+        gl.blendFunc(gl.ONE, gl.ONE_MINUS_SRC_ALPHA);
+
+        if (this.lightEnabled) {
+            h.programs.drawnode_screen_wl.activate();
+            sh = h.programs.drawnode_screen_wl._program;
+            shu = sh.uniforms;
+
+            gl.uniform3fv(shu.lightsPositions, this._lightsPositions);
+            gl.uniformMatrix4fv(shu.viewMatrix, false, cam.getViewMatrix());
+            gl.uniformMatrix4fv(shu.projectionMatrix, false, cam.getProjectionMatrix());
+
+            if (this.baseLayer) {
+                gl.uniform3fv(shu.diffuse, this.baseLayer._diffuse || this._diffuse);
+                gl.uniform3fv(shu.ambient, this.baseLayer._ambient || this._ambient);
+                gl.uniform4fv(shu.specular, this.baseLayer._specular || this._specular);
+                gl.uniform1f(shu.nightTextureCoefficient, this.baseLayer.nightTextureCoefficient || this.nightTextureCoefficient);
+            } else {
+                gl.uniform3fv(shu.diffuse, this._diffuse);
+                gl.uniform3fv(shu.ambient, this._ambient);
+                gl.uniform4fv(shu.specular, this._specular);
+                gl.uniform1f(shu.nightTextureCoefficient, this.nightTextureCoefficient);
             }
-            this._skipPreRender = true;
 
-            // Here is the planet node dispatches a draw event before
-            // rendering begins and we have got render nodes.
-            this.events.dispatch(this.events.draw, this);
+            //
+            // Night and specular
+            //
+            gl.activeTexture(gl.TEXTURE0 + this.SLICE_SIZE);
+            gl.bindTexture(gl.TEXTURE_2D, this._nightTexture || this.transparentTexture);
+            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.uniform1i(shu.specularTexture, this.SLICE_SIZE + 1);
+
+            gl.uniform1f(shu.camHeight, cam.getHeight());
+
+        } else {
+            h.programs.drawnode_screen_nl.activate();
+            sh = h.programs.drawnode_screen_nl._program;
+            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);
 
-            this.transformLights();
+        //
+        // drawing planet nodes
+        //
+        let rn = this._renderedNodesInFrustum[frustumIndex],
+            sl = this._visibleTileLayerSlices;
 
-            this._normalMapCreator.frame();
+        if (sl.length) {
+            let sli = sl[0];
+            for (var i = sli.length - 1; i >= 0; --i) {
+                let li = sli[i];
+                if (li._fading && firstPass && li._refreshFadingOpacity()) {
+                    sli.splice(i, 1);
+                }
+            }
+        }
 
-            // Creating geoImages textures.
-            this._geoImageCreator.frame();
+        let isEq = this.terrain.equalizeVertices;
+        i = rn.length;
+        while (i--) {
+            let s = rn[i].segment;
+            isEq && s.equalize();
+            s.readyToEngage && s.engage();
+            s.screenRendering(sh, sl[0], 0);
+        }
 
-            // Collect entity collections from vector layers
-            this._collectVectorLayerCollections();
+        gl.enable(gl.POLYGON_OFFSET_FILL);
+        for (let j = 1, len = sl.length; j < len; j++) {
+            let slj = sl[j];
+            for (i = slj.length - 1; i >= 0; --i) {
+                let li = slj[i];
+                if (li._fading && firstPass && li._refreshFadingOpacity()) {
+                    slj.splice(i, 1);
+                }
+            }
 
-            // Vector tiles rasteriazation
-            this._vectorTileCreator.frame();
+            gl.polygonOffset(0, -j);
+            i = rn.length;
+            while (i--) {
+                rn[i].segment.screenRendering(sh, sl[j], j, this.transparentTexture, true);
+            }
         }
+        gl.disable(gl.POLYGON_OFFSET_FILL);
+
+        gl.disable(gl.BLEND);
+    }
+
+    /**
+     * @protected
+     */
+    _renderScreenNodesPASSAtmos() {
 
+        let sh, shu;
+        let renderer = this.renderer;
+        let h = renderer.handler;
+        let gl = h.gl;
+        let cam = renderer.activeCamera;
+        let firstPass = cam.isFirstPass;
+        let frustumIndex = cam.currentFrustumIndex;
 
         gl.enable(gl.CULL_FACE);
 
@@ -1162,28 +1354,49 @@ export class Planet extends RenderNode {
             sh = h.programs.drawnode_screen_wl._program;
             shu = sh.uniforms;
 
-            gl.uniform4fv(shu.lightsPositions, this._lightsTransformedPositions);
-
-            gl.uniformMatrix3fv(shu.normalMatrix, false, cam.getNormalMatrix());
+            gl.uniform3fv(shu.lightsPositions, this._lightsPositions);
             gl.uniformMatrix4fv(shu.viewMatrix, false, cam.getViewMatrix());
             gl.uniformMatrix4fv(shu.projectionMatrix, false, cam.getProjectionMatrix());
 
-            gl.uniform3fv(shu.diffuse, this._diffuse);
-            gl.uniform3fv(shu.ambient, this._ambient);
-            gl.uniform4fv(shu.specular, this._specular);
+            if (this.baseLayer) {
+                gl.uniform3fv(shu.diffuse, this.baseLayer._diffuse || this._diffuse);
+                gl.uniform3fv(shu.ambient, this.baseLayer._ambient || this._ambient);
+                gl.uniform4fv(shu.specular, this.baseLayer._specular || this._specular);
+                gl.uniform1f(shu.nightTextureCoefficient, this.baseLayer.nightTextureCoefficient || this.nightTextureCoefficient);
+            } else {
+                gl.uniform3fv(shu.diffuse, this._diffuse);
+                gl.uniform3fv(shu.ambient, this._ambient);
+                gl.uniform4fv(shu.specular, this._specular);
+                gl.uniform1f(shu.nightTextureCoefficient, this.nightTextureCoefficient);
+            }
+
+            gl.uniform2fv(shu.maxMinOpacity, this._atmosphereMaxMinOpacity);
 
-            // bind night glowing material
+            //
+            // Night and specular
+            //
             gl.activeTexture(gl.TEXTURE0 + this.SLICE_SIZE);
-            gl.bindTexture(gl.TEXTURE_2D,
-                (this.camera._lonLat.height > 329958.0 && (this._nightTexture || this.transparentTexture)) || this.transparentTexture
-            );
+            gl.bindTexture(gl.TEXTURE_2D, this._nightTexture || this.transparentTexture);
             gl.uniform1i(shu.nightTexture, this.SLICE_SIZE);
 
-            // bind specular material
             gl.activeTexture(gl.TEXTURE0 + this.SLICE_SIZE + 1);
             gl.bindTexture(gl.TEXTURE_2D, this._specularTexture || this.transparentTexture);
             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.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.uniform1i(shu.scatteringTexture, this.SLICE_SIZE + 5);
+
+            gl.uniform1f(shu.camHeight, cam.getHeight());
+
         } else {
             h.programs.drawnode_screen_nl.activate();
             sh = h.programs.drawnode_screen_nl._program;
@@ -1195,8 +1408,10 @@ export class Planet extends RenderNode {
         gl.uniform3fv(shu.eyePositionHigh, cam.eyeHigh);
         gl.uniform3fv(shu.eyePositionLow, cam.eyeLow);
 
+        //
         // drawing planet nodes
-        var rn = this._renderedNodesInFrustum[frustumIndex],
+        //
+        let rn = this._renderedNodesInFrustum[frustumIndex],
             sl = this._visibleTileLayerSlices;
 
         if (sl.length) {
@@ -1252,7 +1467,7 @@ export class Planet extends RenderNode {
             let h = renderer.handler;
             let gl = h.gl;
             let cam = renderer.activeCamera;
-            let frustumIndex = cam.getCurrentFrustum();
+            let frustumIndex = cam.currentFrustumIndex;
 
             if (frustumIndex === cam.FARTHEST_FRUSTUM_INDEX) {
                 gl.clearColor(0.0, 0.0, 0.0, 1.0);
@@ -1272,8 +1487,7 @@ export class Planet extends RenderNode {
             gl.uniform3fv(shu.eyePositionLow, cam.eyeLow);
 
             // drawing planet nodes
-            let rn = this._renderedNodesInFrustum[frustumIndex],
-                sl = this._visibleTileLayerSlices;
+            let rn = this._renderedNodesInFrustum[frustumIndex], sl = this._visibleTileLayerSlices;
 
             let i = rn.length;
             while (i--) {
@@ -1309,8 +1523,7 @@ export class Planet extends RenderNode {
         gl.uniform3fv(shu.eyePositionLow, cam.eyeLow);
 
         // drawing planet nodes
-        var rn = this._renderedNodesInFrustum[cam.getCurrentFrustum()],
-            sl = this._visibleTileLayerSlices;
+        var rn = this._renderedNodesInFrustum[cam.getCurrentFrustum()], sl = this._visibleTileLayerSlices;
 
         let i = rn.length;
         while (i--) {
@@ -1355,8 +1568,7 @@ export class Planet extends RenderNode {
         gl.uniform3fv(shu.frustumPickingColor, cam.frustum._pickingColorU);
 
         // drawing planet nodes
-        var rn = this._renderedNodesInFrustum[cam.getCurrentFrustum()],
-            sl = this._visibleTileLayerSlices;
+        var rn = this._renderedNodesInFrustum[cam.getCurrentFrustum()], sl = this._visibleTileLayerSlices;
 
         let i = rn.length;
         while (i--) {
@@ -1550,11 +1762,9 @@ export class Planet extends RenderNode {
             return this.getDistanceFromPixelEllipsoid(px) || 0;
         } else {
 
-            let r = this.renderer,
-                cnv = this.renderer.handler.canvas;
+            let r = this.renderer, cnv = this.renderer.handler.canvas;
 
-            let spx = px.x / cnv.width,
-                spy = (cnv.height - px.y) / cnv.height;
+            let spx = px.x / cnv.width, spy = (cnv.height - px.y) / cnv.height;
 
             _tempPickingPix_[0] = _tempPickingPix_[1] = _tempPickingPix_[2] = 0.0;
 
@@ -1562,28 +1772,27 @@ export class Planet extends RenderNode {
 
             // HEIGHT
             this._heightPickingFramebuffer.activate();
-            if (this._heightPickingFramebuffer.isComplete()) {
-                this._heightPickingFramebuffer.readPixels(_tempPickingPix_, spx, spy);
-                dist = decodeFloatFromRGBAArr(_tempPickingPix_);
-            }
+
+            //if (this._heightPickingFramebuffer.isComplete()) {
+            this._heightPickingFramebuffer.readPixels(_tempPickingPix_, spx, spy);
+            dist = decodeFloatFromRGBAArr(_tempPickingPix_);
+            //}
+
             this._heightPickingFramebuffer.deactivate();
 
             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 || this.renderer.activeCamera.unproject(px.x, px.y);
-                    dist = -(viewPosition.z / viewPosition.w) / dir.dot(this.renderer.activeCamera.getForward());
-                }
+
+                //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 || this.renderer.activeCamera.unproject(px.x, px.y);
+                dist = -(viewPosition.z / viewPosition.w) / dir.dot(this.renderer.activeCamera.getForward());
+                //}
+
                 r.screenDepthFramebuffer.deactivate();
             }
             return dist;
@@ -1606,12 +1815,7 @@ export class Planet extends RenderNode {
      * where index 0 - southwest longitude, 1 - latitude southwest, 2 - longitude northeast, 3 - latitude northeast.
      */
     viewExtentArr(extentArr) {
-        this.renderer.activeCamera.viewExtent(
-            new Extent(
-                new LonLat(extentArr[0], extentArr[1]),
-                new LonLat(extentArr[2], extentArr[3])
-            )
-        );
+        this.renderer.activeCamera.viewExtent(new Extent(new LonLat(extentArr[0], extentArr[1]), new LonLat(extentArr[2], extentArr[3])));
     }
 
     /**
@@ -1666,14 +1870,7 @@ export class Planet extends RenderNode {
      * @param {cameraCallback} [completeCallback] - Callback that calls befor the flying begins.
      */
     flyExtent(extent, height, up, ampl, completeCallback, startCallback) {
-        this.renderer.activeCamera.flyExtent(
-            extent,
-            height,
-            up,
-            ampl,
-            completeCallback,
-            startCallback
-        );
+        this.renderer.activeCamera.flyExtent(extent, height, up, ampl, completeCallback, startCallback);
     }
 
     /**
@@ -1688,15 +1885,7 @@ export class Planet extends RenderNode {
      * @param [frameCallback]
      */
     flyCartesian(cartesian, look, up, ampl, completeCallback, startCallback, frameCallback) {
-        this.renderer.activeCamera.flyCartesian(
-            cartesian,
-            look,
-            up,
-            ampl,
-            completeCallback,
-            startCallback,
-            frameCallback
-        );
+        this.renderer.activeCamera.flyCartesian(cartesian, look, up, ampl, completeCallback, startCallback, frameCallback);
     }
 
     /**
@@ -1711,15 +1900,7 @@ export class Planet extends RenderNode {
      * @param [frameCallback]
      */
     flyLonLat(lonlat, look, up, ampl, completeCallback, startCallback, frameCallback) {
-        this.renderer.activeCamera.flyLonLat(
-            lonlat,
-            look,
-            up,
-            ampl,
-            completeCallback,
-            startCallback,
-            frameCallback
-        );
+        this.renderer.activeCamera.flyLonLat(lonlat, look, up, ampl, completeCallback, startCallback, frameCallback);
     }
 
     /**
@@ -1750,8 +1931,7 @@ export class Planet extends RenderNode {
     }
 
     getEntityTerrainPoint(entity, res) {
-        let n = this._renderedNodes,
-            i = n.length;
+        let n = this._renderedNodes, i = n.length;
         while (i--) {
             if (n[i].segment.isEntityInside(entity)) {
                 return n[i].segment.getEntityTerrainPoint(entity, res);