@cesium/engine 6.1.1 → 7.0.0

package/Source/Shaders/Builtin/Functions/computeScattering.js

@@ -0,0 +1,152 @@
+//This file is automatically rebuilt by the Cesium build process.
+export default "/**\n\
+ * This function computes the colors contributed by Rayliegh and Mie scattering on a given ray, as well as\n\
+ * the transmittance value for the ray. This function uses automatic uniforms\n\
+ * so the atmosphere settings are always synced with the current scene.\n\
+ *\n\
+ * @name czm_computeScattering\n\
+ * @glslfunction\n\
+ *\n\
+ * @param {czm_ray} primaryRay The ray from the camera to the position.\n\
+ * @param {float} primaryRayLength The length of the primary ray.\n\
+ * @param {vec3} lightDirection The direction of the light to calculate the scattering from.\n\
+ * @param {vec3} rayleighColor The variable the Rayleigh scattering will be written to.\n\
+ * @param {vec3} mieColor The variable the Mie scattering will be written to.\n\
+ * @param {float} opacity The variable the transmittance will be written to.\n\
+ */\n\
+void czm_computeScattering(\n\
+    czm_ray primaryRay,\n\
+    float primaryRayLength,\n\
+    vec3 lightDirection,\n\
+    float atmosphereInnerRadius,\n\
+    out vec3 rayleighColor,\n\
+    out vec3 mieColor,\n\
+    out float opacity\n\
+) {\n\
+    const float ATMOSPHERE_THICKNESS = 111e3; // The thickness of the atmosphere in meters.\n\
+    const int PRIMARY_STEPS_MAX = 16; // Maximum number of times the ray from the camera to the world position (primary ray) is sampled.\n\
+    const int LIGHT_STEPS_MAX = 4; // Maximum number of times the light is sampled from the light source's intersection with the atmosphere to a sample position on the primary ray.\n\
+\n\
+    // Initialize the default scattering amounts to 0.\n\
+    rayleighColor = vec3(0.0);\n\
+    mieColor = vec3(0.0);\n\
+    opacity = 0.0;\n\
+\n\
+    float atmosphereOuterRadius = atmosphereInnerRadius + ATMOSPHERE_THICKNESS;\n\
+\n\
+    vec3 origin = vec3(0.0);\n\
+\n\
+    // Calculate intersection from the camera to the outer ring of the atmosphere.\n\
+    czm_raySegment primaryRayAtmosphereIntersect = czm_raySphereIntersectionInterval(primaryRay, origin, atmosphereOuterRadius);\n\
+\n\
+    // Return empty colors if no intersection with the atmosphere geometry.\n\
+    if (primaryRayAtmosphereIntersect == czm_emptyRaySegment) {\n\
+        rayleighColor = vec3(1.0, 0.0, 1.0);\n\
+        return;\n\
+    }\n\
+\n\
+    // To deal with smaller values of PRIMARY_STEPS (e.g. 4)\n\
+    // we implement a split strategy: sky or horizon.\n\
+    // For performance reasons, instead of a if/else branch\n\
+    // a soft choice is implemented through a weight 0.0 <= w_stop_gt_lprl <= 1.0\n\
+    float x = 1e-7 * primaryRayAtmosphereIntersect.stop / length(primaryRayLength);\n\
+    // Value close to 0.0: close to the horizon\n\
+    // Value close to 1.0: above in the sky\n\
+    float w_stop_gt_lprl = 0.5 * (1.0 + czm_approximateTanh(x));\n\
+\n\
+    // The ray should start from the first intersection with the outer atmopshere, or from the camera position, if it is inside the atmosphere.\n\
+    float start_0 = primaryRayAtmosphereIntersect.start;\n\
+    primaryRayAtmosphereIntersect.start = max(primaryRayAtmosphereIntersect.start, 0.0);\n\
+    // The ray should end at the exit from the atmosphere or at the distance to the vertex, whichever is smaller.\n\
+    primaryRayAtmosphereIntersect.stop = min(primaryRayAtmosphereIntersect.stop, length(primaryRayLength));\n\
+\n\
+    // For the number of ray steps, distinguish inside or outside atmosphere (outer space)\n\
+    // (1) from outer space we have to use more ray steps to get a realistic rendering\n\
+    // (2) within atmosphere we need fewer steps for faster rendering\n\
+    float x_o_a = start_0 - ATMOSPHERE_THICKNESS; // ATMOSPHERE_THICKNESS used as an ad-hoc constant, no precise meaning here, only the order of magnitude matters\n\
+    float w_inside_atmosphere = 1.0 - 0.5 * (1.0 + czm_approximateTanh(x_o_a));\n\
+    int PRIMARY_STEPS = PRIMARY_STEPS_MAX - int(w_inside_atmosphere * 12.0); // Number of times the ray from the camera to the world position (primary ray) is sampled.\n\
+    int LIGHT_STEPS = LIGHT_STEPS_MAX - int(w_inside_atmosphere * 2.0); // Number of times the light is sampled from the light source's intersection with the atmosphere to a sample position on the primary ray.\n\
+\n\
+    // Setup for sampling positions along the ray - starting from the intersection with the outer ring of the atmosphere.\n\
+    float rayPositionLength = primaryRayAtmosphereIntersect.start;\n\
+    // (1) Outside the atmosphere: constant rayStepLength\n\
+    // (2) Inside atmosphere: variable rayStepLength to compensate the rough rendering of the smaller number of ray steps\n\
+    float totalRayLength = primaryRayAtmosphereIntersect.stop - rayPositionLength;\n\
+    float rayStepLengthIncrease = w_inside_atmosphere * ((1.0 - w_stop_gt_lprl) * totalRayLength / (float(PRIMARY_STEPS * (PRIMARY_STEPS + 1)) / 2.0));\n\
+    float rayStepLength = max(1.0 - w_inside_atmosphere, w_stop_gt_lprl) * totalRayLength / max(7.0 * w_inside_atmosphere, float(PRIMARY_STEPS));\n\
+\n\
+    vec3 rayleighAccumulation = vec3(0.0);\n\
+    vec3 mieAccumulation = vec3(0.0);\n\
+    vec2 opticalDepth = vec2(0.0);\n\
+    vec2 heightScale = vec2(czm_atmosphereRayleighScaleHeight, czm_atmosphereMieScaleHeight);\n\
+\n\
+    // Sample positions on the primary ray.\n\
+    for (int i = 0; i < PRIMARY_STEPS_MAX; ++i) {\n\
+\n\
+        // The loop should be: for (int i = 0; i < PRIMARY_STEPS; ++i) {...} but WebGL1 cannot\n\
+        // loop with non-constant condition, so it has to break early instead\n\
+        if (i >= PRIMARY_STEPS) {\n\
+            break;\n\
+        }\n\
+\n\
+        // Calculate sample position along viewpoint ray.\n\
+        vec3 samplePosition = primaryRay.origin + primaryRay.direction * (rayPositionLength + rayStepLength);\n\
+\n\
+        // Calculate height of sample position above ellipsoid.\n\
+        float sampleHeight = length(samplePosition) - atmosphereInnerRadius;\n\
+\n\
+        // Calculate and accumulate density of particles at the sample position.\n\
+        vec2 sampleDensity = exp(-sampleHeight / heightScale) * rayStepLength;\n\
+        opticalDepth += sampleDensity;\n\
+\n\
+        // Generate ray from the sample position segment to the light source, up to the outer ring of the atmosphere.\n\
+        czm_ray lightRay = czm_ray(samplePosition, lightDirection);\n\
+        czm_raySegment lightRayAtmosphereIntersect = czm_raySphereIntersectionInterval(lightRay, origin, atmosphereOuterRadius);\n\
+\n\
+        float lightStepLength = lightRayAtmosphereIntersect.stop / float(LIGHT_STEPS);\n\
+        float lightPositionLength = 0.0;\n\
+\n\
+        vec2 lightOpticalDepth = vec2(0.0);\n\
+\n\
+        // Sample positions along the light ray, to accumulate incidence of light on the latest sample segment.\n\
+        for (int j = 0; j < LIGHT_STEPS_MAX; ++j) {\n\
+\n\
+            // The loop should be: for (int j = 0; i < LIGHT_STEPS; ++j) {...} but WebGL1 cannot\n\
+            // loop with non-constant condition, so it has to break early instead\n\
+            if (j >= LIGHT_STEPS) {\n\
+                break;\n\
+            }\n\
+\n\
+            // Calculate sample position along light ray.\n\
+            vec3 lightPosition = samplePosition + lightDirection * (lightPositionLength + lightStepLength * 0.5);\n\
+\n\
+            // Calculate height of the light sample position above ellipsoid.\n\
+            float lightHeight = length(lightPosition) - atmosphereInnerRadius;\n\
+\n\
+            // Calculate density of photons at the light sample position.\n\
+            lightOpticalDepth += exp(-lightHeight / heightScale) * lightStepLength;\n\
+\n\
+            // Increment distance on light ray.\n\
+            lightPositionLength += lightStepLength;\n\
+        }\n\
+\n\
+        // Compute attenuation via the primary ray and the light ray.\n\
+        vec3 attenuation = exp(-((czm_atmosphereMieCoefficient * (opticalDepth.y + lightOpticalDepth.y)) + (czm_atmosphereRayleighCoefficient * (opticalDepth.x + lightOpticalDepth.x))));\n\
+\n\
+        // Accumulate the scattering.\n\
+        rayleighAccumulation += sampleDensity.x * attenuation;\n\
+        mieAccumulation += sampleDensity.y * attenuation;\n\
+\n\
+        // Increment distance on primary ray.\n\
+        rayPositionLength += (rayStepLength += rayStepLengthIncrease);\n\
+    }\n\
+\n\
+    // Compute the scattering amount.\n\
+    rayleighColor = czm_atmosphereRayleighCoefficient * rayleighAccumulation;\n\
+    mieColor = czm_atmosphereMieCoefficient * mieAccumulation;\n\
+\n\
+    // Compute the transmittance i.e. how much light is passing through the atmosphere.\n\
+    opacity = length(exp(-((czm_atmosphereMieCoefficient * opticalDepth.y) + (czm_atmosphereRayleighCoefficient * opticalDepth.x))));\n\
+}\n\
+";

