@cesium/engine 6.2.0 → 7.0.0

package/Source/Scene/Scene.js

@@ -18,6 +18,7 @@ import Event from "../Core/Event.js";
 import GeographicProjection from "../Core/GeographicProjection.js";
 import GeometryInstance from "../Core/GeometryInstance.js";
 import GeometryPipeline from "../Core/GeometryPipeline.js";
+import HeightReference from "./HeightReference.js";
 import Intersect from "../Core/Intersect.js";
 import JulianDate from "../Core/JulianDate.js";
 import CesiumMath from "../Core/Math.js";
@@ -37,6 +38,7 @@ import Context from "../Renderer/Context.js";
 import ContextLimits from "../Renderer/ContextLimits.js";
 import Pass from "../Renderer/Pass.js";
 import RenderState from "../Renderer/RenderState.js";
+import Atmosphere from "./Atmosphere.js";
 import BrdfLutGenerator from "./BrdfLutGenerator.js";
 import Camera from "./Camera.js";
 import Cesium3DTilePass from "./Cesium3DTilePass.js";
@@ -46,6 +48,7 @@ import DebugCameraPrimitive from "./DebugCameraPrimitive.js";
 import DepthPlane from "./DepthPlane.js";
 import DerivedCommand from "./DerivedCommand.js";
 import DeviceOrientationCameraController from "./DeviceOrientationCameraController.js";
+import DynamicAtmosphereLightingType from "./DynamicAtmosphereLightingType.js";
 import Fog from "./Fog.js";
 import FrameState from "./FrameState.js";
 import GlobeTranslucencyState from "./GlobeTranslucencyState.js";
