@cesium/engine 6.1.1 → 6.2.0

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/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\

package/Source/Shaders/Model/VerticalExaggerationStageVS.glsl

@@ -0,0 +1,39 @@
+void verticalExaggerationStage(
+  inout ProcessedAttributes attributes
+) {
+  // Compute the distance from the camera to the local center of curvature.
+  vec4 vertexPositionENU = czm_modelToEnu * vec4(attributes.positionMC, 1.0);
+  vec2 vertexAzimuth = normalize(vertexPositionENU.xy);
+  // Curvature = 1 / radius of curvature.
+  float azimuthalCurvature = dot(vertexAzimuth * vertexAzimuth, czm_eyeEllipsoidCurvature);
+  float eyeToCenter = 1.0 / azimuthalCurvature + czm_eyeHeight;
+
+  // Compute the approximate ellipsoid normal at the vertex position.
+  // Uses a circular approximation for the Earth curvature along the geodesic.
+  vec3 vertexPositionEC = (czm_modelView * vec4(attributes.positionMC, 1.0)).xyz;
+  vec3 centerToVertex = eyeToCenter * czm_eyeEllipsoidNormalEC + vertexPositionEC;
+  vec3 vertexNormal = normalize(centerToVertex);
+
+  // Estimate the (sine of the) angle between the camera direction and the vertex normal
+  float verticalDistance = dot(vertexPositionEC, czm_eyeEllipsoidNormalEC);
+  float horizontalDistance = length(vertexPositionEC - verticalDistance * czm_eyeEllipsoidNormalEC);
+  float sinTheta = horizontalDistance / (eyeToCenter + verticalDistance);
+  bool isSmallAngle = clamp(sinTheta, 0.0, 0.05) == sinTheta;
+
+  // Approximate the change in height above the ellipsoid, from camera to vertex position.
+  float exactVersine = 1.0 - dot(czm_eyeEllipsoidNormalEC, vertexNormal);
+  float smallAngleVersine = 0.5 * sinTheta * sinTheta;
+  float versine = isSmallAngle ? smallAngleVersine : exactVersine;
+  float dHeight = dot(vertexPositionEC, vertexNormal) - eyeToCenter * versine;
+  float vertexHeight = czm_eyeHeight + dHeight;
+
+  // Transform the approximate vertex normal to model coordinates.
+  vec3 vertexNormalMC = (czm_inverseModelView * vec4(vertexNormal, 0.0)).xyz;
+  vertexNormalMC = normalize(vertexNormalMC);
+
+  // Compute the exaggeration and apply it along the approximate vertex normal.
+  float stretch = u_verticalExaggerationAndRelativeHeight.x;
+  float shift = u_verticalExaggerationAndRelativeHeight.y;
+  float exaggeration = (vertexHeight - shift) * (stretch - 1.0);
+  attributes.positionMC += exaggeration * vertexNormalMC;
+}

package/Source/Shaders/Model/VerticalExaggerationStageVS.js

@@ -0,0 +1,41 @@
+//This file is automatically rebuilt by the Cesium build process.
+export default "void verticalExaggerationStage(\n\
+  inout ProcessedAttributes attributes\n\
+) {\n\
+  // Compute the distance from the camera to the local center of curvature.\n\
+  vec4 vertexPositionENU = czm_modelToEnu * vec4(attributes.positionMC, 1.0);\n\
+  vec2 vertexAzimuth = normalize(vertexPositionENU.xy);\n\
+  // Curvature = 1 / radius of curvature.\n\
+  float azimuthalCurvature = dot(vertexAzimuth * vertexAzimuth, czm_eyeEllipsoidCurvature);\n\
+  float eyeToCenter = 1.0 / azimuthalCurvature + czm_eyeHeight;\n\
+\n\
+  // Compute the approximate ellipsoid normal at the vertex position.\n\
+  // Uses a circular approximation for the Earth curvature along the geodesic.\n\
+  vec3 vertexPositionEC = (czm_modelView * vec4(attributes.positionMC, 1.0)).xyz;\n\
+  vec3 centerToVertex = eyeToCenter * czm_eyeEllipsoidNormalEC + vertexPositionEC;\n\
+  vec3 vertexNormal = normalize(centerToVertex);\n\
+\n\
+  // Estimate the (sine of the) angle between the camera direction and the vertex normal\n\
+  float verticalDistance = dot(vertexPositionEC, czm_eyeEllipsoidNormalEC);\n\
+  float horizontalDistance = length(vertexPositionEC - verticalDistance * czm_eyeEllipsoidNormalEC);\n\
+  float sinTheta = horizontalDistance / (eyeToCenter + verticalDistance);\n\
+  bool isSmallAngle = clamp(sinTheta, 0.0, 0.05) == sinTheta;\n\
+\n\
+  // Approximate the change in height above the ellipsoid, from camera to vertex position.\n\
+  float exactVersine = 1.0 - dot(czm_eyeEllipsoidNormalEC, vertexNormal);\n\
+  float smallAngleVersine = 0.5 * sinTheta * sinTheta;\n\
+  float versine = isSmallAngle ? smallAngleVersine : exactVersine;\n\
+  float dHeight = dot(vertexPositionEC, vertexNormal) - eyeToCenter * versine;\n\
+  float vertexHeight = czm_eyeHeight + dHeight;\n\
+\n\
+  // Transform the approximate vertex normal to model coordinates.\n\
+  vec3 vertexNormalMC = (czm_inverseModelView * vec4(vertexNormal, 0.0)).xyz;\n\
+  vertexNormalMC = normalize(vertexNormalMC);\n\
+\n\
+  // Compute the exaggeration and apply it along the approximate vertex normal.\n\
+  float stretch = u_verticalExaggerationAndRelativeHeight.x;\n\
+  float shift = u_verticalExaggerationAndRelativeHeight.y;\n\
+  float exaggeration = (vertexHeight - shift) * (stretch - 1.0);\n\
+  attributes.positionMC += exaggeration * vertexNormalMC;\n\
+}\n\
+";