@cesium/engine 6.1.1 → 7.0.0

package/Source/Scene/DynamicAtmosphereLightingType.js

@@ -0,0 +1,56 @@
+/**
+ * Atmosphere lighting effects (sky atmosphere, ground atmosphere, fog) can be
+ * further modified with dynamic lighting from the sun or other light source
+ * that changes over time. This enum determines which light source to use.
+ *
+ * @enum {number}
+ */
+const DynamicAtmosphereLightingType = {
+  /**
+   * Do not use dynamic atmosphere lighting. Atmosphere lighting effects will
+   * be lit from directly above rather than using the scene's light source.
+   *
+   * @type {number}
+   * @constant
+   */
+  NONE: 0,
+  /**
+   * Use the scene's current light source for dynamic atmosphere lighting.
+   *
+   * @type {number}
+   * @constant
+   */
+  SCENE_LIGHT: 1,
+  /**
+   * Force the dynamic atmosphere lighting to always use the sunlight direction,
+   * even if the scene uses a different light source.
+   *
+   * @type {number}
+   * @constant
+   */
+  SUNLIGHT: 2,
+};
+
+/**
+ * Get the lighting enum from the older globe flags
+ *
+ * @param {Globe} globe The globe
+ * @return {DynamicAtmosphereLightingType} The corresponding enum value
+ *
+ * @private
+ */
+DynamicAtmosphereLightingType.fromGlobeFlags = function (globe) {
+  const lightingOn = globe.enableLighting && globe.dynamicAtmosphereLighting;
+  if (!lightingOn) {
+    return DynamicAtmosphereLightingType.NONE;
+  }
+
+  // Force sunlight
+  if (globe.dynamicAtmosphereLightingFromSun) {
+    return DynamicAtmosphereLightingType.SUNLIGHT;
+  }
+
+  return DynamicAtmosphereLightingType.SCENE_LIGHT;
+};
+
+export default Object.freeze(DynamicAtmosphereLightingType);

package/Source/Scene/Empty3DTileContent.js

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

package/Source/Scene/Fog.js

@@ -173,6 +173,7 @@ Fog.prototype.update = function (frameState) {
     frameState.mode !== SceneMode.SCENE3D
   ) {
     frameState.fog.enabled = false;
+    frameState.fog.density = 0;
     return;
   }
 

package/Source/Scene/FrameState.js

@@ -254,7 +254,8 @@ function FrameState(context, creditDisplay, jobScheduler) {
   /**
    * @typedef FrameState.Fog
    * @type {object}
-   * @property {boolean} enabled <code>true</code> if fog is enabled, <code>false</code> otherwise.
+   * @property {boolean} enabled <code>true</code> if fog is enabled, <code>false</code> otherwise. This affects both fog culling and rendering.
+   * @property {boolean} renderable <code>true</code> if fog should be rendered, <code>false</code> if not. This flag should be checked in combination with fog.enabled.
    * @property {number} density A positive number used to mix the color and fog color based on camera distance.
    * @property {number} sse A scalar used to modify the screen space error of geometry partially in fog.
    * @property {number} minimumBrightness The minimum brightness of terrain with fog applied.
@@ -269,24 +270,31 @@ function FrameState(context, creditDisplay, jobScheduler) {
      * @default false
      */
     enabled: false,
+    renderable: false,
     density: undefined,
     sse: undefined,
     minimumBrightness: undefined,
   };
 
   /**
-   * A scalar used to exaggerate the terrain.
+   * The current Atmosphere
+   * @type {Atmosphere}
+   */
+  this.atmosphere = undefined;
+
+  /**
+   * A scalar used to vertically exaggerate the scene
    * @type {number}
    * @default 1.0
    */
-  this.terrainExaggeration = 1.0;
+  this.verticalExaggeration = 1.0;
 
   /**
-   * The height relative to which terrain is exaggerated.
+   * The height relative to which the scene is vertically exaggerated.
    * @type {number}
    * @default 0.0
    */