package/Source/Shaders/Builtin/Functions/getDynamicAtmosphereLightDirection.glsl

@@ -0,0 +1,22 @@
+/**
+ * Select which direction vector to use for dynamic atmosphere lighting based on an enum value
+ *
+ * @name czm_getDynamicAtmosphereLightDirection
+ * @glslfunction
+ * @see DynamicAtmosphereLightingType.js
+ *
+ * @param {vec3} positionWC the position of the vertex/fragment in world coordinates. This is normalized and returned when dynamic lighting is turned off.
+ * @param {float} lightEnum The enum value for selecting between light sources.
+ * @return {vec3} The normalized light direction vector. Depending on the enum value, it is either positionWC, czm_lightDirectionWC or czm_sunDirectionWC
+ */
+vec3 czm_getDynamicAtmosphereLightDirection(vec3 positionWC, float lightEnum) {
+    const float NONE = 0.0;
+    const float SCENE_LIGHT = 1.0;
+    const float SUNLIGHT = 2.0;
+
+    vec3 lightDirection =
+        positionWC * float(lightEnum == NONE) +
+        czm_lightDirectionWC * float(lightEnum == SCENE_LIGHT) +
+        czm_sunDirectionWC * float(lightEnum == SUNLIGHT);
+    return normalize(lightDirection);
+}

