@openglobus/og 0.14.10 → 0.15.0

package/src/og/shaders/drawnode.js

@@ -5,6 +5,8 @@
 "use strict";
 
 import { Program } from "../webgl/Program.js";
+import * as atmos from "./atmos.js";
+import { UTILS } from './utils.js';
 
 // REMEMBER!
 // src*(1)+dest*(1-src.alpha)
@@ -45,11 +47,8 @@ export function drawnode_screen_nl() {
             samplerArr: "sampler2darray",
             defaultTexture: "sampler2d",
             height: "float"
-        },
-        attributes: {
-            aVertexPositionHigh: "vec3",
-            aVertexPositionLow: "vec3",
-            aTextureCoord: "vec2"
+        }, attributes: {
+            aVertexPositionHigh: "vec3", aVertexPositionLow: "vec3", aTextureCoord: "vec2"
         },
 
         vertexShader: `attribute vec3 aVertexPositionHigh;
@@ -111,7 +110,7 @@ export function drawnode_screen_nl() {
     });
 }
 
-export function drawnode_screen_wl() {
+export function drawnode_screen_wl_webgl1NoAtmos() {
     return new Program("drawnode_screen_wl", {
         uniforms: {
             projectionMatrix: "mat4",
@@ -128,22 +127,25 @@ export function drawnode_screen_wl() {
             layerOpacityArr: "float",
             samplerArr: "sampler2darray",
             defaultTexture: "sampler2d",
-            normalMatrix: "mat3",
             uNormalMap: "sampler2d",
             nightTexture: "sampler2d",
             specularTexture: "sampler2d",
-            lightsPositions: "vec4",
+            lightsPositions: "vec3",
             diffuse: "vec3",
             ambient: "vec3",
-            specular: "vec4"
-        },
-        attributes: {
+            specular: "vec4",
+
+            camHeight: "float",
+            nightTextureCoefficient: "float"
+        }, attributes: {
             aVertexPositionHigh: "vec3",
             aVertexPositionLow: "vec3",
             aTextureCoord: "vec2"
         },
 
-        vertexShader: `attribute vec3 aVertexPositionHigh;
+        vertexShader:
+            `
+            attribute vec3 aVertexPositionHigh;
             attribute vec3 aVertexPositionLow;
             attribute vec2 aTextureCoord;
 
@@ -157,12 +159,16 @@ export function drawnode_screen_wl() {
 
             varying vec4 vTextureCoord;
             varying vec2 vGlobalTextureCoord;
-            varying vec4 v_vertex;
-            varying float v_height;           
+            varying vec3 v_vertex;
+            varying float v_height;
+            varying vec3 cameraPosition;
 
             void main(void) {
 
                 vec3 aVertexPosition = aVertexPositionHigh + aVertexPositionLow;
+                
+                cameraPosition = eyePositionHigh + eyePositionLow;
+                
                 vec3 highDiff = aVertexPositionHigh - eyePositionHigh;
                 vec3 lowDiff = aVertexPositionLow + normalize(aVertexPosition) * height - eyePositionLow;
 
@@ -170,26 +176,28 @@ export function drawnode_screen_wl() {
                 viewMatrixRTE[3] = vec4(0.0, 0.0, 0.0, 1.0);
 
                 v_height = height;
-                vec3 heightVertex = aVertexPosition + normalize(aVertexPosition) * height;
-                v_vertex = viewMatrix * vec4(heightVertex, 1.0);
+                v_vertex = aVertexPosition + normalize(aVertexPosition) * height;
+                                
                 vTextureCoord.xy = aTextureCoord;
                 vGlobalTextureCoord = uGlobalTextureCoord.xy + (uGlobalTextureCoord.zw - uGlobalTextureCoord.xy) * aTextureCoord;
                 vTextureCoord.zw = uNormalMapBias.z * ( aTextureCoord + uNormalMapBias.xy );
+                
                 gl_Position = projectionMatrix * viewMatrixRTE * vec4(highDiff + lowDiff, 1.0);
             }`,
 
-        fragmentShader: `precision highp float;
-
+        fragmentShader:
+            `
+            precision highp float;
+            
             #define MAX_POINT_LIGHTS 1
             #define SLICE_SIZE ${SLICE_SIZE + 1}
 
             uniform vec3 diffuse;
             uniform vec3 ambient;
-            uniform vec4 specular;
+            uniform vec4 specular;     
 
             uniform sampler2D uNormalMap;