-  this.terrainExaggerationRelativeHeight = 0.0;
+  this.verticalExaggerationRelativeHeight = 0.0;
 
   /**
    * @typedef FrameState.ShadowState

package/Source/Scene/Geometry3DTileContent.js

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

package/Source/Scene/Globe.js

@@ -28,6 +28,7 @@ import ImageryLayerCollection from "./ImageryLayerCollection.js";
 import QuadtreePrimitive from "./QuadtreePrimitive.js";
 import SceneMode from "./SceneMode.js";
 import ShadowMode from "./ShadowMode.js";
+import deprecationWarning from "../Core/deprecationWarning.js";
 
 /**
  * The globe rendered in the scene, including its terrain ({@link Globe#terrainProvider})
@@ -340,25 +341,9 @@ function Globe(ellipsoid) {
    */
   this.atmosphereBrightnessShift = 0.0;
 
-  /**
-   * A scalar used to exaggerate the terrain. Defaults to <code>1.0</code> (no exaggeration).
-   * A value of <code>2.0</code> scales the terrain by 2x.
-   * A value of <code>0.0</code> makes the terrain completely flat.
-   * Note that terrain exaggeration will not modify any other primitive as they are positioned relative to the ellipsoid.
-   * @type {number}
-   * @default 1.0
-   */
-  this.terrainExaggeration = 1.0;
-
-  /**
-   * The height from which terrain is exaggerated. Defaults to <code>0.0</code> (scaled relative to ellipsoid surface).
-   * Terrain that is above this height will scale upwards and terrain that is below this height will scale downwards.
-   * Note that terrain exaggeration will not modify any other primitive as they are positioned relative to the ellipsoid.
-   * If {@link Globe#terrainExaggeration} is <code>1.0</code> this value will have no effect.
-   * @type {number}
-   * @default 0.0
-   */
-  this.terrainExaggerationRelativeHeight = 0.0;
+  this._terrainExaggerationChanged = false;
+  this._terrainExaggeration = 1.0;
+  this._terrainExaggerationRelativeHeight = 0.0;
 
   /**
    * Whether to show terrain skirts. Terrain skirts are geometry extending downwards from a tile's edges used to hide seams between neighboring tiles.
@@ -538,6 +523,68 @@ Object.defineProperties(Globe.prototype, {
       return this._terrainProviderChanged;
     },
   },
+  /**
+   * A scalar used to exaggerate the terrain. Defaults to <code>1.0</code> (no exaggeration).
+   * A value of <code>2.0</code> scales the terrain by 2x.
+   * A value of <code>0.0</code> makes the terrain completely flat.
+   * Note that terrain exaggeration will not modify any other primitive as they are positioned relative to the ellipsoid.
+   *
+   * @memberof Globe.prototype
+   * @type {number}
+   * @default 1.0
+   *
+   * @deprecated
+   */
+  terrainExaggeration: {
+    get: function () {
+      deprecationWarning(
+        "Globe.terrainExaggeration",
+        "Globe.terrainExaggeration was deprecated in CesiumJS 1.113.  It will be removed in CesiumJS 1.116. Use Scene.verticalExaggeration instead."
+      );
+      return this._terrainExaggeration;
+    },
+    set: function (value) {
+      deprecationWarning(
+        "Globe.terrainExaggeration",
+        "Globe.terrainExaggeration was deprecated in CesiumJS 1.113.  It will be removed in CesiumJS 1.116. Use Scene.verticalExaggeration instead."
+      );
+      if (value !== this._terrainExaggeration) {
+        this._terrainExaggeration = value;
+        this._terrainExaggerationChanged = true;
+      }
+    },
+  },
+  /**
+   * The height from which terrain is exaggerated. Defaults to <code>0.0</code> (scaled relative to ellipsoid surface).
+   * Terrain that is above this height will scale upwards and terrain that is below this height will scale downwards.
+   * Note that terrain exaggeration will not modify any other primitive as they are positioned relative to the ellipsoid.
+   * If {@link Globe#terrainExaggeration} is <code>1.0</code> this value will have no effect.
+   *
+   * @memberof Globe.prototype
+   * @type {number}
+   * @default 0.0
+   *
+   * @deprecated
+   */
+  terrainExaggerationRelativeHeight: {
+    get: function () {
+      deprecationWarning(
+        "Globe.terrainExaggerationRelativeHeight",
+        "Globe.terrainExaggerationRelativeHeight was deprecated in CesiumJS 1.113.  It will be removed in CesiumJS 1.116. Use Scene.verticalExaggerationRelativeHeight instead."
+      );
+      return this._terrainExaggerationRelativeHeight;
+    },
+    set: function (value) {
+      deprecationWarning(
+        "Globe.terrainExaggerationRelativeHeight",
+        "Globe.terrainExaggerationRelativeHeight was deprecated in CesiumJS 1.113.  It will be removed in CesiumJS 1.116. Use Scene.verticalExaggerationRelativeHeight instead."
+      );
+      if (value !== this._terrainExaggerationRelativeHeight) {
+        this._terrainExaggerationRelativeHeight = value;
+        this._terrainExaggerationChanged = true;
+      }
+    },
+  },
   /**
    * Gets an event that's raised when the length of the tile load queue has changed since the last render frame.  When the load queue is empty,
    * all terrain and imagery for the current view have been loaded.  The event passes the new length of the tile load queue.
@@ -644,8 +691,8 @@ function makeShadersDirty(globe) {
 
   const requireNormals =
     defined(globe._material) &&
-    (globe._material.shaderSource.match(/slope/) ||
-      globe._material.shaderSource.match("normalEC"));
+    (defined(globe._material.shaderSource.match(/slope/)) ||
+      defined(globe._material.shaderSource.match("normalEC")));
 
   const fragmentSources = [AtmosphereCommon, GroundAtmosphere];
   if (
@@ -1059,6 +1106,7 @@ Globe.prototype.beginFrame = function (frameState) {
     tileProvider.undergroundColor = this._undergroundColor;
     tileProvider.undergroundColorAlphaByDistance = this._undergroundColorAlphaByDistance;
     tileProvider.lambertDiffuseMultiplier = this.lambertDiffuseMultiplier;
+
     surface.beginFrame(frameState);
   }
 };

package/Source/Scene/GlobeSurfaceTile.js

@@ -463,9 +463,9 @@ GlobeSurfaceTile.prototype.updateExaggeration = function (
   }
 
   // Check the tile's terrain encoding to see if it has been exaggerated yet
-  const exaggeration = frameState.terrainExaggeration;
+  const exaggeration = frameState.verticalExaggeration;
   const exaggerationRelativeHeight =
-    frameState.terrainExaggerationRelativeHeight;
+    frameState.verticalExaggerationRelativeHeight;
   const hasExaggerationScale = exaggeration !== 1.0;
 
   const encoding = mesh.encoding;
@@ -790,9 +790,9 @@ function transform(surfaceTile, frameState, terrainProvider, x, y, level) {
   createMeshOptions.x = x;
   createMeshOptions.y = y;
   createMeshOptions.level = level;
-  createMeshOptions.exaggeration = frameState.terrainExaggeration;
+  createMeshOptions.exaggeration = frameState.verticalExaggeration;
   createMeshOptions.exaggerationRelativeHeight =
-    frameState.terrainExaggerationRelativeHeight;
+    frameState.verticalExaggerationRelativeHeight;
   createMeshOptions.throttle = true;
 
   const terrainData = surfaceTile.terrainData;

package/Source/Scene/GlobeSurfaceTileProvider.js

@@ -25,7 +25,7 @@ import OrthographicFrustum from "../Core/OrthographicFrustum.js";
 import PrimitiveType from "../Core/PrimitiveType.js";
 import Rectangle from "../Core/Rectangle.js";
 import SphereOutlineGeometry from "../Core/SphereOutlineGeometry.js";
-import TerrainExaggeration from "../Core/TerrainExaggeration.js";
+import VerticalExaggeration from "../Core/VerticalExaggeration.js";
 import TerrainQuantization from "../Core/TerrainQuantization.js";
 import Visibility from "../Core/Visibility.js";
 import WebMercatorProjection from "../Core/WebMercatorProjection.js";
@@ -179,8 +179,8 @@ function GlobeSurfaceTileProvider(options) {
   this._hasLoadedTilesThisFrame = false;
   this._hasFillTilesThisFrame = false;
 
-  this._oldTerrainExaggeration = undefined;
-  this._oldTerrainExaggerationRelativeHeight = undefined;
+  this._oldVerticalExaggeration = undefined;
+  this._oldVerticalExaggerationRelativeHeight = undefined;
 }
 
 Object.defineProperties(GlobeSurfaceTileProvider.prototype, {
@@ -448,7 +448,7 @@ GlobeSurfaceTileProvider.prototype.endUpdate = function (frameState) {
     );
   }
 
-  // When terrain exaggeration changes, all of the loaded tiles need to generate
+  // When vertical exaggeration changes, all of the loaded tiles need to generate
   // geodetic surface normals so they can scale properly when rendered.
   // When exaggeration is reset, geodetic surface normals are removed to decrease
   // memory usage. Some tiles might have been constructed with the correct
@@ -460,16 +460,16 @@ GlobeSurfaceTileProvider.prototype.endUpdate = function (frameState) {
   // exaggeration changes.
 
   const quadtree = this.quadtree;
-  const exaggeration = frameState.terrainExaggeration;
+  const exaggeration = frameState.verticalExaggeration;
   const exaggerationRelativeHeight =
-    frameState.terrainExaggerationRelativeHeight;
+    frameState.verticalExaggerationRelativeHeight;
   const exaggerationChanged =
-    this._oldTerrainExaggeration !== exaggeration ||
-    this._oldTerrainExaggerationRelativeHeight !== exaggerationRelativeHeight;
+    this._oldVerticalExaggeration !== exaggeration ||
+    this._oldVerticalExaggerationRelativeHeight !== exaggerationRelativeHeight;
 
   // Keep track of the next time there is a change in exaggeration
-  this._oldTerrainExaggeration = exaggeration;
-  this._oldTerrainExaggerationRelativeHeight = exaggerationRelativeHeight;
+  this._oldVerticalExaggeration = exaggeration;
+  this._oldVerticalExaggerationRelativeHeight = exaggerationRelativeHeight;
 
   if (exaggerationChanged) {
     quadtree.forEachLoadedTile(function (tile) {
@@ -1258,18 +1258,18 @@ function updateTileBoundingRegion(tile, tileProvider, frameState) {
 
   // Update bounding regions from the min and max heights
   if (sourceTile !== undefined) {
-    const exaggeration = frameState.terrainExaggeration;
+    const exaggeration = frameState.verticalExaggeration;
     const exaggerationRelativeHeight =
-      frameState.terrainExaggerationRelativeHeight;
+      frameState.verticalExaggerationRelativeHeight;
     const hasExaggeration = exaggeration !== 1.0;
     if (hasExaggeration) {
       hasBoundingVolumesFromMesh = false;
-      tileBoundingRegion.minimumHeight = TerrainExaggeration.getHeight(
+      tileBoundingRegion.minimumHeight = VerticalExaggeration.getHeight(
         tileBoundingRegion.minimumHeight,
         exaggeration,
         exaggerationRelativeHeight
       );
-      tileBoundingRegion.maximumHeight = TerrainExaggeration.getHeight(
+      tileBoundingRegion.maximumHeight = VerticalExaggeration.getHeight(
         tileBoundingRegion.maximumHeight,
         exaggeration,
         exaggerationRelativeHeight
@@ -1625,8 +1625,8 @@ function createTileUniformMap(frameState, globeSurfaceTileProvider) {
     u_center3D: function () {
       return this.properties.center3D;
     },
-    u_terrainExaggerationAndRelativeHeight: function () {
-      return this.properties.terrainExaggerationAndRelativeHeight;
+    u_verticalExaggerationAndRelativeHeight: function () {
+      return this.properties.verticalExaggerationAndRelativeHeight;
     },
     u_tileRectangle: function () {
       return this.properties.tileRectangle;
@@ -1808,7 +1808,7 @@ function createTileUniformMap(frameState, globeSurfaceTileProvider) {
       modifiedModelView: new Matrix4(),
       tileRectangle: new Cartesian4(),
 
-      terrainExaggerationAndRelativeHeight: new Cartesian2(1.0, 0.0),
+      verticalExaggerationAndRelativeHeight: new Cartesian2(1.0, 0.0),
 
       dayTextures: [],
       dayTextureTranslationAndScale: [],
@@ -2174,9 +2174,9 @@ function addDrawCommandsForTile(tileProvider, tile, frameState) {
   const encoding = mesh.encoding;
   const tileBoundingRegion = surfaceTile.tileBoundingRegion;
 
-  const exaggeration = frameState.terrainExaggeration;
+  const exaggeration = frameState.verticalExaggeration;
   const exaggerationRelativeHeight =
-    frameState.terrainExaggerationRelativeHeight;
+    frameState.verticalExaggerationRelativeHeight;
   const hasExaggeration = exaggeration !== 1.0;
   const hasGeodeticSurfaceNormals = encoding.hasGeodeticSurfaceNormals;
 
@@ -2431,8 +2431,8 @@ function addDrawCommandsForTile(tileProvider, tile, frameState) {
       );
     }
 
-    uniformMapProperties.terrainExaggerationAndRelativeHeight.x = exaggeration;
-    uniformMapProperties.terrainExaggerationAndRelativeHeight.y = exaggerationRelativeHeight;
+    uniformMapProperties.verticalExaggerationAndRelativeHeight.x = exaggeration;
+    uniformMapProperties.verticalExaggerationAndRelativeHeight.y = exaggerationRelativeHeight;
 
     uniformMapProperties.center3D = mesh.center;
     Cartesian3.clone(rtc, uniformMapProperties.rtc);
@@ -2502,7 +2502,9 @@ function addDrawCommandsForTile(tileProvider, tile, frameState) {
       uniformMapProperties.localizedTranslucencyRectangle
     );
 
-    // For performance, use fog in the shader only when the tile is in fog.
+    // For performance, render fog only when fog is enabled and the effect of
+    // fog would be non-negligible. This prevents the shader from running when
+    // the camera is in space, for example.
     const applyFog =
       enableFog &&
       CesiumMath.fog(tile._distance, frameState.fog.density) >

package/Source/Scene/GltfLoader.js

@@ -179,6 +179,7 @@ const GltfLoaderState = {
  * @param {Axis} [options.forwardAxis=Axis.Z] The forward-axis of the glTF model.
  * @param {boolean} [options.loadAttributesAsTypedArray=false] Load all attributes and indices as typed arrays instead of GPU buffers. If the attributes are interleaved in the glTF they will be de-interleaved in the typed array.
  * @param {boolean} [options.loadAttributesFor2D=false] If <code>true</code>, load the positions buffer and any instanced attribute buffers as typed arrays for accurately projecting models to 2D.
+ * @param {boolean} [options.enablePick=false]  If <code>true</code>, load the positions buffer, any instanced attribute buffers, and index buffer as typed arrays for CPU-enabled picking in WebGL1.
  * @param {boolean} [options.loadIndicesForWireframe=false] If <code>true</code>, load the index buffer as both a buffer and typed array. The latter is useful for creating wireframe indices in WebGL1.
  * @param {boolean} [options.loadPrimitiveOutline=true] If <code>true</code>, load outlines from the {@link https://github.com/KhronosGroup/glTF/tree/master/extensions/2.0/Vendor/CESIUM_primitive_outline|CESIUM_primitive_outline} extension. This can be set false to avoid post-processing geometry at load time.
  * @param {boolean} [options.loadForClassification=false] If <code>true</code> and if the model has feature IDs, load the feature IDs and indices as typed arrays. This is useful for batching features for classification.
@@ -203,6 +204,7 @@ function GltfLoader(options) {
     false
   );
   const loadAttributesFor2D = defaultValue(options.loadAttributesFor2D, false);
+  const enablePick = defaultValue(options.enablePick);
   const loadIndicesForWireframe = defaultValue(
     options.loadIndicesForWireframe,
     false
@@ -234,6 +236,7 @@ function GltfLoader(options) {
   this._forwardAxis = forwardAxis;
   this._loadAttributesAsTypedArray = loadAttributesAsTypedArray;
   this._loadAttributesFor2D = loadAttributesFor2D;
+  this._enablePick = enablePick;
   this._loadIndicesForWireframe = loadIndicesForWireframe;
   this._loadPrimitiveOutline = loadPrimitiveOutline;
   this._loadForClassification = loadForClassification;
@@ -1241,6 +1244,8 @@ function loadVertexAttribute(
     !hasInstances &&
     loader._loadAttributesFor2D &&
     !frameState.scene3DOnly;
+  const loadTypedArrayForPicking =
+    isPositionAttribute && loader._enablePick && !frameState.context.webgl2;
 
   const loadTypedArrayForClassification =
     loader._loadForClassification && isFeatureIdAttribute;
@@ -1252,6 +1257,7 @@ function loadVertexAttribute(
   const outputTypedArray =
     outputTypedArrayOnly ||
     loadTypedArrayFor2D ||
+    loadTypedArrayForPicking ||
     loadTypedArrayForClassification;
 
   // Determine what to load right now:
@@ -1319,6 +1325,8 @@ function loadInstancedAttribute(
     loader._loadAttributesAsTypedArray ||
     (hasRotation && isTransformAttribute) ||
     !frameState.context.instancedArrays;
+  const loadTypedArrayForPicking =
+    loader._enablePick && !frameState.context.webgl2;
 
   const loadBuffer = !loadAsTypedArrayOnly;
 
@@ -1328,7 +1336,8 @@ function loadInstancedAttribute(
   // - the model will be projected to 2D.
   const loadFor2D = loader._loadAttributesFor2D && !frameState.scene3DOnly;
   const loadTranslationAsTypedArray =
-    isTranslationAttribute && (!hasTranslationMinMax || loadFor2D);
+    isTranslationAttribute &&
+    (!hasTranslationMinMax || loadFor2D || loadTypedArrayForPicking);
 
   const loadTypedArray = loadAsTypedArrayOnly || loadTranslationAsTypedArray;
 
@@ -1365,9 +1374,10 @@ function loadIndices(
   indices.count = accessor.count;
 
   const loadAttributesAsTypedArray = loader._loadAttributesAsTypedArray;
-  // Load the index buffer as a typed array to generate wireframes in WebGL1.
-  const loadForWireframe =
-    loader._loadIndicesForWireframe && !frameState.context.webgl2;
+  // Load the index buffer as a typed array to generate wireframes or pick in WebGL1.
+  const loadForCpuOperations =
+    (loader._loadIndicesForWireframe || loader._enablePick) &&
+    !frameState.context.webgl2;
 
   // Load the index buffer as a typed array to batch features together for classification.
   const loadForClassification = loader._loadForClassification && hasFeatureIds;
@@ -1377,7 +1387,7 @@ function loadIndices(
   const outputTypedArrayOnly = loadAttributesAsTypedArray;
   const outputBuffer = !outputTypedArrayOnly;
   const outputTypedArray =
-    loadAttributesAsTypedArray || loadForWireframe || loadForClassification;
+    loadAttributesAsTypedArray || loadForCpuOperations || loadForClassification;
 
   // Determine what to load right now:
   //

package/Source/Scene/GroundPrimitive.js

@@ -10,7 +10,7 @@ import DeveloperError from "../Core/DeveloperError.js";
 import GeometryInstance from "../Core/GeometryInstance.js";
 import OrientedBoundingBox from "../Core/OrientedBoundingBox.js";
 import Rectangle from "../Core/Rectangle.js";
-import TerrainExaggeration from "../Core/TerrainExaggeration.js";
+import VerticalExaggeration from "../Core/VerticalExaggeration.js";
 import ClassificationPrimitive from "./ClassificationPrimitive.js";
 import ClassificationType from "./ClassificationType.js";
 import PerInstanceColorAppearance from "./PerInstanceColorAppearance.js";
@@ -763,15 +763,15 @@ GroundPrimitive.prototype.update = function (frameState) {
 
     // Now compute the min/max heights for the primitive
     setMinMaxTerrainHeights(this, rectangle, ellipsoid);
-    const exaggeration = frameState.terrainExaggeration;
+    const exaggeration = frameState.verticalExaggeration;
     const exaggerationRelativeHeight =
-      frameState.terrainExaggerationRelativeHeight;
-    this._minHeight = TerrainExaggeration.getHeight(
+      frameState.verticalExaggerationRelativeHeight;
+    this._minHeight = VerticalExaggeration.getHeight(
       this._minTerrainHeight,
       exaggeration,
       exaggerationRelativeHeight
     );
-    this._maxHeight = TerrainExaggeration.getHeight(
+    this._maxHeight = VerticalExaggeration.getHeight(
       this._maxTerrainHeight,
       exaggeration,
       exaggerationRelativeHeight

package/Source/Scene/HeightReference.js

@@ -12,17 +12,74 @@ const HeightReference = {
   NONE: 0,
 
   /**
-   * The position is clamped to the terrain.
+   * The position is clamped to the terrain and 3D Tiles.
    * @type {number}
    * @constant
    */
   CLAMP_TO_GROUND: 1,
 
   /**
-   * The position height is the height above the terrain.
+   * The position height is the height above the terrain and 3D Tiles.
    * @type {number}
    * @constant
    */
   RELATIVE_TO_GROUND: 2,
