@cesium/engine 6.2.0 → 8.0.0

package/Source/Scene/VoxelTraversal.js

@@ -49,16 +49,14 @@ function VoxelTraversal(
    */
   this._primitive = primitive;
 
-  const length = types.length;
-
   /**
    * @type {Megatexture[]}
    * @readonly
    */
-  this.megatextures = new Array(length);
+  this.megatextures = new Array(types.length);
 
   // TODO make sure to split the maximumTextureMemoryByteLength across all the megatextures
-  for (let i = 0; i < length; i++) {
+  for (let i = 0; i < types.length; i++) {
     const type = types[i];
     const componentCount = MetadataType.getComponentCount(type);
     const componentType = componentTypes[i];
@@ -218,6 +216,18 @@ function VoxelTraversal(
   this.leafNodeTexelSizeUv = new Cartesian2();
 }
 
+/**
+ * Finds a keyframe node in the traversal
+ *
+ * @param {number} megatextureIndex
+ * @returns {KeyframeNode}
+ */
+VoxelTraversal.prototype.findKeyframeNode = function (megatextureIndex) {
+  return this._keyframeNodesInMegatexture.find(function (keyframeNode) {
+    return keyframeNode.megatextureIndex === megatextureIndex;
+  });
+};
+
 function binaryTreeWeightingRecursive(arr, start, end, depth) {
   if (start > end) {
     return;
@@ -382,10 +392,7 @@ VoxelTraversal.prototype.destroy = function () {
  * @private
  */
 function recomputeBoundingVolumesRecursive(that, node) {
-  const primitive = that._primitive;
-  const shape = primitive._shape;
-  const dimensions = primitive._provider.dimensions;
-  node.computeBoundingVolumes(shape, dimensions);
+  node.computeBoundingVolumes(that._primitive._shape);
   if (defined(node.children)) {
     for (let i = 0; i < 8; i++) {
       const child = node.children[i];
@@ -410,12 +417,11 @@ function requestData(that, keyframeNode) {
     return;
   }
 
-  const primitive = that._primitive;
-  const provider = primitive._provider;
+  const provider = that._primitive._provider;
 
   function postRequestSuccess(result) {
     that._simultaneousRequestCount--;
-    const length = primitive._provider.types.length;
+    const length = provider.types.length;
 
     if (!defined(result)) {
       keyframeNode.state = KeyframeNode.LoadState.UNAVAILABLE;
@@ -434,7 +440,7 @@ function requestData(that, keyframeNode) {
         const data = result[i];
         const expectedLength = tileVoxelCount * channelCount;
         if (data.length === expectedLength) {
-          keyframeNode.metadatas[i] = data;
+          keyframeNode.metadata[i] = data;
           // State is received only when all metadata requests have been received
           keyframeNode.state = KeyframeNode.LoadState.RECEIVED;
         } else {
@@ -492,42 +498,22 @@ function loadAndUnload(that, frameState) {
   const frameNumber = that._frameNumber;
   const primitive = that._primitive;
   const shape = primitive._shape;
-  const { dimensions } = primitive;
   const targetScreenSpaceError = primitive.screenSpaceError;
   const priorityQueue = that._priorityQueue;
-  const keyframeLocation = that._keyframeLocation;
   const keyframeCount = that._keyframeCount;
-  const rootNode = that.rootNode;
+
+  const previousKeyframe = CesiumMath.clamp(
+    Math.floor(that._keyframeLocation),
+    0,
+    keyframeCount - 2
+  );
+  const nextKeyframe = previousKeyframe + 1;
 
   const { camera, context, pixelRatio } = frameState;
   const { positionWC, frustum } = camera;
   const screenHeight = context.drawingBufferHeight / pixelRatio;
   const screenSpaceErrorMultiplier = screenHeight / frustum.sseDenominator;
 
-  function keyframePriority(previousKeyframe, keyframe, nextKeyframe) {
-    const keyframeDifference = Math.min(
-      Math.abs(keyframe - previousKeyframe),
-      Math.abs(keyframe - nextKeyframe)
-    );
-    const maxKeyframeDifference = Math.max(
-      previousKeyframe,
-      keyframeCount - nextKeyframe - 1,
-      1
-    );
-    const keyframeFactor = Math.pow(
-      1.0 - keyframeDifference / maxKeyframeDifference,
-      4.0
-    );
-    const binaryTreeFactor = Math.exp(
-      -that._binaryTreeKeyframeWeighting[keyframe]
-    );
-    return CesiumMath.lerp(
-      binaryTreeFactor,
-      keyframeFactor,
-      0.15 + 0.85 * keyframeFactor
-    );
-  }
-
   /**
    * @ignore
    * @param {SpatialNode} spatialNode
@@ -545,13 +531,6 @@ function loadAndUnload(that, frameState) {
     }
     spatialNode.visitedFrameNumber = frameNumber;
 
-    const previousKeyframe = CesiumMath.clamp(
-      Math.floor(keyframeLocation),
-      0,
-      keyframeCount - 2
-    );
-    const nextKeyframe = previousKeyframe + 1;
-
     // Create keyframe nodes at the playhead.
     // If they already exist, nothing will be created.
     if (keyframeCount === 1) {
@@ -561,16 +540,21 @@ function loadAndUnload(that, frameState) {
         spatialNode.createKeyframeNode(k);
       }
     }
-    const ssePriority = mapInfiniteRangeToZeroOne(spatialNode.screenSpaceError);
+    const { screenSpaceError, keyframeNodes } = spatialNode;
+    const ssePriority = mapInfiniteRangeToZeroOne(screenSpaceError);
 
     let hasLoadedKeyframe = false;
-    const keyframeNodes = spatialNode.keyframeNodes;
     for (let i = 0; i < keyframeNodes.length; i++) {
       const keyframeNode = keyframeNodes[i];
 
       keyframeNode.priority =
         10.0 * ssePriority +
-        keyframePriority(previousKeyframe, keyframeNode.keyframe, nextKeyframe);
+        keyframePriority(
+          previousKeyframe,
+          keyframeNode.keyframe,
+          nextKeyframe,
+          that
+        );
 
       if (
         keyframeNode.state !== KeyframeNode.LoadState.UNAVAILABLE &&
@@ -584,16 +568,14 @@ function loadAndUnload(that, frameState) {
       }
     }
 
-    const meetsScreenSpaceError =
-      spatialNode.screenSpaceError < targetScreenSpaceError;
-    if (meetsScreenSpaceError || !hasLoadedKeyframe) {
+    if (screenSpaceError < targetScreenSpaceError || !hasLoadedKeyframe) {
       // Free up memory
       spatialNode.children = undefined;
       return;
     }
 
     if (!defined(spatialNode.children)) {
-      spatialNode.constructChildNodes(shape, dimensions);
+      spatialNode.constructChildNodes(shape);
     }
     for (let childIndex = 0; childIndex < 8; childIndex++) {
       const child = spatialNode.children[childIndex];
@@ -601,9 +583,11 @@ function loadAndUnload(that, frameState) {
     }
   }
 
+  // Add all the nodes to the queue, to sort them by priority.
   priorityQueue.reset();
-  addToQueueRecursive(rootNode, CullingVolume.MASK_INDETERMINATE);
+  addToQueueRecursive(that.rootNode, CullingVolume.MASK_INDETERMINATE);
 
+  // Move the nodes from the queue to array of high priority nodes.
   const highPriorityKeyframeNodes = that._highPriorityKeyframeNodes;
   let highPriorityKeyframeNodeCount = 0;
   let highPriorityKeyframeNode;
@@ -616,6 +600,8 @@ function loadAndUnload(that, frameState) {
     highPriorityKeyframeNodeCount++;
   }
 
+  // Sort the list of keyframe nodes in the megatexture by priority, so
+  // we can remove the lowest priority nodes if we need space.
   const keyframeNodesInMegatexture = that._keyframeNodesInMegatexture;
   // TODO: some of the megatexture state should be stored once, not duplicate for each megatexture
   const megatexture = that.megatextures[0];
@@ -628,6 +614,8 @@ function loadAndUnload(that, frameState) {
     return b.highPriorityFrameNumber - a.highPriorityFrameNumber;
   });
 
+  // Add the high priority nodes to the megatexture,
+  // removing existing lower-priority nodes if necessary.
   let destroyedCount = 0;
   let addedCount = 0;
 
@@ -675,6 +663,40 @@ function loadAndUnload(that, frameState) {
   }
 }
 
+/**
+ * Compute a priority for a keyframe node.
+ *
+ * @private
+ * @param {number} previousKeyframe
+ * @param {number} keyframe
+ * @param {number} nextKeyframe
+ * @param {VoxelTraversal} traversal
+ * @returns {number} The computed priority
+ */
+function keyframePriority(previousKeyframe, keyframe, nextKeyframe, traversal) {
+  const keyframeDifference = Math.min(
+    Math.abs(keyframe - previousKeyframe),
+    Math.abs(keyframe - nextKeyframe)
+  );
+  const maxKeyframeDifference = Math.max(
+    previousKeyframe,
+    traversal._keyframeCount - nextKeyframe - 1,
+    1
+  );
+  const keyframeFactor = Math.pow(
+    1.0 - keyframeDifference / maxKeyframeDifference,
+    4.0
+  );
+  const binaryTreeFactor = Math.exp(
+    -traversal._binaryTreeKeyframeWeighting[keyframe]
+  );
+  return CesiumMath.lerp(
+    binaryTreeFactor,
+    keyframeFactor,
+    0.15 + 0.85 * keyframeFactor
+  );
+}
+
 /**
  * @function
  *

package/Source/Scene/buildVoxelDrawCommands.js

@@ -58,8 +58,17 @@ function buildVoxelDrawCommands(primitive, context) {
   // Compile shaders
   const shaderBuilderPick = shaderBuilder.clone();
   shaderBuilderPick.addDefine("PICKING", undefined, ShaderDestination.FRAGMENT);
+  const shaderBuilderPickVoxel = shaderBuilder.clone();
+  shaderBuilderPickVoxel.addDefine(
+    "PICKING_VOXEL",
+    undefined,
+    ShaderDestination.FRAGMENT
+  );
   const shaderProgram = shaderBuilder.buildShaderProgram(context);
   const shaderProgramPick = shaderBuilderPick.buildShaderProgram(context);
+  const shaderProgramPickVoxel = shaderBuilderPickVoxel.buildShaderProgram(
+    context
+  );
   const renderState = RenderState.fromCache({
     cull: {
       enabled: true,
@@ -98,6 +107,14 @@ function buildVoxelDrawCommands(primitive, context) {
   drawCommandPick.shaderProgram = shaderProgramPick;
   drawCommandPick.pickOnly = true;
 
+  // Create the pick voxels draw command
+  const drawCommandPickVoxel = DrawCommand.shallowClone(
+    drawCommand,
+    new DrawCommand()
+  );
+  drawCommandPickVoxel.shaderProgram = shaderProgramPickVoxel;
+  drawCommandPickVoxel.pickOnly = true;
+
   // Delete the old shader programs
   if (defined(primitive._drawCommand)) {
     const command = primitive._drawCommand;
@@ -109,9 +126,15 @@ function buildVoxelDrawCommands(primitive, context) {
     command.shaderProgram =
       command.shaderProgram && command.shaderProgram.destroy();
   }
+  if (defined(primitive._drawCommandPickVoxel)) {
+    const command = primitive._drawCommandPickVoxel;
+    command.shaderProgram =
+      command.shaderProgram && command.shaderProgram.destroy();
+  }
 
   primitive._drawCommand = drawCommand;
   primitive._drawCommandPick = drawCommandPick;
+  primitive._drawCommandPickVoxel = drawCommandPickVoxel;
 }
 
 export default buildVoxelDrawCommands;

package/Source/Scene/createGooglePhotorealistic3DTileset.js

@@ -46,6 +46,7 @@ async function createGooglePhotorealistic3DTileset(key, options) {
     options.maximumCacheOverflowBytes,
     1024 * 1024 * 1024
   );
+  options.enableCollision = defaultValue(options.enableCollision, true);
 
   key = defaultValue(key, GoogleMaps.defaultApiKey);
   if (!defined(key)) {

package/Source/Scene/processVoxelProperties.js

@@ -153,6 +153,8 @@ function processVoxelProperties(renderResources, primitive) {
   shaderBuilder.addStructField(voxelStructId, "vec3", "viewDirWorld");
   shaderBuilder.addStructField(voxelStructId, "vec3", "surfaceNormal");
   shaderBuilder.addStructField(voxelStructId, "float", "travelDistance");
+  shaderBuilder.addStructField(voxelStructId, "int", "tileIndex");
+  shaderBuilder.addStructField(voxelStructId, "int", "sampleIndex");
 
   // FragmentInput struct
   const fragmentInputStructId = "FragmentInput";

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