package/Source/Shaders/Builtin/Functions/getDynamicAtmosphereLightDirection.js

@@ -0,0 +1,24 @@
+//This file is automatically rebuilt by the Cesium build process.
+export default "/**\n\
+ * Select which direction vector to use for dynamic atmosphere lighting based on an enum value\n\
+ *\n\
+ * @name czm_getDynamicAtmosphereLightDirection\n\
+ * @glslfunction\n\
+ * @see DynamicAtmosphereLightingType.js\n\
+ *\n\
+ * @param {vec3} positionWC the position of the vertex/fragment in world coordinates. This is normalized and returned when dynamic lighting is turned off.\n\
+ * @param {float} lightEnum The enum value for selecting between light sources.\n\
+ * @return {vec3} The normalized light direction vector. Depending on the enum value, it is either positionWC, czm_lightDirectionWC or czm_sunDirectionWC\n\
+ */\n\
+vec3 czm_getDynamicAtmosphereLightDirection(vec3 positionWC, float lightEnum) {\n\
+    const float NONE = 0.0;\n\
+    const float SCENE_LIGHT = 1.0;\n\
+    const float SUNLIGHT = 2.0;\n\
+\n\
+    vec3 lightDirection =\n\
+        positionWC * float(lightEnum == NONE) +\n\
+        czm_lightDirectionWC * float(lightEnum == SCENE_LIGHT) +\n\
+        czm_sunDirectionWC * float(lightEnum == SUNLIGHT);\n\
+    return normalize(lightDirection);\n\
+}\n\
+";

package/Source/Shaders/Builtin/Functions/translateRelativeToEye.glsl

