@cesium/engine 6.2.0 → 7.0.0

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

@@ -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)

package/Source/Shaders/GlobeVS.js

@@ -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\

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
+    }
+}

package/Source/Shaders/Model/AtmosphereStageFS.js

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

package/Source/Shaders/Model/AtmosphereStageVS.glsl

@@ -0,0 +1,12 @@
+void atmosphereStage(ProcessedAttributes attributes) {
+    vec3 lightDirection = czm_getDynamicAtmosphereLightDirection(v_positionWC, czm_atmosphereDynamicLighting);
+
+    czm_computeGroundAtmosphereScattering(
+        // This assumes the geometry stage came before this.
+        v_positionWC,
+        lightDirection,
+        v_atmosphereRayleighColor,
+        v_atmosphereMieColor,
+        v_atmosphereOpacity
+    );
+}

package/Source/Shaders/Model/AtmosphereStageVS.js

@@ -0,0 +1,14 @@
+//This file is automatically rebuilt by the Cesium build process.
+export default "void atmosphereStage(ProcessedAttributes attributes) {\n\
+    vec3 lightDirection = czm_getDynamicAtmosphereLightDirection(v_positionWC, czm_atmosphereDynamicLighting);\n\
+\n\
+    czm_computeGroundAtmosphereScattering(\n\
+        // This assumes the geometry stage came before this.\n\
+        v_positionWC,\n\
+        lightDirection,\n\
+        v_atmosphereRayleighColor,\n\
+        v_atmosphereMieColor,\n\
+        v_atmosphereOpacity\n\
+    );\n\
+}\n\
+";

package/Source/Shaders/Model/GeometryStageFS.glsl

@@ -3,7 +3,7 @@ void geometryStage(out ProcessedAttributes attributes)
   attributes.positionMC = v_positionMC;
   attributes.positionEC = v_positionEC;
 
-  #ifdef COMPUTE_POSITION_WC_CUSTOM_SHADER
+  #if defined(COMPUTE_POSITION_WC_CUSTOM_SHADER) || defined(COMPUTE_POSITION_WC_STYLE) || defined(COMPUTE_POSITION_WC_ATMOSPHERE)
   attributes.positionWC = v_positionWC;
   #endif
 

package/Source/Shaders/Model/GeometryStageFS.js

@@ -4,7 +4,7 @@ export default "void geometryStage(out ProcessedAttributes attributes)\n\
   attributes.positionMC = v_positionMC;\n\
   attributes.positionEC = v_positionEC;\n\
 \n\
-  #ifdef COMPUTE_POSITION_WC_CUSTOM_SHADER\n\
+  #if defined(COMPUTE_POSITION_WC_CUSTOM_SHADER) || defined(COMPUTE_POSITION_WC_STYLE) || defined(COMPUTE_POSITION_WC_ATMOSPHERE)\n\
   attributes.positionWC = v_positionWC;\n\
   #endif\n\
 \n\

package/Source/Shaders/Model/GeometryStageVS.glsl