+
+  /**
+   * The position is clamped to terain.
+   * @type {number}
+   * @constant
+   */
+  CLAMP_TO_TERRAIN: 3,
+
+  /**
+   * The position height is the height above terrain.
+   * @type {number}
+   * @constant
+   */
+  RELATIVE_TO_TERRAIN: 4,
+
+  /**
+   * The position is clamped to 3D Tiles.
+   * @type {number}
+   * @constant
+   */
+  CLAMP_TO_3D_TILE: 5,
+
+  /**
+   * The position height is the height above 3D Tiles.
+   * @type {number}
+   * @constant
+   */
+  RELATIVE_TO_3D_TILE: 6,
 };
+
 export default Object.freeze(HeightReference);
+
+/**
+ * Returns true if the height should be clamped to the surface
+ * @param {HeightReference} heightReference
+ * @returns true if the height should be clamped to the surface
+ * @private
+ */
+export function isHeightReferenceClamp(heightReference) {
+  return (
+    heightReference === HeightReference.CLAMP_TO_GROUND ||
+    heightReference === HeightReference.CLAMP_TO_3D_TILE ||
+    heightReference === HeightReference.CLAMP_TO_TERRAIN
+  );
+}
+
+/**
+ * Returns true if the height should be offset relative to the surface
+ * @param {HeightReference} heightReference
+ * @returns true if the height should be offset relative to the surface
+ * @private
+ */
+export function isHeightReferenceRelative(heightReference) {
+  return (
+    heightReference === HeightReference.RELATIVE_TO_GROUND ||
+    heightReference === HeightReference.RELATIVE_TO_3D_TILE ||
+    heightReference === HeightReference.RELATIVE_TO_TERRAIN
+  );
+}