@@ -34,6 +34,11 @@
 vec4 czm_translateRelativeToEye(vec3 high, vec3 low)
 {
     vec3 highDifference = high - czm_encodedCameraPositionMCHigh;
+    // This check handles the case when NaN values have gotten into `highDifference`.
+    // Such a thing could happen on devices running iOS.
+    if (length(highDifference) == 0.0) {  
+        highDifference = vec3(0);  
+    }
     vec3 lowDifference = low - czm_encodedCameraPositionMCLow;
 
     return vec4(highDifference + lowDifference, 1.0);

package/Source/Shaders/Builtin/Functions/translateRelativeToEye.js

@@ -35,6 +35,11 @@ export default "/**\n\
 vec4 czm_translateRelativeToEye(vec3 high, vec3 low)\n\
 {\n\
     vec3 highDifference = high - czm_encodedCameraPositionMCHigh;\n\
+    // This check handles the case when NaN values have gotten into `highDifference`.\n\
+    // Such a thing could happen on devices running iOS.\n\
+    if (length(highDifference) == 0.0) {  \n\
+        highDifference = vec3(0);  \n\
+    }\n\
     vec3 lowDifference = low - czm_encodedCameraPositionMCLow;\n\
 \n\
     return vec4(highDifference + lowDifference, 1.0);\n\

package/Source/Shaders/GlobeFS.glsl

@@ -268,20 +268,6 @@ vec4 sampleAndBlend(
     return vec4(outColor, max(outAlpha, 0.0));
 }
 
-vec3 colorCorrect(vec3 rgb) {
-#ifdef COLOR_CORRECT
-    // Convert rgb color to hsb
-    vec3 hsb = czm_RGBToHSB(rgb);
-    // Perform hsb shift
-    hsb.x += u_hsbShift.x; // hue
-    hsb.y = clamp(hsb.y + u_hsbShift.y, 0.0, 1.0); // saturation
-    hsb.z = hsb.z > czm_epsilon7 ? hsb.z + u_hsbShift.z : 0.0; // brightness
-    // Convert shifted hsb back to rgb
-    rgb = czm_HSBToRGB(hsb);
-#endif
-    return rgb;
-}
-
 vec4 computeDayColor(vec4 initialColor, vec3 textureCoordinates, float nightBlend);
 vec4 computeWaterColor(vec3 positionEyeCoordinates, vec2 textureCoordinates, mat3 enuToEye, vec4 imageryColor, float specularMapValue, float fade);
 
@@ -396,7 +382,7 @@ void main()
     materialInput.st = v_textureCoordinates.st;
     materialInput.normalEC = normalize(v_normalEC);
     materialInput.positionToEyeEC = -v_positionEC;
-    materialInput.tangentToEyeMatrix = czm_eastNorthUpToEyeCoordinates(v_positionMC, normalize(v_normalEC));     
+    materialInput.tangentToEyeMatrix = czm_eastNorthUpToEyeCoordinates(v_positionMC, normalize(v_normalEC));
     materialInput.slope = v_slope;
     materialInput.height = v_height;
     materialInput.aspect = v_aspect;
@@ -442,7 +428,7 @@ void main()
     {
         bool dynamicLighting = false;
         #if defined(DYNAMIC_ATMOSPHERE_LIGHTING) && (defined(ENABLE_DAYNIGHT_SHADING) || defined(ENABLE_VERTEX_LIGHTING))
-            dynamicLighting = true;     
+            dynamicLighting = true;
         #endif
 
         vec3 rayleighColor;
@@ -472,30 +458,35 @@ void main()
             opacity = v_atmosphereOpacity;
         #endif
 
-        rayleighColor = colorCorrect(rayleighColor);
-        mieColor = colorCorrect(mieColor);
+        #ifdef COLOR_CORRECT
+            const bool ignoreBlackPixels = true;
+            rayleighColor = czm_applyHSBShift(rayleighColor, u_hsbShift, ignoreBlackPixels);
+            mieColor = czm_applyHSBShift(mieColor, u_hsbShift, ignoreBlackPixels);
+        #endif
 
         vec4 groundAtmosphereColor = computeAtmosphereColor(positionWC, lightDirection, rayleighColor, mieColor, opacity);
 
         // Fog is applied to tiles selected for fog, close to the Earth.
         #ifdef FOG
             vec3 fogColor = groundAtmosphereColor.rgb;
-            
+
             // If there is lighting, apply that to the fog.
             #if defined(DYNAMIC_ATMOSPHERE_LIGHTING) && (defined(ENABLE_VERTEX_LIGHTING) || defined(ENABLE_DAYNIGHT_SHADING))
                 float darken = clamp(dot(normalize(czm_viewerPositionWC), atmosphereLightDirection), u_minimumBrightness, 1.0);
-                fogColor *= darken;                
+                fogColor *= darken;
             #endif
 
             #ifndef HDR
                 fogColor.rgb = czm_acesTonemapping(fogColor.rgb);
                 fogColor.rgb = czm_inverseGamma(fogColor.rgb);
             #endif
-            
+
             const float modifier = 0.15;
             finalColor = vec4(czm_fog(v_distance, finalColor.rgb, fogColor.rgb, modifier), finalColor.a);
 
         #else
+            // Apply ground atmosphere. This happens when the camera is far away from the earth.
+
             // The transmittance is based on optical depth i.e. the length of segment of the ray inside the atmosphere.
             // This value is larger near the "circumference", as it is further away from the camera. We use it to
             // brighten up that area of the ground atmosphere.
@@ -507,20 +498,20 @@ void main()
             #if defined(DYNAMIC_ATMOSPHERE_LIGHTING) && (defined(ENABLE_VERTEX_LIGHTING) || defined(ENABLE_DAYNIGHT_SHADING))
                 float fadeInDist = u_nightFadeDistance.x;
                 float fadeOutDist = u_nightFadeDistance.y;
-            
+
                 float sunlitAtmosphereIntensity = clamp((cameraDist - fadeOutDist) / (fadeInDist - fadeOutDist), 0.05, 1.0);
                 float darken = clamp(dot(normalize(positionWC), atmosphereLightDirection), 0.0, 1.0);
                 vec3 darkenendGroundAtmosphereColor = mix(groundAtmosphereColor.rgb, finalAtmosphereColor.rgb, darken);
 
                 finalAtmosphereColor = mix(darkenendGroundAtmosphereColor, finalAtmosphereColor, sunlitAtmosphereIntensity);
             #endif
-            
+
             #ifndef HDR
                 finalAtmosphereColor.rgb = vec3(1.0) - exp(-fExposure * finalAtmosphereColor.rgb);
             #else
                 finalAtmosphereColor.rgb = czm_saturation(finalAtmosphereColor.rgb, 1.6);
             #endif
-            
+
             finalColor.rgb = mix(finalColor.rgb, finalAtmosphereColor.rgb, fade);
         #endif
     }
@@ -544,7 +535,7 @@ void main()
       finalColor.a *= interpolateByDistance(alphaByDistance, v_distance);
     }
 #endif
