@cesium/engine 6.1.1 → 7.0.0

package/Source/Scene/VoxelPrimitive.js

@@ -131,6 +131,38 @@ function VoxelPrimitive(options) {
    */
   this._maxBoundsOld = new Cartesian3();
 
+  /**
+   * Minimum bounds with vertical exaggeration applied
+   *
+   * @type {Cartesian3}
+   * @private
+   */
+  this._exaggeratedMinBounds = new Cartesian3();
+
+  /**
+   * Used to detect if the shape is dirty.
+   *
+   * @type {Cartesian3}
+   * @private
+   */
+  this._exaggeratedMinBoundsOld = new Cartesian3();
+
+  /**
+   * Maximum bounds with vertical exaggeration applied
+   *
+   * @type {Cartesian3}
+   * @private
+   */
+  this._exaggeratedMaxBounds = new Cartesian3();
+
+  /**
+   * Used to detect if the shape is dirty.
+   *
+   * @type {Cartesian3}
+   * @private
+   */
+  this._exaggeratedMaxBoundsOld = new Cartesian3();
+
   /**
    * This member is not known until the provider is ready.
    *
@@ -442,6 +474,7 @@ function initialize(primitive, provider) {
   // Create the shape object, and update it so it is valid for VoxelTraversal
   const ShapeConstructor = VoxelShapeType.getShapeConstructor(shapeType);
   primitive._shape = new ShapeConstructor();
+  updateVerticalExaggeration(primitive);
   primitive._shapeVisible = updateShapeAndTransforms(
     primitive,
     primitive._shape,
@@ -964,6 +997,8 @@ VoxelPrimitive.prototype.update = function (frameState) {
     return;
   }
 
+  updateVerticalExaggeration(this, frameState);
+
   // Check if the shape is dirty before updating it. This needs to happen every
   // frame because the member variables can be modified externally via the
   // getters.
@@ -1107,6 +1142,32 @@ VoxelPrimitive.prototype.update = function (frameState) {
   frameState.commandList.push(command);
 };
 
+/**
+ * Update the exaggerated bounds of a primitive to account for vertical exaggeration
+ * Currently only applies to Ellipsoid shape type
+ * @param {VoxelPrimitive} primitive
+ * @param {FrameState} [frameState]
+ * @private
+ */
+function updateVerticalExaggeration(primitive, frameState) {
+  primitive._exaggeratedMinBounds = Cartesian3.clone(
+    primitive._minBounds,
+    primitive._exaggeratedMinBounds
+  );
+  primitive._exaggeratedMaxBounds = Cartesian3.clone(
+    primitive._maxBounds,
+    primitive._exaggeratedMaxBounds
+  );
+  if (defined(frameState) && primitive.shape === VoxelShapeType.ELLIPSOID) {
+    const relativeHeight = frameState.verticalExaggerationRelativeHeight;
+    const exaggeration = frameState.verticalExaggeration;
+    primitive._exaggeratedMinBounds.z =
+      (primitive._minBounds.z - relativeHeight) * exaggeration + relativeHeight;
+    primitive._exaggeratedMaxBounds.z =
+      (primitive._maxBounds.z - relativeHeight) * exaggeration + relativeHeight;
+  }
+}
+
 /**
  * Initialize primitive properties that are derived from the voxel provider
  * @param {VoxelPrimitive} primitive
@@ -1203,6 +1264,16 @@ function checkTransformAndBounds(primitive, provider) {
     updateBound(primitive, "_compoundModelMatrix", "_compoundModelMatrixOld") +
     updateBound(primitive, "_minBounds", "_minBoundsOld") +
     updateBound(primitive, "_maxBounds", "_maxBoundsOld") +
+    updateBound(
+      primitive,
+      "_exaggeratedMinBounds",
+      "_exaggeratedMinBoundsOld"
+    ) +
+    updateBound(
+      primitive,
+      "_exaggeratedMaxBounds",
+      "_exaggeratedMaxBoundsOld"
+    ) +
     updateBound(primitive, "_minClippingBounds", "_minClippingBoundsOld") +
     updateBound(primitive, "_maxClippingBounds", "_maxClippingBoundsOld");
   return numChanges > 0;
@@ -1239,8 +1310,8 @@ function updateBound(primitive, newBoundKey, oldBoundKey) {
 function updateShapeAndTransforms(primitive, shape, provider) {
   const visible = shape.update(
     primitive._compoundModelMatrix,
-    primitive.minBounds,
-    primitive.maxBounds,
+    primitive._exaggeratedMinBounds,
+    primitive._exaggeratedMaxBounds,
     primitive.minClippingBounds,
     primitive.maxClippingBounds
   );

package/Source/Shaders/AtmosphereCommon.glsl

@@ -11,14 +11,6 @@ const float ATMOSPHERE_THICKNESS = 111e3; // The thickness of the atmosphere in
 const int PRIMARY_STEPS_MAX = 16; // Maximum number of times the ray from the camera to the world position (primary ray) is sampled.
 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.
 
-/**
- * Rational approximation to tanh(x)
-*/
-float approximateTanh(float x) {
-    float x2 = x * x;
-    return max(-1.0, min(+1.0, x * (27.0 + x2) / (27.0 + 9.0 * x2)));
-}
-
 /**
  * This function computes the colors contributed by Rayliegh and Mie scattering on a given ray, as well as
  * the transmittance value for the ray.
@@ -65,8 +57,8 @@ void computeScattering(
     float x = 1e-7 * primaryRayAtmosphereIntersect.stop / length(primaryRayLength);
     // Value close to 0.0: close to the horizon
     // Value close to 1.0: above in the sky
-    float w_stop_gt_lprl = 0.5 * (1.0 + approximateTanh(x));
-    
+    float w_stop_gt_lprl = 0.5 * (1.0 + czm_approximateTanh(x));
+
     // The ray should start from the first intersection with the outer atmopshere, or from the camera position, if it is inside the atmosphere.
     float start_0 = primaryRayAtmosphereIntersect.start;
     primaryRayAtmosphereIntersect.start = max(primaryRayAtmosphereIntersect.start, 0.0);
@@ -77,7 +69,7 @@ void computeScattering(
     // (1) from outer space we have to use more ray steps to get a realistic rendering
     // (2) within atmosphere we need fewer steps for faster rendering
     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
-    float w_inside_atmosphere = 1.0 - 0.5 * (1.0 + approximateTanh(x_o_a));
+    float w_inside_atmosphere = 1.0 - 0.5 * (1.0 + czm_approximateTanh(x_o_a));
     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.
     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.
 

package/Source/Shaders/AtmosphereCommon.js

@@ -12,14 +12,6 @@ const float ATMOSPHERE_THICKNESS = 111e3; // The thickness of the atmosphere in
 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\
-/**\n\
- * Rational approximation to tanh(x)\n\
-*/\n\
-float approximateTanh(float x) {\n\
-    float x2 = x * x;\n\
-    return max(-1.0, min(+1.0, x * (27.0 + x2) / (27.0 + 9.0 * x2)));\n\
-}\n\
-\n\
 /**\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.\n\
@@ -66,8 +58,8 @@ void computeScattering(\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 + approximateTanh(x));\n\
-    \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\
@@ -78,7 +70,7 @@ void computeScattering(\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 + approximateTanh(x_o_a));\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\

package/Source/Shaders/Builtin/CzmBuiltins.js

@@ -55,7 +55,9 @@ import czm_XYZToRGB from './Functions/XYZToRGB.js'
 import czm_acesTonemapping from './Functions/acesTonemapping.js'
 import czm_alphaWeight from './Functions/alphaWeight.js'
 import czm_antialias from './Functions/antialias.js'
+import czm_applyHSBShift from './Functions/applyHSBShift.js'
 import czm_approximateSphericalCoordinates from './Functions/approximateSphericalCoordinates.js'
+import czm_approximateTanh from './Functions/approximateTanh.js'
 import czm_backFacing from './Functions/backFacing.js'
 import czm_branchFreeTernary from './Functions/branchFreeTernary.js'
 import czm_cascadeColor from './Functions/cascadeColor.js'
@@ -63,7 +65,10 @@ import czm_cascadeDistance from './Functions/cascadeDistance.js'
 import czm_cascadeMatrix from './Functions/cascadeMatrix.js'
 import czm_cascadeWeights from './Functions/cascadeWeights.js'
 import czm_columbusViewMorph from './Functions/columbusViewMorph.js'
+import czm_computeAtmosphereColor from './Functions/computeAtmosphereColor.js'
+import czm_computeGroundAtmosphereScattering from './Functions/computeGroundAtmosphereScattering.js'
 import czm_computePosition from './Functions/computePosition.js'
+import czm_computeScattering from './Functions/computeScattering.js'
 import czm_cosineAndSine from './Functions/cosineAndSine.js'
 import czm_decompressTextureCoordinates from './Functions/decompressTextureCoordinates.js'
 import czm_defaultPbrMaterial from './Functions/defaultPbrMaterial.js'
@@ -79,6 +84,7 @@ import czm_fog from './Functions/fog.js'
 import czm_gammaCorrect from './Functions/gammaCorrect.js'
 import czm_geodeticSurfaceNormal from './Functions/geodeticSurfaceNormal.js'
 import czm_getDefaultMaterial from './Functions/getDefaultMaterial.js'
+import czm_getDynamicAtmosphereLightDirection from './Functions/getDynamicAtmosphereLightDirection.js'
 import czm_getLambertDiffuse from './Functions/getLambertDiffuse.js'
 import czm_getSpecular from './Functions/getSpecular.js'
 import czm_getWaterNoise from './Functions/getWaterNoise.js'
@@ -188,7 +194,9 @@ export default {
     czm_acesTonemapping : czm_acesTonemapping,
     czm_alphaWeight : czm_alphaWeight,
     czm_antialias : czm_antialias,
+    czm_applyHSBShift : czm_applyHSBShift,
     czm_approximateSphericalCoordinates : czm_approximateSphericalCoordinates,
+    czm_approximateTanh : czm_approximateTanh,
     czm_backFacing : czm_backFacing,
     czm_branchFreeTernary : czm_branchFreeTernary,
     czm_cascadeColor : czm_cascadeColor,
@@ -196,7 +204,10 @@ export default {
     czm_cascadeMatrix : czm_cascadeMatrix,
     czm_cascadeWeights : czm_cascadeWeights,
     czm_columbusViewMorph : czm_columbusViewMorph,
+    czm_computeAtmosphereColor : czm_computeAtmosphereColor,
+    czm_computeGroundAtmosphereScattering : czm_computeGroundAtmosphereScattering,
     czm_computePosition : czm_computePosition,
+    czm_computeScattering : czm_computeScattering,
     czm_cosineAndSine : czm_cosineAndSine,
     czm_decompressTextureCoordinates : czm_decompressTextureCoordinates,
     czm_defaultPbrMaterial : czm_defaultPbrMaterial,
@@ -212,6 +223,7 @@ export default {
     czm_gammaCorrect : czm_gammaCorrect,
     czm_geodeticSurfaceNormal : czm_geodeticSurfaceNormal,
     czm_getDefaultMaterial : czm_getDefaultMaterial,
+    czm_getDynamicAtmosphereLightDirection : czm_getDynamicAtmosphereLightDirection,
     czm_getLambertDiffuse : czm_getLambertDiffuse,
     czm_getSpecular : czm_getSpecular,
     czm_getWaterNoise : czm_getWaterNoise,

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

@@ -0,0 +1,32 @@
+/**
+ * Apply a HSB color shift to an RGB color.
+ *
+ * @param {vec3} rgb The color in RGB space.
+ * @param {vec3} hsbShift The amount to shift each component. The xyz components correspond to hue, saturation, and brightness. Shifting the hue by +/- 1.0 corresponds to shifting the hue by a full cycle. Saturation and brightness are clamped between 0 and 1 after the adjustment
+ * @param {bool} ignoreBlackPixels If true, black pixels will be unchanged. This is necessary in some shaders such as atmosphere-related effects.
+ *
+ * @return {vec3} The RGB color after shifting in HSB space and clamping saturation and brightness to a valid range.
+ */
+vec3 czm_applyHSBShift(vec3 rgb, vec3 hsbShift, bool ignoreBlackPixels) {
+    // Convert rgb color to hsb
+    vec3 hsb = czm_RGBToHSB(rgb);
+
+    // Perform hsb shift
+    // Hue cycles around so no clamp is needed.
+    hsb.x += hsbShift.x; // hue
+    hsb.y = clamp(hsb.y + hsbShift.y, 0.0, 1.0); // saturation
+
+    // brightness
+    //
+    // Some shaders such as atmosphere-related effects need to leave black
+    // pixels unchanged
+    if (ignoreBlackPixels) {
+        hsb.z = hsb.z > czm_epsilon7 ? hsb.z + hsbShift.z : 0.0;
+    } else {
+        hsb.z = hsb.z + hsbShift.z;
+    }
+    hsb.z = clamp(hsb.z, 0.0, 1.0);
+
+    // Convert shifted hsb back to rgb
+    return czm_HSBToRGB(hsb);
+}

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

@@ -0,0 +1,34 @@
+//This file is automatically rebuilt by the Cesium build process.
+export default "/**\n\
+ * Apply a HSB color shift to an RGB color.\n\
+ *\n\
+ * @param {vec3} rgb The color in RGB space.\n\
+ * @param {vec3} hsbShift The amount to shift each component. The xyz components correspond to hue, saturation, and brightness. Shifting the hue by +/- 1.0 corresponds to shifting the hue by a full cycle. Saturation and brightness are clamped between 0 and 1 after the adjustment\n\
+ * @param {bool} ignoreBlackPixels If true, black pixels will be unchanged. This is necessary in some shaders such as atmosphere-related effects.\n\
+ *\n\
+ * @return {vec3} The RGB color after shifting in HSB space and clamping saturation and brightness to a valid range.\n\
+ */\n\
+vec3 czm_applyHSBShift(vec3 rgb, vec3 hsbShift, bool ignoreBlackPixels) {\n\
+    // Convert rgb color to hsb\n\
+    vec3 hsb = czm_RGBToHSB(rgb);\n\
+\n\
+    // Perform hsb shift\n\
+    // Hue cycles around so no clamp is needed.\n\
+    hsb.x += hsbShift.x; // hue\n\
+    hsb.y = clamp(hsb.y + hsbShift.y, 0.0, 1.0); // saturation\n\
+\n\
+    // brightness\n\
+    //\n\
+    // Some shaders such as atmosphere-related effects need to leave black\n\
+    // pixels unchanged\n\
+    if (ignoreBlackPixels) {\n\
+        hsb.z = hsb.z > czm_epsilon7 ? hsb.z + hsbShift.z : 0.0;\n\
+    } else {\n\
+        hsb.z = hsb.z + hsbShift.z;\n\
+    }\n\
+    hsb.z = clamp(hsb.z, 0.0, 1.0);\n\
+\n\
+    // Convert shifted hsb back to rgb\n\
+    return czm_HSBToRGB(hsb);\n\
+}\n\
+";

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

@@ -0,0 +1,10 @@
+/**
+ * Compute a rational approximation to tanh(x)
+ *
+ * @param {float} x A real number input
+ * @returns {float} An approximation for tanh(x)
+*/
+float czm_approximateTanh(float x) {
+    float x2 = x * x;
+    return max(-1.0, min(1.0, x * (27.0 + x2) / (27.0 + 9.0 * x2)));
+}

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

@@ -0,0 +1,12 @@
+//This file is automatically rebuilt by the Cesium build process.
+export default "/**\n\
+ * Compute a rational approximation to tanh(x)\n\
+ *\n\
+ * @param {float} x A real number input\n\
+ * @returns {float} An approximation for tanh(x)\n\
+*/\n\
+float czm_approximateTanh(float x) {\n\
+    float x2 = x * x;\n\
+    return max(-1.0, min(1.0, x * (27.0 + x2) / (27.0 + 9.0 * x2)));\n\
+}\n\
+";

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

@@ -0,0 +1,44 @@
+/**
+ * Compute the atmosphere color, applying Rayleigh and Mie scattering. This
+ * builtin uses automatic uniforms so the atmophere settings are synced with the
+ * state of the Scene, even in other contexts like Model.
+ *
+ * @name czm_computeAtmosphereColor
+ * @glslFunction
+ *
+ * @param {vec3} positionWC Position of the fragment in world coords (low precision)
+ * @param {vec3} lightDirection Light direction from the sun or other light source.
+ * @param {vec3} rayleighColor The Rayleigh scattering color computed by a scattering function
+ * @param {vec3} mieColor The Mie scattering color computed by a scattering function
+ * @param {float} opacity The opacity computed by a scattering function.
+ */
+vec4 czm_computeAtmosphereColor(
+    vec3 positionWC,
+    vec3 lightDirection,
+    vec3 rayleighColor,
+    vec3 mieColor,
+    float opacity
+) {
+    // Setup the primary ray: from the camera position to the vertex position.
+    vec3 cameraToPositionWC = positionWC - czm_viewerPositionWC;
+    vec3 cameraToPositionWCDirection = normalize(cameraToPositionWC);
+
+    float cosAngle = dot(cameraToPositionWCDirection, lightDirection);
+    float cosAngleSq = cosAngle * cosAngle;
+
+    float G = czm_atmosphereMieAnisotropy;
+    float GSq = G * G;
+
+    // The Rayleigh phase function.
+    float rayleighPhase = 3.0 / (50.2654824574) * (1.0 + cosAngleSq);
+    // The Mie phase function.
+    float miePhase = 3.0 / (25.1327412287) * ((1.0 - GSq) * (cosAngleSq + 1.0)) / (pow(1.0 + GSq - 2.0 * cosAngle * G, 1.5) * (2.0 + GSq));
+
+    // The final color is generated by combining the effects of the Rayleigh and Mie scattering.
+    vec3 rayleigh = rayleighPhase * rayleighColor;
+    vec3 mie = miePhase * mieColor;
+
+    vec3 color = (rayleigh + mie) * czm_atmosphereLightIntensity;
+
+    return vec4(color, opacity);
+}

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

@@ -0,0 +1,46 @@
+//This file is automatically rebuilt by the Cesium build process.
+export default "/**\n\
+ * Compute the atmosphere color, applying Rayleigh and Mie scattering. This\n\
+ * builtin uses automatic uniforms so the atmophere settings are synced with the\n\
+ * state of the Scene, even in other contexts like Model.\n\
+ *\n\
+ * @name czm_computeAtmosphereColor\n\
+ * @glslFunction\n\
+ *\n\
+ * @param {vec3} positionWC Position of the fragment in world coords (low precision)\n\
+ * @param {vec3} lightDirection Light direction from the sun or other light source.\n\
+ * @param {vec3} rayleighColor The Rayleigh scattering color computed by a scattering function\n\
+ * @param {vec3} mieColor The Mie scattering color computed by a scattering function\n\
+ * @param {float} opacity The opacity computed by a scattering function.\n\
+ */\n\
+vec4 czm_computeAtmosphereColor(\n\
+    vec3 positionWC,\n\
+    vec3 lightDirection,\n\
+    vec3 rayleighColor,\n\
+    vec3 mieColor,\n\
+    float opacity\n\
+) {\n\
+    // Setup the primary ray: from the camera position to the vertex position.\n\
+    vec3 cameraToPositionWC = positionWC - czm_viewerPositionWC;\n\
+    vec3 cameraToPositionWCDirection = normalize(cameraToPositionWC);\n\
+\n\
+    float cosAngle = dot(cameraToPositionWCDirection, lightDirection);\n\
+    float cosAngleSq = cosAngle * cosAngle;\n\
+\n\
+    float G = czm_atmosphereMieAnisotropy;\n\
+    float GSq = G * G;\n\
+\n\
+    // The Rayleigh phase function.\n\
+    float rayleighPhase = 3.0 / (50.2654824574) * (1.0 + cosAngleSq);\n\
+    // The Mie phase function.\n\
+    float miePhase = 3.0 / (25.1327412287) * ((1.0 - GSq) * (cosAngleSq + 1.0)) / (pow(1.0 + GSq - 2.0 * cosAngle * G, 1.5) * (2.0 + GSq));\n\
+\n\
+    // The final color is generated by combining the effects of the Rayleigh and Mie scattering.\n\
+    vec3 rayleigh = rayleighPhase * rayleighColor;\n\
+    vec3 mie = miePhase * mieColor;\n\
+\n\
+    vec3 color = (rayleigh + mie) * czm_atmosphereLightIntensity;\n\
+\n\
+    return vec4(color, opacity);\n\
+}\n\
+";

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

@@ -0,0 +1,30 @@
+/**
+ * Compute atmosphere scattering for the ground atmosphere and fog. This method
+ * uses automatic uniforms so it is always synced with the scene settings.
+ *
+ * @name czm_computeGroundAtmosphereScattering
+ * @glslfunction
+ *
+ * @param {vec3} positionWC The position of the fragment in world coordinates.
+ * @param {vec3} lightDirection The direction of the light to calculate the scattering from.
+ * @param {vec3} rayleighColor The variable the Rayleigh scattering will be written to.
+ * @param {vec3} mieColor The variable the Mie scattering will be written to.
+ * @param {float} opacity The variable the transmittance will be written to.
+ */
+void czm_computeGroundAtmosphereScattering(vec3 positionWC, vec3 lightDirection, out vec3 rayleighColor, out vec3 mieColor, out float opacity) {
+    vec3 cameraToPositionWC = positionWC - czm_viewerPositionWC;
+    vec3 cameraToPositionWCDirection = normalize(cameraToPositionWC);
+    czm_ray primaryRay = czm_ray(czm_viewerPositionWC, cameraToPositionWCDirection);
+
+    float atmosphereInnerRadius = length(positionWC);
+
+    czm_computeScattering(
+        primaryRay,
+        length(cameraToPositionWC),
+        lightDirection,
+        atmosphereInnerRadius,
+        rayleighColor,
+        mieColor,
+        opacity
+    );
+}

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

@@ -0,0 +1,32 @@
+//This file is automatically rebuilt by the Cesium build process.
+export default "/**\n\
+ * Compute atmosphere scattering for the ground atmosphere and fog. This method\n\
+ * uses automatic uniforms so it is always synced with the scene settings.\n\
+ *\n\
+ * @name czm_computeGroundAtmosphereScattering\n\
+ * @glslfunction\n\
+ *\n\
+ * @param {vec3} positionWC The position of the fragment in world coordinates.\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_computeGroundAtmosphereScattering(vec3 positionWC, vec3 lightDirection, out vec3 rayleighColor, out vec3 mieColor, out float opacity) {\n\
+    vec3 cameraToPositionWC = positionWC - czm_viewerPositionWC;\n\
+    vec3 cameraToPositionWCDirection = normalize(cameraToPositionWC);\n\
+    czm_ray primaryRay = czm_ray(czm_viewerPositionWC, cameraToPositionWCDirection);\n\
+\n\
+    float atmosphereInnerRadius = length(positionWC);\n\
+\n\
+    czm_computeScattering(\n\
+        primaryRay,\n\
+        length(cameraToPositionWC),\n\
+        lightDirection,\n\
+        atmosphereInnerRadius,\n\
+        rayleighColor,\n\
+        mieColor,\n\
+        opacity\n\
+    );\n\
+}\n\
+";

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

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