@@ -164,6 +167,7 @@ function Scene(options) {
   this._groundPrimitives = new PrimitiveCollection();
 
   this._globeHeight = undefined;
+  this._globeHeightDirty = undefined;
   this._cameraUnderground = false;
 
   this._logDepthBuffer = context.fragmentDepth;
@@ -512,6 +516,14 @@ function Scene(options) {
    */
   this.cameraEventWaitTime = 500.0;
 
+  /**
+   * Settings for atmosphere lighting effects affecting 3D Tiles and model rendering. This is not to be confused with
+   * {@link Scene#skyAtmosphere} which is responsible for rendering the sky.
+   *
+   * @type {Atmosphere}
+   */
+  this.atmosphere = new Atmosphere();
+
   /**
    * Blends the atmosphere to geometry far from the camera for horizon views. Allows for additional
    * performance improvements by rendering less geometry and dispatching less terrain requests.
@@ -738,6 +750,11 @@ function updateGlobeListeners(scene, globe) {
         requestRenderAfterFrame(scene)
       )
     );
+    removeGlobeCallbacks.push(
+      globe.tileLoadProgressEvent.addEventListener(() => {
+        scene._globeHeightDirty = true;
+      })
+    );
   }
   scene._removeGlobeCallbacks = removeGlobeCallbacks;
 }
@@ -3167,6 +3184,7 @@ Scene.prototype.updateEnvironment = function () {
   const environmentState = this._environmentState;
   const renderPass = frameState.passes.render;
   const offscreenPass = frameState.passes.offscreen;
+  const atmosphere = this.atmosphere;
   const skyAtmosphere = this.skyAtmosphere;
   const globe = this.globe;
   const globeTranslucencyState = this._globeTranslucencyState;
@@ -3185,17 +3203,19 @@ Scene.prototype.updateEnvironment = function () {
   } else {
     if (defined(skyAtmosphere)) {
       if (defined(globe)) {
-        skyAtmosphere.setDynamicAtmosphereColor(
-          globe.enableLighting && globe.dynamicAtmosphereLighting,
-          globe.dynamicAtmosphereLightingFromSun
+        skyAtmosphere.setDynamicLighting(
+          DynamicAtmosphereLightingType.fromGlobeFlags(globe)
         );
         environmentState.isReadyForAtmosphere =
           environmentState.isReadyForAtmosphere ||
           !globe.show ||
           globe._surface._tilesToRender.length > 0;
       } else {
+        const dynamicLighting = atmosphere.dynamicLighting;
+        skyAtmosphere.setDynamicLighting(dynamicLighting);
         environmentState.isReadyForAtmosphere = true;
       }
+
       environmentState.skyAtmosphereCommand = skyAtmosphere.update(
         frameState,
         globe
@@ -3601,19 +3621,178 @@ function callAfterRenderFunctions(scene) {
 }
 
 function getGlobeHeight(scene) {
-  const globe = scene._globe;
+  if (scene.mode === SceneMode.MORPHING) {
+    return;
+  }
+
   const camera = scene.camera;
   const cartographic = camera.positionCartographic;
-  if (defined(globe) && globe.show && defined(cartographic)) {
-    return globe.getHeight(cartographic);
+  return scene.getHeight(cartographic);
+}
+
+/**
+ * Gets the height of the loaded surface at the cartographic position.
+ * @param {Cartographic} cartographic The cartographic position.
+ * @param {HeightReference} [heightReference=CLAMP_TO_GROUND] Based on the height reference value, determines whether to ignore heights from 3D Tiles or terrain.
+ * @private
+ */
+Scene.prototype.getHeight = function (cartographic, heightReference) {
+  if (!defined(cartographic)) {
+    return undefined;
+  }
+
+  const ignore3dTiles =
+    heightReference === HeightReference.CLAMP_TO_TERRAIN ||
+    heightReference === HeightReference.RELATIVE_TO_TERRAIN;
+
+  const ignoreTerrain =
+    heightReference === HeightReference.CLAMP_TO_3D_TILE ||
+    heightReference === HeightReference.RELATIVE_TO_3D_TILE;
+
+  if (!defined(cartographic)) {
+    return;
   }
+
+  let maxHeight = Number.NEGATIVE_INFINITY;
+
+  if (!ignore3dTiles) {
+    const length = this.primitives.length;
+    for (let i = 0; i < length; ++i) {
+      const primitive = this.primitives.get(i);
+      if (
+        !primitive.isCesium3DTileset ||
+        !primitive.show ||
+        primitive.disableCollision
+      ) {
+        continue;
+      }
+
+      const result = primitive.getHeight(cartographic, this);
+      if (defined(result) && result > maxHeight) {
+        maxHeight = result;
+      }
+    }
+  }
+
+  const globe = this._globe;
+  if (!ignoreTerrain && defined(globe) && globe.show) {
+    const result = globe.getHeight(cartographic);
+    if (result > maxHeight) {
+      maxHeight = result;
+    }
+  }
+
+  if (maxHeight > Number.NEGATIVE_INFINITY) {
+    return maxHeight;
+  }
+
   return undefined;
-}
+};
+
+const updateHeightScratchCartographic = new Cartographic();
+/**
+ * Calls the callback when a new tile is rendered that contains the given cartographic. The only parameter
+ * is the cartesian position on the tile.
+ *
+ * @private
+ *
+ * @param {Cartographic} cartographic The cartographic position.
+ * @param {Function} callback The function to be called when a new tile is loaded containing the updated cartographic.
+ * @param {HeightReference} [heightReference=CLAMP_TO_GROUND] Based on the height reference value, determines whether to ignore heights from 3D Tiles or terrain.
+ * @returns {Function} The function to remove this callback from the quadtree.
+ */
+Scene.prototype.updateHeight = function (
+  cartographic,
+  callback,
+  heightReference
+) {
+  //>>includeStart('debug', pragmas.debug);
+  Check.typeOf.func("callback", callback);
+  //>>includeEnd('debug');
+
+  const callbackWrapper = () => {
+    Cartographic.clone(cartographic, updateHeightScratchCartographic);
+
+    const height = this.getHeight(cartographic, heightReference);
+    if (defined(height)) {
+      updateHeightScratchCartographic.height = height;
+      callback(updateHeightScratchCartographic);
+    }
+  };
+
+  const ignore3dTiles =
+    heightReference === HeightReference.CLAMP_TO_TERRAIN ||
+    heightReference === HeightReference.RELATIVE_TO_TERRAIN;
+
+  const ignoreTerrain =
+    heightReference === HeightReference.CLAMP_TO_3D_TILE ||
+    heightReference === HeightReference.RELATIVE_TO_3D_TILE;
+
+  let terrainRemoveCallback;
+  if (!ignoreTerrain && defined(this.globe)) {
+    terrainRemoveCallback = this.globe._surface.updateHeight(
+      cartographic,
+      callbackWrapper
+    );
+  }
+
+  let tilesetRemoveCallbacks = {};
+  const ellipsoid = this.globe?.ellipsoid;
+  const createPrimitiveEventListener = (primitive) => {
+    if (
+      ignore3dTiles ||
+      !primitive.isCesium3DTileset ||
+      primitive.disableCollision
+    ) {
+      return;
+    }
+
+    const tilesetRemoveCallback = primitive.updateHeight(
+      cartographic,
+      callbackWrapper,
+      ellipsoid
+    );
+    tilesetRemoveCallbacks[primitive.id] = tilesetRemoveCallback;
+  };
+
+  if (!ignore3dTiles) {
+    const length = this.primitives.length;
+    for (let i = 0; i < length; ++i) {
+      const primitive = this.primitives.get(i);
+      createPrimitiveEventListener(primitive);
+    }
+  }
+
+  const removeAddedListener = this.primitives.primitiveAdded.addEventListener(
+    createPrimitiveEventListener
+  );
+  const removeRemovedListener = this.primitives.primitiveRemoved.addEventListener(
+    (primitive) => {
+      if (!primitive.isCesium3DTileset) {
+        return;
+      }
+
+      tilesetRemoveCallbacks[primitive.id]();
+      delete tilesetRemoveCallbacks[primitive.id];
+    }
+  );
+
+  const removeCallback = () => {
+    terrainRemoveCallback = terrainRemoveCallback && terrainRemoveCallback();
+    Object.values(tilesetRemoveCallbacks).forEach((tilesetRemoveCallback) =>
+      tilesetRemoveCallback()
+    );
+    tilesetRemoveCallbacks = {};
+    removeAddedListener();
+    removeRemovedListener();
+  };
+
+  return removeCallback;
+};
 
 function isCameraUnderground(scene) {
   const camera = scene.camera;
   const mode = scene._mode;
-  const globe = scene.globe;
   const cameraController = scene._screenSpaceCameraController;
   const cartographic = camera.positionCartographic;
 
@@ -3627,12 +3806,7 @@ function isCameraUnderground(scene) {
     return true;
   }
 
-  if (
-    !defined(globe) ||
-    !globe.show ||
-    mode === SceneMode.SCENE2D ||
-    mode === SceneMode.MORPHING
-  ) {
+  if (mode === SceneMode.SCENE2D || mode === SceneMode.MORPHING) {
     return false;
   }
 
@@ -3653,7 +3827,10 @@ Scene.prototype.initializeFrame = function () {
 
   this._tweens.update();
 
-  this._globeHeight = getGlobeHeight(this);
+  if (this._globeHeightDirty) {
+    this._globeHeight = getGlobeHeight(this);
+    this._globeHeightDirty = false;
+  }
   this._cameraUnderground = isCameraUnderground(this);
   this._globeTranslucencyState.update(this);
 
@@ -3740,6 +3917,7 @@ function render(scene) {
   }
   frameState.backgroundColor = backgroundColor;
 
+  frameState.atmosphere = scene.atmosphere;
   scene.fog.update(frameState);
 
   us.update(frameState);
@@ -3828,8 +4006,12 @@ Scene.prototype.render = function (time) {
     time = JulianDate.now();
   }
 
-  // Determine if shouldRender
   const cameraChanged = this._view.checkForCameraUpdates(this);
+  if (cameraChanged) {
+    this._globeHeightDirty = true;
+  }
+
+  // Determine if should render a new frame in request render mode
   let shouldRender =
     !this.requestRenderMode ||
     this._renderRequested ||

package/Source/Scene/ScreenSpaceCameraController.js

@@ -2861,16 +2861,12 @@ function adjustHeightForTerrain(controller) {
   const mode = scene.mode;
   const globe = scene.globe;
 
-  if (
-    !defined(globe) ||
-    mode === SceneMode.SCENE2D ||
-    mode === SceneMode.MORPHING
-  ) {
+  if (mode === SceneMode.SCENE2D || mode === SceneMode.MORPHING) {
     return;
   }
 
   const camera = scene.camera;
-  const ellipsoid = globe.ellipsoid;
+  const ellipsoid = defaultValue(globe?.ellipsoid, Ellipsoid.WGS84);
   const projection = scene.mapProjection;
 
   let transform;

package/Source/Scene/SkyAtmosphere.js

@@ -217,14 +217,13 @@ Object.defineProperties(SkyAtmosphere.prototype, {
 });
 
 /**
+ * Set the dynamic lighting enum value for the shader
+ * @param {DynamicAtmosphereLightingType} lightingEnum The enum that determines the dynamic atmosphere light source
+ *
  * @private
  */
-SkyAtmosphere.prototype.setDynamicAtmosphereColor = function (
-  enableLighting,
-  useSunDirection
-) {
-  const lightEnum = enableLighting ? (useSunDirection ? 2.0 : 1.0) : 0.0;
-  this._radiiAndDynamicAtmosphereColor.z = lightEnum;
+SkyAtmosphere.prototype.setDynamicLighting = function (lightingEnum) {
+  this._radiiAndDynamicAtmosphereColor.z = lightingEnum;
 };
 
 const scratchModelMatrix = new Matrix4();

package/Source/Scene/Terrain.js

@@ -1,5 +1,6 @@
 import Check from "../Core/Check.js";
 import Event from "../Core/Event.js";
+import createWorldBathymetryAsync from "../Core/createWorldBathymetryAsync.js";
 import createWorldTerrainAsync from "../Core/createWorldTerrainAsync.js";
 
 /**
@@ -156,6 +157,54 @@ Terrain.fromWorldTerrain = function (options) {
   return new Terrain(createWorldTerrainAsync(options));
 };
 
+/**
+ * Creates a {@link Terrain} instance for {@link https://cesium.com/content/#cesium-world-bathymetry|Cesium World Bathymetry}.
+ *
+ * @function
+ *
+ * @param {Object} [options] Object with the following properties:
+ * @param {Boolean} [options.requestVertexNormals=false] Flag that indicates if the client should request additional lighting information from the server if available.
+ * @returns {Terrain} An asynchronous helper object for a CesiumTerrainProvider
+ *
+ * @see Ion
+ * @see createWorldBathymetryAsync
+ *
+ * @example
+ * // Create Cesium World Bathymetry with default settings
+ * const viewer = new Cesium.Viewer("cesiumContainer", {
+ *   terrain: Cesium.Terrain.fromWorldBathymetry)
+ * });
+ *
+ * @example
+ * // Create Cesium World Terrain with normals.
+ * const viewer1 = new Cesium.Viewer("cesiumContainer", {
+ *   terrain: Cesium.Terrain.fromWorldBathymetry({
+ *      requestVertexNormals: true
+ *    });
+ * });
+ *
+ * @example
+ * // Handle loading events
+ * const bathymetry = Cesium.Terrain.fromWorldBathymetry();
+ *
+ * scene.setTerrain(bathymetry);
+ *
+ * bathymetry.readyEvent.addEventListener(provider => {
+ *   scene.globe.enableLighting = true;
+ *
+ *   bathymetry.provider.errorEvent.addEventListener(error => {
+ *     alert(`Encountered an error while loading bathymetric terrain tiles! ${error}`);
+ *   });
+ * });
+ *
+ * bathymetry.errorEvent.addEventListener(error => {
+ *   alert(`Encountered an error while creating bathymetric terrain! ${error}`);
+ * });
+ */
+Terrain.fromWorldBathymetry = function (options) {
+  return new Terrain(createWorldBathymetryAsync(options));
+};
+
 function handleError(errorEvent, error) {
   if (errorEvent.numberOfListeners > 0) {
     errorEvent.raiseEvent(error);

package/Source/Scene/TileBoundingS2Cell.js

@@ -330,7 +330,7 @@ Object.defineProperties(TileBoundingS2Cell.prototype, {
   /**
    * The underlying bounding volume.
    *
-   * @memberof TileOrientedBoundingBox.prototype
+   * @memberof TileBoundingS2Cell.prototype
    *
    * @type {object}
    * @readonly
@@ -343,7 +343,7 @@ Object.defineProperties(TileBoundingS2Cell.prototype, {
   /**
    * The underlying bounding sphere.
    *
-   * @memberof TileOrientedBoundingBox.prototype
+   * @memberof TileBoundingS2Cell.prototype
    *
    * @type {BoundingSphere}
    * @readonly

package/Source/Scene/Tileset3DTileContent.js

@@ -168,6 +168,10 @@ Tileset3DTileContent.prototype.applyStyle = function (style) {};
 
 Tileset3DTileContent.prototype.update = function (tileset, frameState) {};
 
+Tileset3DTileContent.prototype.pick = function (ray, frameState, result) {
+  return undefined;
+};
+
 Tileset3DTileContent.prototype.isDestroyed = function () {
   return false;
 };

package/Source/Scene/Vector3DTileContent.js

@@ -727,6 +727,10 @@ Vector3DTileContent.prototype.update = function (tileset, frameState) {
   }
 };
 
+Vector3DTileContent.prototype.pick = function (ray, frameState, result) {
+  return undefined;
+};
+
 Vector3DTileContent.prototype.getPolylinePositions = function (batchId) {
   const polylines = this._polylines;
   if (!defined(polylines)) {

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