-    
+
     out_FragColor =  finalColor;
 }
 

package/Source/Shaders/GlobeFS.js

@@ -269,20 +269,6 @@ vec4 sampleAndBlend(\n\
     return vec4(outColor, max(outAlpha, 0.0));\n\
 }\n\
 \n\
-vec3 colorCorrect(vec3 rgb) {\n\
-#ifdef COLOR_CORRECT\n\
-    // Convert rgb color to hsb\n\
-    vec3 hsb = czm_RGBToHSB(rgb);\n\
-    // Perform hsb shift\n\
-    hsb.x += u_hsbShift.x; // hue\n\
-    hsb.y = clamp(hsb.y + u_hsbShift.y, 0.0, 1.0); // saturation\n\
-    hsb.z = hsb.z > czm_epsilon7 ? hsb.z + u_hsbShift.z : 0.0; // brightness\n\
-    // Convert shifted hsb back to rgb\n\
-    rgb = czm_HSBToRGB(hsb);\n\
-#endif\n\
-    return rgb;\n\
-}\n\
-\n\
 vec4 computeDayColor(vec4 initialColor, vec3 textureCoordinates, float nightBlend);\n\
 vec4 computeWaterColor(vec3 positionEyeCoordinates, vec2 textureCoordinates, mat3 enuToEye, vec4 imageryColor, float specularMapValue, float fade);\n\
 \n\
@@ -397,7 +383,7 @@ void main()\n\
     materialInput.st = v_textureCoordinates.st;\n\
     materialInput.normalEC = normalize(v_normalEC);\n\
     materialInput.positionToEyeEC = -v_positionEC;\n\
-    materialInput.tangentToEyeMatrix = czm_eastNorthUpToEyeCoordinates(v_positionMC, normalize(v_normalEC));     \n\
+    materialInput.tangentToEyeMatrix = czm_eastNorthUpToEyeCoordinates(v_positionMC, normalize(v_normalEC));\n\
     materialInput.slope = v_slope;\n\
     materialInput.height = v_height;\n\
     materialInput.aspect = v_aspect;\n\