@@ -1,4 +1,4 @@
-vec4 geometryStage(inout ProcessedAttributes attributes, mat4 modelView, mat3 normal) 
+vec4 geometryStage(inout ProcessedAttributes attributes, mat4 modelView, mat3 normal)
 {
     vec4 computedPosition;
 
@@ -16,7 +16,7 @@ vec4 geometryStage(inout ProcessedAttributes attributes, mat4 modelView, mat3 no
     #endif
 
     // Sometimes the custom shader and/or style needs this
-    #if defined(COMPUTE_POSITION_WC_CUSTOM_SHADER) || defined(COMPUTE_POSITION_WC_STYLE)
+    #if defined(COMPUTE_POSITION_WC_CUSTOM_SHADER) || defined(COMPUTE_POSITION_WC_STYLE) || defined(COMPUTE_POSITION_WC_ATMOSPHERE)
     // Note that this is a 32-bit position which may result in jitter on small
     // scales.
     v_positionWC = (czm_model * vec4(positionMC, 1.0)).xyz;
@@ -27,7 +27,7 @@ vec4 geometryStage(inout ProcessedAttributes attributes, mat4 modelView, mat3 no
     #endif
 
     #ifdef HAS_TANGENTS
-    v_tangentEC = normalize(normal * attributes.tangentMC);    
+    v_tangentEC = normalize(normal * attributes.tangentMC);
     #endif
 
     #ifdef HAS_BITANGENTS
@@ -37,6 +37,6 @@ vec4 geometryStage(inout ProcessedAttributes attributes, mat4 modelView, mat3 no
     // All other varyings need to be dynamically generated in
     // GeometryPipelineStage
     setDynamicVaryings(attributes);
-    
+
     return computedPosition;
 }

package/Source/Shaders/Model/GeometryStageVS.js

@@ -1,5 +1,5 @@
 //This file is automatically rebuilt by the Cesium build process.
-export default "vec4 geometryStage(inout ProcessedAttributes attributes, mat4 modelView, mat3 normal) \n\
+export default "vec4 geometryStage(inout ProcessedAttributes attributes, mat4 modelView, mat3 normal)\n\
 {\n\
     vec4 computedPosition;\n\
 \n\
@@ -17,7 +17,7 @@ export default "vec4 geometryStage(inout ProcessedAttributes attributes, mat4 mo
     #endif\n\
 \n\
     // Sometimes the custom shader and/or style needs this\n\
-    #if defined(COMPUTE_POSITION_WC_CUSTOM_SHADER) || defined(COMPUTE_POSITION_WC_STYLE)\n\
+    #if defined(COMPUTE_POSITION_WC_CUSTOM_SHADER) || defined(COMPUTE_POSITION_WC_STYLE) || defined(COMPUTE_POSITION_WC_ATMOSPHERE)\n\
     // Note that this is a 32-bit position which may result in jitter on small\n\
     // scales.\n\
     v_positionWC = (czm_model * vec4(positionMC, 1.0)).xyz;\n\
@@ -28,7 +28,7 @@ export default "vec4 geometryStage(inout ProcessedAttributes attributes, mat4 mo
     #endif\n\
 \n\
     #ifdef HAS_TANGENTS\n\
-    v_tangentEC = normalize(normal * attributes.tangentMC);    \n\
+    v_tangentEC = normalize(normal * attributes.tangentMC);\n\
     #endif\n\
 \n\
     #ifdef HAS_BITANGENTS\n\
@@ -38,7 +38,7 @@ export default "vec4 geometryStage(inout ProcessedAttributes attributes, mat4 mo
     // All other varyings need to be dynamically generated in\n\
     // GeometryPipelineStage\n\
     setDynamicVaryings(attributes);\n\
-    \n\
+\n\
     return computedPosition;\n\
 }\n\
 ";

package/Source/Shaders/Model/ModelColorStageFS.glsl

@@ -4,4 +4,4 @@ void modelColorStage(inout czm_modelMaterial material)
     float highlight = ceil(model_colorBlend);
     material.diffuse *= mix(model_color.rgb, vec3(1.0), highlight);
     material.alpha *= model_color.a;
-}
+}

package/Source/Shaders/Model/ModelColorStageFS.js

@@ -5,4 +5,5 @@ export default "void modelColorStage(inout czm_modelMaterial material)\n\
     float highlight = ceil(model_colorBlend);\n\
     material.diffuse *= mix(model_color.rgb, vec3(1.0), highlight);\n\
     material.alpha *= model_color.a;\n\
-}";
+}\n\
+";

package/Source/Shaders/Model/ModelFS.glsl

@@ -79,5 +79,9 @@ void main()
     silhouetteStage(color);
     #endif
 
+    #ifdef HAS_ATMOSPHERE
+    atmosphereStage(color, attributes);
+    #endif
+
     out_FragColor = color;
 }

package/Source/Shaders/Model/ModelFS.js

@@ -79,6 +79,10 @@ void main()\n\
     #if defined(HAS_SILHOUETTE) && defined(HAS_NORMALS)\n\
     silhouetteStage(color);\n\
     #endif\n\
+\n\
+    #ifdef HAS_ATMOSPHERE\n\
+    atmosphereStage(color, attributes);\n\
+    #endif\n\
 \n\
     out_FragColor = color;\n\
 }\n\

package/Source/Shaders/Model/ModelVS.glsl

@@ -7,7 +7,7 @@ czm_modelVertexOutput defaultVertexOutput(vec3 positionMC) {
     return vsOutput;
 }
 
