@cesium/engine 6.1.0 → 6.2.0

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

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/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/IonImageryProvider.js

@@ -251,7 +251,7 @@ Object.defineProperties(IonImageryProvider.prototype, {
  * Creates a provider for tiled imagery using the Cesium ion REST API.
  *
  * @param {Number} assetId  An ion imagery asset ID.
- * @param {IonImageryProvider.ConstructorOptions} options Object describing initialization options.
+ * @param {IonImageryProvider.ConstructorOptions} [options] Object describing initialization options.
  * @returns {Promise<IonImageryProvider>} A promise which resolves to the created IonImageryProvider.
  *
  * @example

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

package/Source/Scene/Megatexture.js

@@ -366,7 +366,7 @@ Megatexture.getApproximateTextureMemoryByteLength = function (
   const voxelCountTotal =
     tileCount * dimensions.x * dimensions.y * dimensions.z;
 
-  const sliceCountPerRegionX = Math.ceil(Math.sqrt(dimensions.z));
+  const sliceCountPerRegionX = Math.ceil(Math.sqrt(dimensions.x));
   const sliceCountPerRegionY = Math.ceil(dimensions.z / sliceCountPerRegionX);
   const voxelCountPerRegionX = sliceCountPerRegionX * dimensions.x;
   const voxelCountPerRegionY = sliceCountPerRegionY * dimensions.y;

package/Source/Scene/Model/Model.js

@@ -333,6 +333,8 @@ function Model(options) {
   this._heightDirty = this._heightReference !== HeightReference.NONE;
   this._removeUpdateHeightCallback = undefined;
 
+  this._verticalExaggerationOn = false;
+
   this._clampedModelMatrix = undefined; // For use with height reference
 
   const scene = options.scene;
@@ -1789,6 +1791,7 @@ Model.prototype.update = function (frameState) {
   updateSkipLevelOfDetail(this, frameState);
   updateClippingPlanes(this, frameState);
   updateSceneMode(this, frameState);
+  updateVerticalExaggeration(this, frameState);
 
   this._defaultTexture = frameState.context.defaultTexture;
 
@@ -1983,6 +1986,14 @@ function updateSceneMode(model, frameState) {
   }
 }
 
+function updateVerticalExaggeration(model, frameState) {
+  const verticalExaggerationNeeded = frameState.verticalExaggeration !== 1.0;
+  if (model._verticalExaggerationOn !== verticalExaggerationNeeded) {
+    model.resetDrawCommands();
+    model._verticalExaggerationOn = verticalExaggerationNeeded;
+  }
+}
+
 function buildDrawCommands(model, frameState) {
   if (!model._drawCommandsBuilt) {
     model.destroyPipelineResources();

package/Source/Scene/Model/ModelRuntimePrimitive.js

@@ -24,6 +24,7 @@ import PrimitiveStatisticsPipelineStage from "./PrimitiveStatisticsPipelineStage
 import SceneMode2DPipelineStage from "./SceneMode2DPipelineStage.js";
 import SelectedFeatureIdPipelineStage from "./SelectedFeatureIdPipelineStage.js";
 import SkinningPipelineStage from "./SkinningPipelineStage.js";
+import VerticalExaggerationPipelineStage from "./VerticalExaggerationPipelineStage.js";
 import WireframePipelineStage from "./WireframePipelineStage.js";
 
 /**
@@ -198,6 +199,7 @@ ModelRuntimePrimitive.prototype.configurePipeline = function (frameState) {
   const mode = frameState.mode;
   const use2D =
     mode !== SceneMode.SCENE3D && !frameState.scene3DOnly && model._projectTo2D;
+  const exaggerateTerrain = frameState.verticalExaggeration !== 1.0;
 
   const hasMorphTargets =
     defined(primitive.morphTargets) && primitive.morphTargets.length > 0;
@@ -281,6 +283,10 @@ ModelRuntimePrimitive.prototype.configurePipeline = function (frameState) {
     pipelineStages.push(CPUStylingPipelineStage);
   }
 
+  if (exaggerateTerrain) {
+    pipelineStages.push(VerticalExaggerationPipelineStage);
+  }
+
   if (hasCustomShader) {
     pipelineStages.push(CustomShaderPipelineStage);
   }

package/Source/Scene/Model/VerticalExaggerationPipelineStage.js

@@ -0,0 +1,60 @@
+import Cartesian2 from "../../Core/Cartesian2.js";
+import ShaderDestination from "../../Renderer/ShaderDestination.js";
+import VerticalExaggerationStageVS from "../../Shaders/Model/VerticalExaggerationStageVS.js";
+
+/**
+ * The custom shader pipeline stage takes GLSL callbacks from the
+ * {@link CustomShader} and inserts them into the overall shader code for the
+ * {@link Model}. The input to the callback is a struct with many
+ * properties that depend on the attributes of the primitive. This shader code
+ * is automatically generated by this stage.
+ *
+ * @namespace VerticalExaggerationPipelineStage
+ *
+ * @private
+ */
+const VerticalExaggerationPipelineStage = {
+  name: "VerticalExaggerationPipelineStage", // Helps with debugging
+};
+
+const scratchExaggerationUniform = new Cartesian2();
+
+/**
+ * Add vertical exaggeration to a shader
+ *
+ * @param {PrimitiveRenderResources} renderResources The render resources for the primitive
+ * @param {ModelComponents.Primitive} primitive The primitive to be rendered
+ * @param {FrameState} frameState The frame state.
+ * @private
+ */
+VerticalExaggerationPipelineStage.process = function (
+  renderResources,
+  primitive,
+  frameState
+) {
+  const { shaderBuilder, uniformMap } = renderResources;
+
+  shaderBuilder.addVertexLines(VerticalExaggerationStageVS);
+
+  shaderBuilder.addDefine(
+    "HAS_VERTICAL_EXAGGERATION",
+    undefined,
+    ShaderDestination.VERTEX
+  );
+
+  shaderBuilder.addUniform(
+    "vec2",
+    "u_verticalExaggerationAndRelativeHeight",
+    ShaderDestination.VERTEX
+  );
+
+  uniformMap.u_verticalExaggerationAndRelativeHeight = function () {
+    return Cartesian2.fromElements(
+      frameState.verticalExaggeration,
+      frameState.verticalExaggerationRelativeHeight,
+      scratchExaggerationUniform
+    );
+  };
+};
+
+export default VerticalExaggerationPipelineStage;

package/Source/Scene/Scene.js

@@ -356,6 +356,24 @@ function Scene(options) {
    */
   this.nearToFarDistance2D = 1.75e6;
 
+  /**
+   * The vertical exaggeration of the scene.
+   * When set to 1.0, no exaggeration is applied.
+   *
+   * @type {number}
+   * @default 1.0
+   */
+  this.verticalExaggeration = 1.0;
+
+  /**
+   * The reference height for vertical exaggeration of the scene.
+   * When set to 0.0, the exaggeration is applied relative to the ellipsoid surface.
+   *
+   * @type {number}
+   * @default 0.0
+   */
+  this.verticalExaggerationRelativeHeight = 0.0;
+
   /**
    * This property is for debugging only; it is not for production use.
    * <p>
@@ -1880,10 +1898,17 @@ Scene.prototype.updateFrameState = function () {
   frameState.cameraUnderground = this._cameraUnderground;
   frameState.globeTranslucencyState = this._globeTranslucencyState;
 
-  if (defined(this.globe)) {
-    frameState.terrainExaggeration = this.globe.terrainExaggeration;
-    frameState.terrainExaggerationRelativeHeight = this.globe.terrainExaggerationRelativeHeight;
+  const { globe } = this;
+  if (defined(globe) && globe._terrainExaggerationChanged) {
+    // Honor a user-set value for the old deprecated globe.terrainExaggeration.
+    // This can be removed when Globe.terrainExaggeration is removed.
+    this.verticalExaggeration = globe._terrainExaggeration;
+    this.verticalExaggerationRelativeHeight =
+      globe._terrainExaggerationRelativeHeight;
+    globe._terrainExaggerationChanged = false;
   }
+  frameState.verticalExaggeration = this.verticalExaggeration;
+  frameState.verticalExaggerationRelativeHeight = this.verticalExaggerationRelativeHeight;
 
   if (
     defined(this._specularEnvironmentMapAtlas) &&

package/Source/Scene/ScreenSpaceCameraController.js

@@ -17,7 +17,7 @@ import OrthographicFrustum from "../Core/OrthographicFrustum.js";
 import Plane from "../Core/Plane.js";
 import Quaternion from "../Core/Quaternion.js";
 import Ray from "../Core/Ray.js";
-import TerrainExaggeration from "../Core/TerrainExaggeration.js";
+import VerticalExaggeration from "../Core/VerticalExaggeration.js";
 import Transforms from "../Core/Transforms.js";
 import CameraEventAggregator from "./CameraEventAggregator.js";
 import CameraEventType from "./CameraEventType.js";
@@ -2948,9 +2948,7 @@ const scratchPreviousDirection = new Cartesian3();
  */
 ScreenSpaceCameraController.prototype.update = function () {
   const scene = this._scene;
-  const camera = scene.camera;
-  const globe = scene.globe;
-  const mode = scene.mode;
+  const { camera, globe, mode } = scene;
 
   if (!Matrix4.equals(camera.transform, Matrix4.IDENTITY)) {
     this._globe = undefined;
@@ -2962,26 +2960,21 @@ ScreenSpaceCameraController.prototype.update = function () {
       : scene.mapProjection.ellipsoid;
   }
 
-  const exaggeration = defined(this._globe)
-    ? this._globe.terrainExaggeration
-    : 1.0;
-  const exaggerationRelativeHeight = defined(this._globe)
-    ? this._globe.terrainExaggerationRelativeHeight
-    : 0.0;
-  this._minimumCollisionTerrainHeight = TerrainExaggeration.getHeight(
+  const { verticalExaggeration, verticalExaggerationRelativeHeight } = scene;
+  this._minimumCollisionTerrainHeight = VerticalExaggeration.getHeight(
     this.minimumCollisionTerrainHeight,
-    exaggeration,
-    exaggerationRelativeHeight
+    verticalExaggeration,
+    verticalExaggerationRelativeHeight
   );
-  this._minimumPickingTerrainHeight = TerrainExaggeration.getHeight(
+  this._minimumPickingTerrainHeight = VerticalExaggeration.getHeight(
     this.minimumPickingTerrainHeight,
-    exaggeration,
-    exaggerationRelativeHeight
+    verticalExaggeration,
+    verticalExaggerationRelativeHeight
   );
-  this._minimumTrackBallHeight = TerrainExaggeration.getHeight(
+  this._minimumTrackBallHeight = VerticalExaggeration.getHeight(
     this.minimumTrackBallHeight,
-    exaggeration,
-    exaggerationRelativeHeight
+    verticalExaggeration,
+    verticalExaggerationRelativeHeight
   );
 
   this._cameraUnderground = scene.cameraUnderground && defined(this._globe);

package/Source/Scene/TerrainFillMesh.js

@@ -830,9 +830,9 @@ function createFillMesh(tileProvider, frameState, tile, vertexArraysToDestroy) {
   const fill = surfaceTile.fill;
   const rectangle = tile.rectangle;
 
-  const exaggeration = frameState.terrainExaggeration;
+  const exaggeration = frameState.verticalExaggeration;
   const exaggerationRelativeHeight =
-    frameState.terrainExaggerationRelativeHeight;
+    frameState.verticalExaggerationRelativeHeight;
   const hasExaggeration = exaggeration !== 1.0;
 
   const ellipsoid = tile.tilingScheme.ellipsoid;

package/Source/Scene/TileOrientedBoundingBox.js

@@ -106,7 +106,7 @@ Object.defineProperties(TileOrientedBoundingBox.prototype, {
    *
    * @memberof TileOrientedBoundingBox.prototype
    *
-   * @type {object}
+   * @type {OrientedBoundingBox}
    * @readonly
    */
   boundingVolume: {

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/GlobeVS.glsl

@@ -11,7 +11,7 @@ in vec3 geodeticSurfaceNormal;
 #endif
 
 #ifdef EXAGGERATION
-uniform vec2 u_terrainExaggerationAndRelativeHeight;
+uniform vec2 u_verticalExaggerationAndRelativeHeight;
 #endif
 
 uniform vec3 u_center3D;
@@ -173,8 +173,8 @@ void main()
 #endif
 
 #if defined(EXAGGERATION) && defined(GEODETIC_SURFACE_NORMALS)
-    float exaggeration = u_terrainExaggerationAndRelativeHeight.x;
-    float relativeHeight = u_terrainExaggerationAndRelativeHeight.y;
+    float exaggeration = u_verticalExaggerationAndRelativeHeight.x;
+    float relativeHeight = u_verticalExaggerationAndRelativeHeight.y;
     float newHeight = (height - relativeHeight) * exaggeration + relativeHeight;
 
     // stop from going through center of earth

package/Source/Shaders/GlobeVS.js

@@ -12,7 +12,7 @@ in vec3 geodeticSurfaceNormal;\n\
 #endif\n\
 \n\
 #ifdef EXAGGERATION\n\
-uniform vec2 u_terrainExaggerationAndRelativeHeight;\n\
+uniform vec2 u_verticalExaggerationAndRelativeHeight;\n\
 #endif\n\
 \n\
 uniform vec3 u_center3D;\n\
@@ -174,8 +174,8 @@ void main()\n\
 #endif\n\
 \n\
 #if defined(EXAGGERATION) && defined(GEODETIC_SURFACE_NORMALS)\n\
-    float exaggeration = u_terrainExaggerationAndRelativeHeight.x;\n\
-    float relativeHeight = u_terrainExaggerationAndRelativeHeight.y;\n\
+    float exaggeration = u_verticalExaggerationAndRelativeHeight.x;\n\
+    float relativeHeight = u_verticalExaggerationAndRelativeHeight.y;\n\
     float newHeight = (height - relativeHeight) * exaggeration + relativeHeight;\n\
 \n\
     // stop from going through center of earth\n\

package/Source/Shaders/Model/ModelVS.glsl

@@ -93,6 +93,10 @@ void main()
     MetadataStatistics metadataStatistics;
     metadataStage(metadata, metadataClass, metadataStatistics, attributes);
 
+    #ifdef HAS_VERTICAL_EXAGGERATION
+    verticalExaggerationStage(attributes);
+    #endif
+
     #ifdef HAS_CUSTOM_VERTEX_SHADER
     czm_modelVertexOutput vsOutput = defaultVertexOutput(attributes.positionMC);
     customShaderStage(vsOutput, attributes, featureIds, metadata, metadataClass, metadataStatistics);

package/Source/Shaders/Model/ModelVS.js

@@ -93,6 +93,10 @@ void main() \n\
     MetadataClass metadataClass;\n\
     MetadataStatistics metadataStatistics;\n\
     metadataStage(metadata, metadataClass, metadataStatistics, attributes);\n\
+\n\
+    #ifdef HAS_VERTICAL_EXAGGERATION\n\
+    verticalExaggerationStage(attributes);\n\
+    #endif\n\
 \n\
     #ifdef HAS_CUSTOM_VERTEX_SHADER\n\
     czm_modelVertexOutput vsOutput = defaultVertexOutput(attributes.positionMC);\n\