@@ -443,7 +429,7 @@ void main()\n\
     {\n\
         bool dynamicLighting = false;\n\
         #if defined(DYNAMIC_ATMOSPHERE_LIGHTING) && (defined(ENABLE_DAYNIGHT_SHADING) || defined(ENABLE_VERTEX_LIGHTING))\n\
-            dynamicLighting = true;     \n\
+            dynamicLighting = true;\n\
         #endif\n\
 \n\
         vec3 rayleighColor;\n\
@@ -473,30 +459,35 @@ void main()\n\
             opacity = v_atmosphereOpacity;\n\
         #endif\n\
 \n\
-        rayleighColor = colorCorrect(rayleighColor);\n\
-        mieColor = colorCorrect(mieColor);\n\
+        #ifdef COLOR_CORRECT\n\
+            const bool ignoreBlackPixels = true;\n\
+            rayleighColor = czm_applyHSBShift(rayleighColor, u_hsbShift, ignoreBlackPixels);\n\
+            mieColor = czm_applyHSBShift(mieColor, u_hsbShift, ignoreBlackPixels);\n\
+        #endif\n\
 \n\
         vec4 groundAtmosphereColor = computeAtmosphereColor(positionWC, lightDirection, rayleighColor, mieColor, opacity);\n\
 \n\
         // Fog is applied to tiles selected for fog, close to the Earth.\n\
         #ifdef FOG\n\
             vec3 fogColor = groundAtmosphereColor.rgb;\n\
-            \n\
+\n\
             // If there is lighting, apply that to the fog.\n\
             #if defined(DYNAMIC_ATMOSPHERE_LIGHTING) && (defined(ENABLE_VERTEX_LIGHTING) || defined(ENABLE_DAYNIGHT_SHADING))\n\
                 float darken = clamp(dot(normalize(czm_viewerPositionWC), atmosphereLightDirection), u_minimumBrightness, 1.0);\n\
-                fogColor *= darken;                \n\
+                fogColor *= darken;\n\
             #endif\n\
 \n\
             #ifndef HDR\n\
                 fogColor.rgb = czm_acesTonemapping(fogColor.rgb);\n\
                 fogColor.rgb = czm_inverseGamma(fogColor.rgb);\n\
             #endif\n\
-            \n\
+\n\
             const float modifier = 0.15;\n\
             finalColor = vec4(czm_fog(v_distance, finalColor.rgb, fogColor.rgb, modifier), finalColor.a);\n\
 \n\
         #else\n\
+            // Apply ground atmosphere. This happens when the camera is far away from the earth.\n\
+\n\
             // The transmittance is based on optical depth i.e. the length of segment of the ray inside the atmosphere.\n\
             // This value is larger near the \"circumference\", as it is further away from the camera. We use it to\n\
             // brighten up that area of the ground atmosphere.\n\
@@ -508,20 +499,20 @@ void main()\n\
             #if defined(DYNAMIC_ATMOSPHERE_LIGHTING) && (defined(ENABLE_VERTEX_LIGHTING) || defined(ENABLE_DAYNIGHT_SHADING))\n\
                 float fadeInDist = u_nightFadeDistance.x;\n\
                 float fadeOutDist = u_nightFadeDistance.y;\n\
-            \n\
+\n\
                 float sunlitAtmosphereIntensity = clamp((cameraDist - fadeOutDist) / (fadeInDist - fadeOutDist), 0.05, 1.0);\n\
                 float darken = clamp(dot(normalize(positionWC), atmosphereLightDirection), 0.0, 1.0);\n\
                 vec3 darkenendGroundAtmosphereColor = mix(groundAtmosphereColor.rgb, finalAtmosphereColor.rgb, darken);\n\
 \n\
                 finalAtmosphereColor = mix(darkenendGroundAtmosphereColor, finalAtmosphereColor, sunlitAtmosphereIntensity);\n\
             #endif\n\
-            \n\
+\n\
             #ifndef HDR\n\
                 finalAtmosphereColor.rgb = vec3(1.0) - exp(-fExposure * finalAtmosphereColor.rgb);\n\
             #else\n\
                 finalAtmosphereColor.rgb = czm_saturation(finalAtmosphereColor.rgb, 1.6);\n\
             #endif\n\
-            \n\
+\n\
             finalColor.rgb = mix(finalColor.rgb, finalAtmosphereColor.rgb, fade);\n\
         #endif\n\
     }\n\
@@ -545,7 +536,7 @@ void main()\n\
       finalColor.a *= interpolateByDistance(alphaByDistance, v_distance);\n\
     }\n\
 #endif\n\
-    \n\
+\n\
     out_FragColor =  finalColor;\n\
 }\n\
 \n\

package/Source/Shaders/GlobeVS.glsl

@@ -11,7 +11,7 @@ in vec3 geodeticSurfaceNormal;
 #endif
 
 #ifdef EXAGGERATION