package/Source/Scene/ImageryLayer.js

@@ -132,8 +132,8 @@ import TileImagery from "./TileImagery.js";
  * @alias ImageryLayer
  * @constructor
  *
- * @param {ImageryProvider} imageryProvider The imagery provider to use.
- * @param {ImageryLayer.ConstructorOptions} options An object describing initialization options
+ * @param {ImageryProvider} [imageryProvider] The imagery provider to use.
+ * @param {ImageryLayer.ConstructorOptions} [options] An object describing initialization options
  *
  * @see ImageryLayer.fromProviderAsync
  * @see ImageryLayer.fromWorldImagery
@@ -142,7 +142,7 @@ import TileImagery from "./TileImagery.js";
  * // Add an OpenStreetMaps layer
  * const imageryLayer = new Cesium.ImageryLayer(new Cesium.OpenStreetMapImageryProvider({
  *   url: "https://tile.openstreetmap.org/"
- * })),
+ * }));
  * scene.imageryLayers.add(imageryLayer);
  *
  * @example

package/Source/Scene/Implicit3DTileContent.js

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

package/Source/Scene/LabelCollection.js

@@ -10,7 +10,7 @@ import writeTextToCanvas from "../Core/writeTextToCanvas.js";
 import bitmapSDF from "bitmap-sdf";
 import BillboardCollection from "./BillboardCollection.js";
 import BlendOption from "./BlendOption.js";