-            uniform vec4 lightsPositions[MAX_POINT_LIGHTS];
-            uniform mat3 normalMatrix;
+            uniform vec3 lightsPositions[MAX_POINT_LIGHTS];
             uniform sampler2D nightTexture;
             uniform sampler2D specularTexture;
 
@@ -199,77 +207,94 @@ export function drawnode_screen_wl() {
             uniform sampler2D defaultTexture;
             uniform sampler2D samplerArr[SLICE_SIZE];
             uniform int samplerCount;
+            uniform float nightTextureCoefficient;
+                
+            uniform float camHeight;
 
             varying vec4 vTextureCoord;
+            varying vec3 v_vertex;
+            varying vec3 cameraPosition;
             varying vec2 vGlobalTextureCoord;
-            varying vec4 v_vertex;
             varying float v_height;
 
+            vec3 sunPos;
+
             ${NIGHT}
 
             ${DEF_BLEND_WEBGL1}
-
-            float shininess;
-            float reflection;
-            float diffuseLightWeighting;
-            vec3 night;
-
+            
+            ${UTILS}
+                                               
             void main(void) {
             
+                sunPos = lightsPositions[0];
+                                
+                vec3 texNormal = texture2D(uNormalMap, vTextureCoord.zw).rgb;
+                vec3 normal = normalize((texNormal - 0.5) * 2.0);
+                
+                float minH = 1200000.0;
+                float maxH = minH * 3.0;
+                float nightCoef = getLerpValue(minH, maxH, camHeight) * nightTextureCoefficient;
+                                
+                if(camHeight > 6000000.0)
+                {
+                    normal = normalize(v_vertex);
+                }
+                                            
+                vec3 lightDir = normalize(sunPos);
+                vec3 viewDir = normalize(cameraPosition - v_vertex);
+                                                
                 float overGround = 1.0 - step(0.1, v_height);
-                vec3 normal = normalize(normalMatrix * ((texture2D(uNormalMap, vTextureCoord.zw).rgb - 0.5) * 2.0));
-                vec3 lightDirection = normalize(lightsPositions[0].xyz - v_vertex.xyz * lightsPositions[0].w);
-                vec3 eyeDirection = normalize(-v_vertex.xyz);
-                vec3 reflectionDirection = reflect(-lightDirection, normal);
-                vec4 nightImageColor = texture2D( nightTexture, vGlobalTextureCoord.st );
-                shininess = texture2D( specularTexture, vGlobalTextureCoord.st ).r * 255.0 * overGround;
-                reflection = max( dot(reflectionDirection, eyeDirection), 0.0);
-                diffuseLightWeighting = max(dot(normal, lightDirection), 0.0);
-                night = nightStep * (.18 - diffuseLightWeighting * 3.0) * nightImageColor.rgb;
-                night *= overGround * step(0.0, night);
-
-                vec3 spec = specular.rgb * pow( reflection, specular.w) * shininess;
-                vec4 lightWeighting = vec4(ambient + diffuse * diffuseLightWeighting + spec + night, 1.0);
 
+                float shininess = texture2D( specularTexture, vGlobalTextureCoord.st ).r * 255.0 * overGround;
+                vec3 reflectionDirection = reflect(-lightDir, normal);
+                float reflection = max( dot(reflectionDirection, viewDir), 0.0);
+                vec3 spec = specular.rgb * pow( reflection, specular.w) * shininess;                
+                float diffuseLightWeighting = max(dot(normal, lightDir), 0.0);                
+                vec4 nightImageColor = texture2D( nightTexture, vGlobalTextureCoord.st );
+                vec3 night = nightStep * (.18 - diffuseLightWeighting * 3.0) * nightImageColor.rgb * nightCoef;
+                night *= overGround * step(0.0, night);                
+                vec4 lightWeighting = vec4(ambient + diffuse * diffuseLightWeighting + night, 1.0);
+                
                 gl_FragColor = texture2D( defaultTexture, vTextureCoord.xy );
                 if( samplerCount == 0 ) {
-                    gl_FragColor *= lightWeighting;
+                    gl_FragColor = gl_FragColor * lightWeighting + vec4(spec, 0.0);
                     return;
                 }
-    
+
                 vec4 src;
 
                 blend(gl_FragColor, samplerArr[0], tileOffsetArr[0], layerOpacityArr[0]);
-                if( samplerCount == 1 ) {
-                    gl_FragColor *= lightWeighting;
+                if( samplerCount == 1 ) {                
+                    gl_FragColor = gl_FragColor * lightWeighting + vec4(spec, 0.0);
                     return;
                 }
 
                 blend(gl_FragColor, samplerArr[1], tileOffsetArr[1], layerOpacityArr[1]);
                 if( samplerCount == 2 ) {
-                    gl_FragColor *= lightWeighting;
+                    gl_FragColor = gl_FragColor * lightWeighting + vec4(spec, 0.0);
                     return;
                 }
 
                 blend(gl_FragColor, samplerArr[2], tileOffsetArr[2], layerOpacityArr[2]);
                 if( samplerCount == 3 ) {
-                    gl_FragColor *= lightWeighting;
+                    gl_FragColor = gl_FragColor * lightWeighting + vec4(spec, 0.0);
                     return;
                 }
 
                 blend(gl_FragColor, samplerArr[3], tileOffsetArr[3], layerOpacityArr[3]);
                 if( samplerCount == 4 ) {
-                    gl_FragColor *= lightWeighting;
+                    gl_FragColor = gl_FragColor * lightWeighting + vec4(spec, 0.0);
                     return;
                 }
 
                 blend(gl_FragColor, samplerArr[4], tileOffsetArr[4], layerOpacityArr[4]);
-                gl_FragColor *= lightWeighting;
+                gl_FragColor = gl_FragColor * lightWeighting + vec4(spec, 0.0);
             }`
     });
 }
 
-export function drawnode_screen_wl_webgl2() {
+export function drawnode_screen_wl_webgl2NoAtmos() {
     return new Program("drawnode_screen_wl", {
         uniforms: {
             projectionMatrix: "mat4",
@@ -286,22 +311,24 @@ export function drawnode_screen_wl_webgl2() {
             layerOpacityArr: "float",
             samplerArr: "sampler2darray",
             defaultTexture: "sampler2d",
-            normalMatrix: "mat3",
             uNormalMap: "sampler2d",
             nightTexture: "sampler2d",
             specularTexture: "sampler2d",
-            lightsPositions: "vec4",
+            lightsPositions: "vec3",
             diffuse: "vec3",
             ambient: "vec3",
-            specular: "vec4"
-        },
-        attributes: {
+            specular: "vec4",
+
+            camHeight: "float",
+            nightTextureCoefficient: "float"
+        }, attributes: {
             aVertexPositionHigh: "vec3",
             aVertexPositionLow: "vec3",
             aTextureCoord: "vec2"
         },
 
-        vertexShader: `#version 300 es
+        vertexShader:
+            `#version 300 es
 
             in vec3 aVertexPositionHigh;
             in vec3 aVertexPositionLow;
@@ -317,12 +344,16 @@ export function drawnode_screen_wl_webgl2() {
 
             out vec4 vTextureCoord;
             out vec2 vGlobalTextureCoord;
-            out vec4 v_vertex;
+            out vec3 v_vertex;
             out float v_height;
+            out vec3 cameraPosition;
 
             void main(void) {
 
                 vec3 aVertexPosition = aVertexPositionHigh + aVertexPositionLow;
+                
+                cameraPosition = eyePositionHigh + eyePositionLow;
+                
                 vec3 highDiff = aVertexPositionHigh - eyePositionHigh;
                 vec3 lowDiff = aVertexPositionLow + normalize(aVertexPosition) * height - eyePositionLow;
 
@@ -330,28 +361,29 @@ export function drawnode_screen_wl_webgl2() {
                 viewMatrixRTE[3] = vec4(0.0, 0.0, 0.0, 1.0);
 
                 v_height = height;
-                vec3 heightVertex = aVertexPosition + normalize(aVertexPosition) * height;
-                v_vertex = viewMatrix * vec4(heightVertex, 1.0);
+                v_vertex = aVertexPosition + normalize(aVertexPosition) * height;
+                                
                 vTextureCoord.xy = aTextureCoord;
                 vGlobalTextureCoord = uGlobalTextureCoord.xy + (uGlobalTextureCoord.zw - uGlobalTextureCoord.xy) * aTextureCoord;
                 vTextureCoord.zw = uNormalMapBias.z * ( aTextureCoord + uNormalMapBias.xy );
+                
                 gl_Position = projectionMatrix * viewMatrixRTE * vec4(highDiff + lowDiff, 1.0);
             }`,
 
-        fragmentShader: `#version 300 es
+        fragmentShader:
+            `#version 300 es
 
             precision highp float;
-
+            
             #define MAX_POINT_LIGHTS 1
             #define SLICE_SIZE ${SLICE_SIZE + 1}
 
             uniform vec3 diffuse;
             uniform vec3 ambient;
-            uniform vec4 specular;
+            uniform vec4 specular;     
 
             uniform sampler2D uNormalMap;
-            uniform vec4 lightsPositions[MAX_POINT_LIGHTS];
-            uniform mat3 normalMatrix;
+            uniform vec3 lightsPositions[MAX_POINT_LIGHTS];
             uniform sampler2D nightTexture;
             uniform sampler2D specularTexture;
 
@@ -361,75 +393,416 @@ export function drawnode_screen_wl_webgl2() {
             uniform sampler2D defaultTexture;
             uniform sampler2D samplerArr[SLICE_SIZE];
             uniform int samplerCount;
+            uniform float nightTextureCoefficient;
+                
+            uniform float camHeight;
 
             in vec4 vTextureCoord;
+            in vec3 v_vertex;
+            in vec3 cameraPosition;
             in vec2 vGlobalTextureCoord;
-            in vec4 v_vertex;
             in float v_height;
 
-            float shininess;
-            float reflection;
-            float diffuseLightWeighting;
-            vec3 night;
+            vec3 sunPos;
 
-            layout(location = 0) out vec4 fragColor;
+            layout(location = 0) out vec4 diffuseColor;
 
             ${NIGHT}
 
             ${DEF_BLEND}
-
+            
+            ${UTILS}
+                                               
             void main(void) {
-
+            
+                sunPos = lightsPositions[0];
+                                
+                vec3 texNormal = texture(uNormalMap, vTextureCoord.zw).rgb;
+                vec3 normal = normalize((texNormal - 0.5) * 2.0);
+                
+                float minH = 1200000.0;
+                float maxH = minH * 3.0;
+                float nightCoef = getLerpValue(minH, maxH, camHeight) * nightTextureCoefficient;
+                                
+                if(camHeight > 6000000.0)
+                {
+                    normal = normalize(v_vertex);
+                }
+                                            
+                vec3 lightDir = normalize(sunPos);
+                vec3 viewDir = normalize(cameraPosition - v_vertex);
+                                                
                 float overGround = 1.0 - step(0.1, v_height);
-                vec3 normal = normalize(normalMatrix * ((texture(uNormalMap, vTextureCoord.zw).rgb - 0.5) * 2.0));
-                vec3 lightDirection = normalize(lightsPositions[0].xyz - v_vertex.xyz * lightsPositions[0].w);
-                vec3 eyeDirection = normalize(-v_vertex.xyz);
-                vec3 reflectionDirection = reflect(-lightDirection, normal);
+
+                float shininess = texture( specularTexture, vGlobalTextureCoord.st ).r * 255.0 * overGround;
+                vec3 reflectionDirection = reflect(-lightDir, normal);
+                float reflection = max( dot(reflectionDirection, viewDir), 0.0);
+                vec3 spec = specular.rgb * pow( reflection, specular.w) * shininess;                
+                float diffuseLightWeighting = max(dot(normal, lightDir), 0.0);                
                 vec4 nightImageColor = texture( nightTexture, vGlobalTextureCoord.st );
+                vec3 night = nightStep * (.18 - diffuseLightWeighting * 3.0) * nightImageColor.rgb * nightCoef;
+                night *= overGround * step(0.0, night);                
+                vec4 lightWeighting = vec4(ambient + diffuse * diffuseLightWeighting + night, 1.0);
+                
+                diffuseColor = texture( defaultTexture, vTextureCoord.xy );
+                if( samplerCount == 0 ) {
+                    diffuseColor = diffuseColor * lightWeighting + vec4(spec, 0.0);
+                    return;
+                }
 
-                shininess = texture( specularTexture, vGlobalTextureCoord.st ).r * 255.0 * overGround;
-                reflection = max( dot(reflectionDirection, eyeDirection), 0.0);
-                diffuseLightWeighting = max(dot(normal, lightDirection), 0.0);
-                night = nightStep * (.18 - diffuseLightWeighting * 3.0) * nightImageColor.rgb;
-                night *= overGround * step(0.0, night);
+                vec4 src;
 
-                vec3 spec = specular.rgb * pow( reflection, specular.w) * shininess;
-                vec4 lightWeighting = vec4(ambient + diffuse * diffuseLightWeighting + spec + night, 1.0);
+                blend(diffuseColor, samplerArr[0], tileOffsetArr[0], layerOpacityArr[0]);
+                if( samplerCount == 1 ) {                
+                    diffuseColor = diffuseColor * lightWeighting + vec4(spec, 0.0);
+                    return;
+                }
 
-                fragColor = texture( defaultTexture, vTextureCoord.xy );
+                blend(diffuseColor, samplerArr[1], tileOffsetArr[1], layerOpacityArr[1]);
+                if( samplerCount == 2 ) {
+                    diffuseColor = diffuseColor * lightWeighting + vec4(spec, 0.0);
+                    return;
+                }
+
+                blend(diffuseColor, samplerArr[2], tileOffsetArr[2], layerOpacityArr[2]);
+                if( samplerCount == 3 ) {
+                    diffuseColor = diffuseColor * lightWeighting + vec4(spec, 0.0);
+                    return;
+                }
+
+                blend(diffuseColor, samplerArr[3], tileOffsetArr[3], layerOpacityArr[3]);
+                if( samplerCount == 4 ) {
+                    diffuseColor = diffuseColor * lightWeighting + vec4(spec, 0.0);
+                    return;
+                }
+
+                blend(diffuseColor, samplerArr[4], tileOffsetArr[4], layerOpacityArr[4]);
+                diffuseColor = diffuseColor * lightWeighting + vec4(spec, 0.0);
+            }`
+    });
+}
+
+
+export function drawnode_screen_wl_webgl2Atmos() {
+    return new Program("drawnode_screen_wl", {
+        uniforms: {
+            projectionMatrix: "mat4",
+            viewMatrix: "mat4",
+            eyePositionHigh: "vec3",
+            eyePositionLow: "vec3",
+            height: "float",
+
+            uGlobalTextureCoord: "vec4",
+            uNormalMapBias: "vec3",
+
+            samplerCount: "int",
+            tileOffsetArr: "vec4",
+            layerOpacityArr: "float",
+            samplerArr: "sampler2darray",
+            defaultTexture: "sampler2d",
+            uNormalMap: "sampler2d",
+            nightTexture: "sampler2d",
+            specularTexture: "sampler2d",
+            lightsPositions: "vec3",
+            diffuse: "vec3",
+            ambient: "vec3",
+            specular: "vec4",
+
+            transmittanceTexture: "sampler2D",
+            scatteringTexture: "sampler2D",
+            camHeight: "float",
+            nightTextureCoefficient: "float",
+            maxMinOpacity: "vec2"
+        }, attributes: {
+            aVertexPositionHigh: "vec3",
+            aVertexPositionLow: "vec3",
+            aTextureCoord: "vec2"
+        },
+
+        vertexShader:
+            `#version 300 es
+
+            in vec3 aVertexPositionHigh;
+            in vec3 aVertexPositionLow;
+            in vec2 aTextureCoord;
+
+            uniform mat4 projectionMatrix;
+            uniform mat4 viewMatrix;
+            uniform vec4 uGlobalTextureCoord;
+            uniform vec3 uNormalMapBias;
+            uniform vec3 eyePositionHigh;
+            uniform vec3 eyePositionLow;
+            uniform float height;
+
+            out vec4 vTextureCoord;
+            out vec2 vGlobalTextureCoord;
+            out vec3 v_vertex;
+            out float v_height;
+            out vec3 cameraPosition;
+
+            void main(void) {
+
+                vec3 aVertexPosition = aVertexPositionHigh + aVertexPositionLow;
+                
+                cameraPosition = eyePositionHigh + eyePositionLow;
+                
+                vec3 highDiff = aVertexPositionHigh - eyePositionHigh;
+                vec3 lowDiff = aVertexPositionLow + normalize(aVertexPosition) * height - eyePositionLow;
+
+                mat4 viewMatrixRTE = viewMatrix;
+                viewMatrixRTE[3] = vec4(0.0, 0.0, 0.0, 1.0);
+
+                v_height = height;
+                v_vertex = aVertexPosition + normalize(aVertexPosition) * height;
+                                
+                vTextureCoord.xy = aTextureCoord;
+                vGlobalTextureCoord = uGlobalTextureCoord.xy + (uGlobalTextureCoord.zw - uGlobalTextureCoord.xy) * aTextureCoord;
+                vTextureCoord.zw = uNormalMapBias.z * ( aTextureCoord + uNormalMapBias.xy );
+                
+                gl_Position = projectionMatrix * viewMatrixRTE * vec4(highDiff + lowDiff, 1.0);
+            }`,
+
+        fragmentShader:
+            `#version 300 es
+
+            precision highp float;
+            
+            #define MAX_POINT_LIGHTS 1
+            #define SLICE_SIZE ${SLICE_SIZE + 1}
+
+            uniform vec3 diffuse;
+            uniform vec3 ambient;
+            uniform vec4 specular;
+
+            uniform sampler2D uNormalMap;
+            uniform vec3 lightsPositions[MAX_POINT_LIGHTS];
+            uniform sampler2D nightTexture;
+            uniform sampler2D specularTexture;
+
+            uniform sampler2D transmittanceTexture;
+            uniform sampler2D scatteringTexture;
+
+            uniform vec4 tileOffsetArr[SLICE_SIZE];
+            uniform float layerOpacityArr[SLICE_SIZE];
+
+            uniform sampler2D defaultTexture;
+            uniform sampler2D samplerArr[SLICE_SIZE];
+            uniform int samplerCount;
+            uniform float nightTextureCoefficient;
+            
+            uniform vec2 maxMinOpacity;
+                
+            uniform float camHeight;
+
+            in vec4 vTextureCoord;
+            in vec3 v_vertex;
+            in vec3 cameraPosition;
+            in vec2 vGlobalTextureCoord;
+            in float v_height;
+
+            vec3 sunPos;
+
+            layout(location = 0) out vec4 diffuseColor;
+
+            ${NIGHT}
+
+            ${DEF_BLEND}
+            
+            ${atmos.COMMON}            
+            
+            vec3 transmittanceFromTexture(float height, float angle) 
+            {
+                float u = (angle + 1.0) * 0.5;
+                float v = height / ATMOS_HEIGHT;
+                return texture(transmittanceTexture, vec2(u, v)).xyz;
+            }
+
+            vec3 multipleScatteringContributionFromTexture(float height, float angle) 
+            {
+                float u = (angle + 1.0) * 0.5;
+                float v = height / ATMOS_HEIGHT;
+                return texture(scatteringTexture, vec2(u, v)).xyz;
+            }
+            
+            void getSunIlluminance(in vec3 point, in vec3 lightDir, out vec3 sunIlluminance)
+            {
+                //     float r = length(point);
+                //     float mu_s = dot(point, sun_direction) / r;
+                //     float height = r - BOTTOM_RADIUS;
+                
+                float mu_s = dot(normalize(point), lightDir);
+                float height = length(point) - BOTTOM_RADIUS;
+                sunIlluminance = SUN_INTENSITY * transmittanceFromTexture(height, mu_s);
+            }
+           
+            void atmosGroundColor(out vec4 fragColor, in vec3 normal)
+            {                                                                                                                                
+                vec3 rayDirection = normalize(v_vertex - cameraPosition);
+                vec3 lightDir = normalize(sunPos);
+                
+                rayDirection = normalize(rayDirection * SPHERE_TO_ELLIPSOID_SCALE);
+                vec3 camPos = cameraPosition * SPHERE_TO_ELLIPSOID_SCALE;
+                lightDir = normalize(lightDir * SPHERE_TO_ELLIPSOID_SCALE);
+            
+                vec3 light = vec3(0.0);
+                vec3 transmittanceFromCameraToSpace = vec3(1.0);
+                float offset = 0.0;
+                float distanceToSpace = 0.0;
+                
+                intersectSphere(camPos, rayDirection, TOP_RADIUS, offset, distanceToSpace);
+            
+                vec3 rayOrigin = camPos;
+                
+                // above atmosphere
+                if (offset > 0.0) 
+                {
+                    // intersection of camera ray with atmosphere
+                    rayOrigin += rayDirection * offset;
+                }
+                
+                float height = length(rayOrigin) - BOTTOM_RADIUS;
+                float rayAngle = dot(rayOrigin, rayDirection) / length(rayOrigin);
+                bool cameraBelow = rayAngle < 0.0;
+                
+                transmittanceFromCameraToSpace = transmittanceFromTexture(height, cameraBelow ? -rayAngle : rayAngle);
+                
+                float phaseAngle = dot(lightDir, rayDirection);
+                float rayleighPhase = rayleighPhase(phaseAngle);
+                float miePhase = miePhase(phaseAngle);
+                
+                float distanceToGround = 0.0;
+                
+                bool hitGround = intersectSphere(camPos, rayDirection, BOTTOM_RADIUS, distanceToGround) && distanceToGround > 0.0;                
+                
+                // Fix black dots on the edge of atmosphere                        
+                if(camHeight < 700000.0 || !hitGround)
+                {                          
+                    distanceToGround = distance(camPos, v_vertex * SPHERE_TO_ELLIPSOID_SCALE);
+                }
+                                                                
+                float segmentLength = (distanceToGround - max(offset, 0.0)) / float(SAMPLE_COUNT);
+                
+                float t = segmentLength * 0.5;
+                
+                vec3 transmittanceCamera; 
+                vec3 transmittanceLight; 
+                
+                for (int i = 0; i < SAMPLE_COUNT; i++) 
+                {
+                    vec3 position = rayOrigin + t * rayDirection;
+                    float height = length(position) - BOTTOM_RADIUS;
+                    vec3 up = position / length(position);
+                    float rayAngle = dot(up, rayDirection);
+                    float lightAngle = dot(up, lightDir);                                                 
+                    vec3 transmittanceToSpace = transmittanceFromTexture(height, cameraBelow ? -rayAngle : rayAngle);
+                    transmittanceCamera = cameraBelow ? (transmittanceToSpace / transmittanceFromCameraToSpace) : (transmittanceFromCameraToSpace / transmittanceToSpace);
+                    transmittanceLight = transmittanceFromTexture(height, lightAngle);
+                    vec2 opticalDensity = exp(-height / rayleighMieHeights);
+                    vec3 scatteredLight = transmittanceLight * (rayleighScatteringCoefficient * opticalDensity.x * rayleighPhase + mieScatteringCoefficient * opticalDensity.y * miePhase);
+                    scatteredLight += multipleScatteringContributionFromTexture(height, lightAngle) * (rayleighScatteringCoefficient * opticalDensity.x + mieScatteringCoefficient * opticalDensity.y);  
+                    light += transmittanceCamera * scatteredLight * segmentLength;
+                    t += segmentLength;
+                }
+                
+                light *= SUN_INTENSITY;
+        
+                vec3 hitPoint = camPos + rayDirection * distanceToGround;
+                vec3 up = normalize(hitPoint);
+                float diffuseAngle = max(dot(up, lightDir), 0.0);                
+                                
+                float lightAngle = dot(normal, lightDir);
+                vec3 tA = transmittanceCamera * GROUND_ALBEDO * SUN_INTENSITY;                                               
+                vec3 scatteringLight = multipleScatteringContributionFromTexture(height, lightAngle);
+                vec3 diffuseTransmittanceLight = transmittanceLight * diffuseAngle;                
+                light += tA * (scatteringLight + diffuseTransmittanceLight);
+                                                                
+                fragColor = vec4(pow(light * 8.0, vec3(1.0 / 2.2)), 1.0);
+            }
+
+            void getAtmosFadingOpacity(out float opacity)
+            {            
+                float c = length(cameraPosition);
+                float maxDist = sqrt(c * c - BOTTOM_RADIUS * BOTTOM_RADIUS);
+                float minDist = c - BOTTOM_RADIUS;
+                float vertDist = distance(cameraPosition, v_vertex);                    
+                opacity = maxMinOpacity.y + ( maxMinOpacity.x -  maxMinOpacity.y) * getLerpValue(minDist, maxDist, vertDist);
+            }
+
+            void main(void) {
+            
+                sunPos = lightsPositions[0];
+                                
+                vec3 texNormal = texture(uNormalMap, vTextureCoord.zw).rgb;
+                vec3 normal = normalize((texNormal - 0.5) * 2.0);
+                
+                float minH = 1200000.0;
+                float maxH = minH * 3.0;
+                float nightCoef = getLerpValue(minH, maxH, camHeight) * nightTextureCoefficient;
+                                
+                if(camHeight > 6000000.0)
+                {
+                    normal = normalize(v_vertex);
+                }
+                                            
+                vec3 lightDir = normalize(sunPos);
+                vec3 viewDir = normalize(cameraPosition - v_vertex);
+                
+                vec4 atmosColor;
+                atmosGroundColor(atmosColor, normal);
+                
+                vec3 sunIlluminance;                
+                getSunIlluminance(v_vertex * SPHERE_TO_ELLIPSOID_SCALE, lightDir * SPHERE_TO_ELLIPSOID_SCALE, sunIlluminance);
+                
+                float overGround = 1.0 - step(0.1, v_height);
+
+                float shininess = texture( specularTexture, vGlobalTextureCoord.st ).r * 255.0 * overGround;
+                vec3 reflectionDirection = reflect(-lightDir, normal);
+                float reflection = max( dot(reflectionDirection, viewDir), 0.0);
+                vec3 spec = sunIlluminance * specular.rgb * pow( reflection, specular.w) * shininess;                
+                float diffuseLightWeighting = max(dot(normal, lightDir), 0.0);
+                              
+                vec4 nightImageColor = texture( nightTexture, vGlobalTextureCoord.st );
+                vec3 night = nightStep * (.18 - diffuseLightWeighting * 3.0) * nightImageColor.rgb * nightCoef;
+                night *= overGround * step(0.0, night);                
+                vec4 lightWeighting = vec4(ambient + sunIlluminance * diffuse * diffuseLightWeighting + night, 1.0);
+                
+                float fadingOpacity;
+                getAtmosFadingOpacity(fadingOpacity);
+
+                diffuseColor = texture( defaultTexture, vTextureCoord.xy );
                 if( samplerCount == 0 ) {
-                    fragColor *= lightWeighting;
+                    diffuseColor = mix(diffuseColor * lightWeighting, atmosColor, fadingOpacity) + vec4(spec, 0.0);
                     return;
                 }
 
                 vec4 src;
 
-                blend(fragColor, samplerArr[0], tileOffsetArr[0], layerOpacityArr[0]);
-                if( samplerCount == 1 ) {
-                    fragColor *= lightWeighting;
+                blend(diffuseColor, samplerArr[0], tileOffsetArr[0], layerOpacityArr[0]);
+                if( samplerCount == 1 ) {                
+                    diffuseColor = mix(diffuseColor * lightWeighting, atmosColor, fadingOpacity) + vec4(spec, 0.0);
                     return;
                 }
 
-                blend(fragColor, samplerArr[1], tileOffsetArr[1], layerOpacityArr[1]);
+                blend(diffuseColor, samplerArr[1], tileOffsetArr[1], layerOpacityArr[1]);
                 if( samplerCount == 2 ) {
-                    fragColor *= lightWeighting;
+                    diffuseColor = mix(diffuseColor * lightWeighting, atmosColor, fadingOpacity) + vec4(spec, 0.0);
                     return;
                 }
 
-                blend(fragColor, samplerArr[2], tileOffsetArr[2], layerOpacityArr[2]);
+                blend(diffuseColor, samplerArr[2], tileOffsetArr[2], layerOpacityArr[2]);
                 if( samplerCount == 3 ) {
-                    fragColor *= lightWeighting;
+                    diffuseColor = mix(diffuseColor * lightWeighting, atmosColor, fadingOpacity) + vec4(spec, 0.0);
                     return;
                 }
 
-                blend(fragColor, samplerArr[3], tileOffsetArr[3], layerOpacityArr[3]);
+                blend(diffuseColor, samplerArr[3], tileOffsetArr[3], layerOpacityArr[3]);
                 if( samplerCount == 4 ) {
-                    fragColor *= lightWeighting;
+                    diffuseColor = mix(diffuseColor * lightWeighting, atmosColor, fadingOpacity) + vec4(spec, 0.0);
                     return;
                 }
 
-                blend(fragColor, samplerArr[4], tileOffsetArr[4], layerOpacityArr[4]);
-                fragColor *= lightWeighting;
+                blend(diffuseColor, samplerArr[4], tileOffsetArr[4], layerOpacityArr[4]);
+                diffuseColor = mix(diffuseColor * lightWeighting, atmosColor, fadingOpacity) + vec4(spec, 0.0);
             }`
     });
 }
@@ -447,11 +820,8 @@ export function drawnode_colorPicking() {
             pickingMaskArr: "sampler2darray",
             pickingColorArr: "vec4",
             height: "float"
-        },
-        attributes: {
-            aVertexPositionHigh: "vec3",
-            aVertexPositionLow: "vec3",
-            aTextureCoord: "vec2"
+        }, attributes: {
+            aVertexPositionHigh: "vec3", aVertexPositionLow: "vec3", aTextureCoord: "vec2"
         },
 
         vertexShader: `attribute vec3 aVertexPositionHigh;
@@ -523,10 +893,8 @@ export function drawnode_heightPicking() {
             height: "float",
             eyePositionHigh: "vec3",
             eyePositionLow: "vec3"
-        },
-        attributes: {
-            aVertexPositionHigh: "vec3",
-            aVertexPositionLow: "vec3"
+        }, attributes: {
+            aVertexPositionHigh: "vec3", aVertexPositionLow: "vec3"
         },
 
         vertexShader: `attribute vec3 aVertexPositionHigh;
@@ -586,10 +954,8 @@ export function drawnode_depth() {
             eyePositionHigh: "vec3",
             eyePositionLow: "vec3",
             frustumPickingColor: "vec3"
-        },
-        attributes: {
-            aVertexPositionHigh: "vec3",
-            aVertexPositionLow: "vec3"
+        }, attributes: {
+            aVertexPositionHigh: "vec3", aVertexPositionLow: "vec3"
         },
 
         vertexShader: `attribute vec3 aVertexPositionHigh;