-uniform vec2 u_terrainExaggerationAndRelativeHeight;
+uniform vec2 u_verticalExaggerationAndRelativeHeight;
 #endif
 
 uniform vec3 u_center3D;
@@ -128,7 +128,7 @@ void main()
     height = height * (u_minMaxHeight.y - u_minMaxHeight.x) + u_minMaxHeight.x;
     position = (u_scaleAndBias * vec4(position, 1.0)).xyz;
 
-#if (defined(ENABLE_VERTEX_LIGHTING) || defined(GENERATE_POSITION_AND_NORMAL)) && defined(INCLUDE_WEB_MERCATOR_Y)
+#if (defined(ENABLE_VERTEX_LIGHTING) || defined(GENERATE_POSITION_AND_NORMAL)) && defined(INCLUDE_WEB_MERCATOR_Y) || defined(APPLY_MATERIAL)
     float webMercatorT = czm_decompressTextureCoordinates(compressed0.w).x;
     float encodedNormal = compressed1;
 #elif defined(INCLUDE_WEB_MERCATOR_Y)
@@ -173,8 +173,8 @@ void main()
 #endif
 
 #if defined(EXAGGERATION) && defined(GEODETIC_SURFACE_NORMALS)
-    float exaggeration = u_terrainExaggerationAndRelativeHeight.x;
-    float relativeHeight = u_terrainExaggerationAndRelativeHeight.y;
+    float exaggeration = u_verticalExaggerationAndRelativeHeight.x;
+    float relativeHeight = u_verticalExaggerationAndRelativeHeight.y;
     float newHeight = (height - relativeHeight) * exaggeration + relativeHeight;
 
     // stop from going through center of earth

package/Source/Shaders/GlobeVS.js

@@ -12,7 +12,7 @@ in vec3 geodeticSurfaceNormal;\n\
 #endif\n\
 \n\
 #ifdef EXAGGERATION\n\
-uniform vec2 u_terrainExaggerationAndRelativeHeight;\n\
+uniform vec2 u_verticalExaggerationAndRelativeHeight;\n\
 #endif\n\
 \n\
 uniform vec3 u_center3D;\n\
@@ -129,7 +129,7 @@ void main()\n\
     height = height * (u_minMaxHeight.y - u_minMaxHeight.x) + u_minMaxHeight.x;\n\
     position = (u_scaleAndBias * vec4(position, 1.0)).xyz;\n\
 \n\
-#if (defined(ENABLE_VERTEX_LIGHTING) || defined(GENERATE_POSITION_AND_NORMAL)) && defined(INCLUDE_WEB_MERCATOR_Y)\n\
+#if (defined(ENABLE_VERTEX_LIGHTING) || defined(GENERATE_POSITION_AND_NORMAL)) && defined(INCLUDE_WEB_MERCATOR_Y) || defined(APPLY_MATERIAL)\n\
     float webMercatorT = czm_decompressTextureCoordinates(compressed0.w).x;\n\
     float encodedNormal = compressed1;\n\
 #elif defined(INCLUDE_WEB_MERCATOR_Y)\n\
@@ -174,8 +174,8 @@ void main()\n\
 #endif\n\
 \n\
 #if defined(EXAGGERATION) && defined(GEODETIC_SURFACE_NORMALS)\n\
-    float exaggeration = u_terrainExaggerationAndRelativeHeight.x;\n\
-    float relativeHeight = u_terrainExaggerationAndRelativeHeight.y;\n\
+    float exaggeration = u_verticalExaggerationAndRelativeHeight.x;\n\
+    float relativeHeight = u_verticalExaggerationAndRelativeHeight.y;\n\
     float newHeight = (height - relativeHeight) * exaggeration + relativeHeight;\n\
 \n\
     // stop from going through center of earth\n\

package/Source/Shaders/Model/AtmosphereStageFS.glsl