-void main() 
+void main()
 {
     // Initialize the attributes struct with all
     // attributes except quantized ones.
@@ -66,14 +66,14 @@ void main()
     // Update the position for this instance in place
     #ifdef HAS_INSTANCING
 
-        // The legacy instance stage is used when rendering i3dm models that 
+        // The legacy instance stage is used when rendering i3dm models that
         // encode instances transforms in world space, as opposed to glTF models
         // that use EXT_mesh_gpu_instancing, where instance transforms are encoded
         // in object space.
         #ifdef USE_LEGACY_INSTANCING
         mat4 instanceModelView;
         mat3 instanceModelViewInverseTranspose;
-        
+
         legacyInstancingStage(attributes, instanceModelView, instanceModelViewInverseTranspose);
 
         modelView = instanceModelView;
@@ -104,7 +104,12 @@ void main()
 
     // Compute the final position in each coordinate system needed.
     // This returns the value that will be assigned to gl_Position.
-    vec4 positionClip = geometryStage(attributes, modelView, normal);    
+    vec4 positionClip = geometryStage(attributes, modelView, normal);
+
+    // This must go after the geometry stage as it needs v_positionWC
+    #ifdef HAS_ATMOSPHERE
+    atmosphereStage(attributes);
+    #endif
 
     #ifdef HAS_SILHOUETTE
     silhouetteStage(attributes, positionClip);

package/Source/Shaders/Model/ModelVS.js

@@ -8,7 +8,7 @@ czm_modelVertexOutput defaultVertexOutput(vec3 positionMC) {\n\
     return vsOutput;\n\
 }\n\
 \n\
-void main() \n\
+void main()\n\
 {\n\
     // Initialize the attributes struct with all\n\
     // attributes except quantized ones.\n\
@@ -67,14 +67,14 @@ void main() \n\
     // Update the position for this instance in place\n\
     #ifdef HAS_INSTANCING\n\
 \n\
-        // The legacy instance stage is used when rendering i3dm models that \n\
+        // The legacy instance stage is used when rendering i3dm models that\n\
         // encode instances transforms in world space, as opposed to glTF models\n\
         // that use EXT_mesh_gpu_instancing, where instance transforms are encoded\n\
         // in object space.\n\
         #ifdef USE_LEGACY_INSTANCING\n\
         mat4 instanceModelView;\n\
         mat3 instanceModelViewInverseTranspose;\n\
-        \n\
+\n\
         legacyInstancingStage(attributes, instanceModelView, instanceModelViewInverseTranspose);\n\
 \n\
         modelView = instanceModelView;\n\
@@ -105,7 +105,12 @@ void main() \n\
 \n\
     // Compute the final position in each coordinate system needed.\n\
     // This returns the value that will be assigned to gl_Position.\n\
-    vec4 positionClip = geometryStage(attributes, modelView, normal);    \n\
+    vec4 positionClip = geometryStage(attributes, modelView, normal);\n\
+\n\
+    // This must go after the geometry stage as it needs v_positionWC\n\
+    #ifdef HAS_ATMOSPHERE\n\
+    atmosphereStage(attributes);\n\
+    #endif\n\
 \n\
     #ifdef HAS_SILHOUETTE\n\
     silhouetteStage(attributes, positionClip);\n\

package/Source/Shaders/SkyAtmosphereCommon.glsl

@@ -8,16 +8,6 @@ float interpolateByDistance(vec4 nearFarScalar, float distance)
     return mix(startValue, endValue, t);
 }
 
-vec3 getLightDirection(vec3 positionWC)
-{
-    float lightEnum = u_radiiAndDynamicAtmosphereColor.z;
-    vec3 lightDirection =
-        positionWC * float(lightEnum == 0.0) +
-        czm_lightDirectionWC * float(lightEnum == 1.0) +
-        czm_sunDirectionWC * float(lightEnum == 2.0);
-    return normalize(lightDirection);
-}
-
 void computeAtmosphereScattering(vec3 positionWC, vec3 lightDirection, out vec3 rayleighColor, out vec3 mieColor, out float opacity, out float underTranslucentGlobe)
 {
     float ellipsoidRadiiDifference = czm_ellipsoidRadii.x - czm_ellipsoidRadii.z;
@@ -28,7 +18,7 @@ void computeAtmosphereScattering(vec3 positionWC, vec3 lightDirection, out vec3
     float distanceAdjustModifier = ellipsoidRadiiDifference / 2.0;
     float distanceAdjust = distanceAdjustModifier * clamp((czm_eyeHeight - distanceAdjustMin) / (distanceAdjustMax - distanceAdjustMin), 0.0, 1.0);
 
-    // Since atmosphere scattering assumes the atmosphere is a spherical shell, we compute an inner radius of the atmosphere best fit 
+    // Since atmosphere scattering assumes the atmosphere is a spherical shell, we compute an inner radius of the atmosphere best fit
     // for the position on the ellipsoid.
     float radiusAdjust = (ellipsoidRadiiDifference / 4.0) + distanceAdjust;
     float atmosphereInnerRadius = (length(czm_viewerPositionWC) - czm_eyeHeight) - radiusAdjust;
@@ -46,7 +36,7 @@ void computeAtmosphereScattering(vec3 positionWC, vec3 lightDirection, out vec3
         // Check for intersection with the inner radius of the atmopshere.
         czm_raySegment primaryRayEarthIntersect = czm_raySphereIntersectionInterval(primaryRay, vec3(0.0), atmosphereInnerRadius + radiusAdjust);
         if (primaryRayEarthIntersect.start > 0.0 && primaryRayEarthIntersect.stop > 0.0) {
-            
+
             // Compute position on globe.
             vec3 direction = normalize(positionWC);
             czm_ray ellipsoidRay = czm_ray(positionWC, -direction);
@@ -62,7 +52,7 @@ void computeAtmosphereScattering(vec3 positionWC, vec3 lightDirection, out vec3
             vec3 nearColor = vec3(0.0);
 
             rayleighColor = mix(nearColor, horizonColor, exp(-angle) * opacity);
-            
+
             // Set the traslucent flag to avoid alpha adjustment in computeFinalColor funciton.
             underTranslucentGlobe = 1.0;
             return;