-import HeightReference from "./HeightReference.js";
+import { isHeightReferenceClamp } from "./HeightReference.js";
 import HorizontalOrigin from "./HorizontalOrigin.js";
 import Label from "./Label.js";
 import LabelStyle from "./LabelStyle.js";
@@ -510,7 +510,7 @@ function repositionAllGlyphs(label) {
     );
   }
 
-  if (label.heightReference === HeightReference.CLAMP_TO_GROUND) {
+  if (isHeightReferenceClamp(label.heightReference)) {
     for (glyphIndex = 0; glyphIndex < glyphLength; ++glyphIndex) {
       glyph = glyphs[glyphIndex];
       const billboard = glyph.billboard;

package/Source/Scene/MapboxImageryProvider.js

@@ -43,8 +43,8 @@ const defaultCredit = new Credit(
  *     accessToken: 'thisIsMyAccessToken'
  * });
  *
- * @see {@link https://www.mapbox.com/developers/api/maps/#tiles}
- * @see {@link https://www.mapbox.com/developers/api/#access-tokens}
+ * @see {@link https://docs.mapbox.com/api/maps/raster-tiles/}
+ * @see {@link https://docs.mapbox.com/api/accounts/tokens/}
  */
 function MapboxImageryProvider(options) {
   options = defaultValue(options, defaultValue.EMPTY_OBJECT);