@@ -0,0 +1,111 @@
+// robust iterative solution without trig functions
+// https://github.com/0xfaded/ellipse_demo/issues/1
+// https://stackoverflow.com/questions/22959698/distance-from-given-point-to-given-ellipse
+//
+// This version uses only a single iteration for best performance. For fog
+// rendering, the difference is negligible.
+vec2 nearestPointOnEllipseFast(vec2 pos, vec2 radii) {
+    vec2 p = abs(pos);
+    vec2 inverseRadii = 1.0 / radii;
+    vec2 evoluteScale = (radii.x * radii.x - radii.y * radii.y) * vec2(1.0, -1.0) * inverseRadii;
+
+    // We describe the ellipse parametrically: v = radii * vec2(cos(t), sin(t))
+    // but store the cos and sin of t in a vec2 for efficiency.
+    // Initial guess: t = cos(pi/4)
+    vec2 tTrigs = vec2(0.70710678118);
+    vec2 v = radii * tTrigs;
+
+    // Find the evolute of the ellipse (center of curvature) at v.
+    vec2 evolute = evoluteScale * tTrigs * tTrigs * tTrigs;
+    // Find the (approximate) intersection of p - evolute with the ellipsoid.
+    vec2 q = normalize(p - evolute) * length(v - evolute);
+    // Update the estimate of t.
+    tTrigs = (q + evolute) * inverseRadii;
+    tTrigs = normalize(clamp(tTrigs, 0.0, 1.0));
+    v = radii * tTrigs;
+
+    return v * sign(pos);
+}
+
+vec3 computeEllipsoidPositionWC(vec3 positionMC) {
+    // Get the world-space position and project onto a meridian plane of
+    // the ellipsoid
+    vec3 positionWC = (czm_model * vec4(positionMC, 1.0)).xyz;
+
+    vec2 positionEllipse = vec2(length(positionWC.xy), positionWC.z);
+    vec2 nearestPoint = nearestPointOnEllipseFast(positionEllipse, czm_ellipsoidRadii.xz);
+
+    // Reconstruct a 3D point in world space
+    return vec3(nearestPoint.x * normalize(positionWC.xy), nearestPoint.y);
+}
+
+void applyFog(inout vec4 color, vec4 groundAtmosphereColor, vec3 lightDirection, float distanceToCamera) {
+
+    vec3 fogColor = groundAtmosphereColor.rgb;
+
+    // If there is dynamic lighting, apply that to the fog.
+    const float NONE = 0.0;
+    if (czm_atmosphereDynamicLighting != NONE) {
+        float darken = clamp(dot(normalize(czm_viewerPositionWC), lightDirection), czm_fogMinimumBrightness, 1.0);
+        fogColor *= darken;
+    }
+
+    // Tonemap if HDR rendering is disabled
+    #ifndef HDR
+        fogColor.rgb = czm_acesTonemapping(fogColor.rgb);
+        fogColor.rgb = czm_inverseGamma(fogColor.rgb);
+    #endif
+
+    // Matches the constant in GlobeFS.glsl. This makes the fog falloff
+    // more gradual.
+    const float fogModifier = 0.15;
+    vec3 withFog = czm_fog(distanceToCamera, color.rgb, fogColor, fogModifier);
+    color = vec4(withFog, color.a);
+}
+
+void atmosphereStage(inout vec4 color, in ProcessedAttributes attributes) {
+    vec3 rayleighColor;
+    vec3 mieColor;
+    float opacity;
+
+    vec3 positionWC;
+    vec3 lightDirection;
+
+    // When the camera is in space, compute the position per-fragment for
+    // more accurate ground atmosphere. All other cases will use
+    //
+    // The if condition will be added in https://github.com/CesiumGS/cesium/issues/11717
+    if (false) {
+        positionWC = computeEllipsoidPositionWC(attributes.positionMC);
+        lightDirection = czm_getDynamicAtmosphereLightDirection(positionWC, czm_atmosphereDynamicLighting);
+
+        // The fog color is derived from the ground atmosphere color
+        czm_computeGroundAtmosphereScattering(
+            positionWC,
+            lightDirection,
+            rayleighColor,
+            mieColor,
+            opacity
+        );
+    } else {
+        positionWC = attributes.positionWC;
+        lightDirection = czm_getDynamicAtmosphereLightDirection(positionWC, czm_atmosphereDynamicLighting);
+        rayleighColor = v_atmosphereRayleighColor;
+        mieColor = v_atmosphereMieColor;
+        opacity = v_atmosphereOpacity;
+    }
+
+    //color correct rayleigh and mie colors
+    const bool ignoreBlackPixels = true;
+    rayleighColor = czm_applyHSBShift(rayleighColor, czm_atmosphereHsbShift, ignoreBlackPixels);
+    mieColor = czm_applyHSBShift(mieColor, czm_atmosphereHsbShift, ignoreBlackPixels);
+
+    vec4 groundAtmosphereColor = czm_computeAtmosphereColor(positionWC, lightDirection, rayleighColor, mieColor, opacity);
+
+    if (u_isInFog) {
+        float distanceToCamera = length(attributes.positionEC);
+        applyFog(color, groundAtmosphereColor, lightDirection, distanceToCamera);
+    } else {
+        // Ground atmosphere
+    }
+}