@cesium/engine 26.0.0 → 26.2.0

package/Source/Scene/GlobeSurfaceTile.js

@@ -9,6 +9,7 @@ import RequestState from "../Core/RequestState.js";
 import RequestType from "../Core/RequestType.js";
 import TerrainEncoding from "../Core/TerrainEncoding.js";
 import TileProviderError from "../Core/TileProviderError.js";
+import VectorPipeline from "../Core/VectorPipeline.js";
 import Buffer from "../Renderer/Buffer.js";
 import BufferUsage from "../Renderer/BufferUsage.js";
 import PixelDatatype from "../Renderer/PixelDatatype.js";
@@ -22,83 +23,104 @@ import ImageryState from "./ImageryState.js";
 import QuadtreeTileLoadState from "./QuadtreeTileLoadState.js";
 import TerrainState from "./TerrainState.js";
 
+/** @import Context from "../Renderer/Context.js"; */
+/** @import Ellipsoid from "../Core/Ellipsoid.js"; */
+/** @import FrameState from "./FrameState.js"; */
+/** @import HeightmapTerrainData from "../Core/HeightmapTerrainData.js"; */
+/** @import ImageryLayerCollection from "./ImageryLayerCollection.js"; */
+/** @import MapProjection from "../Core/MapProjection.js"; */
+/** @import QuadtreePrimitive from "./QuadtreePrimitive.js"; */
+/** @import QuadtreeTile from "./QuadtreeTile.js"; */
+/** @import Ray from "../Core/Ray.js"; */
+/** @import SceneMode from "./SceneMode.js"; */
+/** @import TerrainMesh from "../Core/TerrainMesh.js"; */
+/** @import TerrainProvider from "../Core/TerrainProvider.js"; */
+/** @import TileBoundingRegion from "./TileBoundingRegion.js"; */
+/** @import TileImagery from "./TileImagery.js"; */
+/** @import VectorProvider, { VectorTileData } from "../Core/VectorProvider.js"; */
+
 /**
  * Contains additional information about a {@link QuadtreeTile} of the globe's surface, and
  * encapsulates state transition logic for loading tiles.
  *
- * @constructor
- * @alias GlobeSurfaceTile
  * @private
  */
-function GlobeSurfaceTile() {
-  /**
-   * The {@link TileImagery} attached to this tile.
-   * @type {TileImagery[]}
-   * @default []
-   */
-  this.imagery = [];
+class GlobeSurfaceTile {
+  /** @type {Request} */
+  request;
+
+  constructor() {
+    /**
+     * The {@link TileImagery} attached to this tile.
+     * @type {TileImagery[]}
+     * @default []
+     */
+    this.imagery = [];
+
+    /** @type {Texture} */
+    this.waterMaskTexture = undefined;
+    this.waterMaskTranslationAndScale = new Cartesian4(0.0, 0.0, 1.0, 1.0);
 
-  this.waterMaskTexture = undefined;
-  this.waterMaskTranslationAndScale = new Cartesian4(0.0, 0.0, 1.0, 1.0);
+    /** @type {HeightmapTerrainData} */
+    this.terrainData = undefined;
 
-  this.terrainData = undefined;
-  this.vertexArray = undefined;
+    /** @type {VectorTileData} */
+    this.vectorData = undefined;
 
-  /**
-   * A bounding region used to estimate distance to the tile. The horizontal bounds are always tight-fitting,
-   * but the `minimumHeight` and `maximumHeight` properties may be derived from the min/max of an ancestor tile
-   * and be quite loose-fitting and thus very poor for estimating distance.
-   * @type {TileBoundingRegion}
-   */
-  this.tileBoundingRegion = undefined;
-  this.occludeePointInScaledSpace = new Cartesian3();
-  this.boundingVolumeSourceTile = undefined;
-  this.boundingVolumeIsFromMesh = false;
+    /** @type {VertexArray} */
+    this.vertexArray = undefined;
 
-  this.terrainState = TerrainState.UNLOADED;
-  this.mesh = undefined;
-  this.fill = undefined;
+    /**
+     * A bounding region used to estimate distance to the tile. The horizontal bounds are always tight-fitting,
+     * but the `minimumHeight` and `maximumHeight` properties may be derived from the min/max of an ancestor tile
+     * and be quite loose-fitting and thus very poor for estimating distance.
+     * @type {TileBoundingRegion}
+     */
+    this.tileBoundingRegion = undefined;
+    this.occludeePointInScaledSpace = new Cartesian3();
+    this.boundingVolumeSourceTile = undefined;
+    this.boundingVolumeIsFromMesh = false;
 
-  this.pickBoundingSphere = new BoundingSphere();
+    this.terrainState = TerrainState.UNLOADED;
+    this.mesh = undefined;
+    this.fill = undefined;
 
-  this.surfaceShader = undefined;
-  this.isClipped = true;
+    this.pickBoundingSphere = new BoundingSphere();
 
-  this.clippedByBoundaries = false;
-}
+    this.surfaceShader = undefined;
+    this.isClipped = true;
+
+    this.clippedByBoundaries = false;
+  }
 
-Object.defineProperties(GlobeSurfaceTile.prototype, {
   /**
    * Gets a value indicating whether or not this tile is eligible to be unloaded.
    * Typically, a tile is ineligible to be unloaded while an asynchronous operation,
    * such as a request for data, is in progress on it.  A tile will never be
    * unloaded while it is needed for rendering, regardless of the value of this
    * property.
-   * @memberof GlobeSurfaceTile.prototype
    * @type {boolean}
    */
-  eligibleForUnloading: {
-    get: function () {
-      // Do not remove tiles that are transitioning or that have
-      // imagery that is transitioning.
-      const terrainState = this.terrainState;
-      const loadingIsTransitioning =
-        terrainState === TerrainState.RECEIVING ||
-        terrainState === TerrainState.TRANSFORMING;
-
-      let shouldRemoveTile = !loadingIsTransitioning;
-
-      const imagery = this.imagery;
-      for (let i = 0, len = imagery.length; shouldRemoveTile && i < len; ++i) {
-        const tileImagery = imagery[i];
-        shouldRemoveTile =
-          !defined(tileImagery.loadingImagery) ||
-          tileImagery.loadingImagery.state !== ImageryState.TRANSITIONING;
-      }
+  get eligibleForUnloading() {
+    // Do not remove tiles that are transitioning or that have
+    // imagery that is transitioning.
+    const terrainState = this.terrainState;
+    const loadingIsTransitioning =
+      terrainState === TerrainState.RECEIVING ||
+      terrainState === TerrainState.TRANSFORMING;
+
+    let shouldRemoveTile = !loadingIsTransitioning;
+
+    const imagery = this.imagery;
+    for (let i = 0, len = imagery.length; shouldRemoveTile && i < len; ++i) {
+      const tileImagery = imagery[i];
+      shouldRemoveTile =
+        !defined(tileImagery.loadingImagery) ||
+        tileImagery.loadingImagery.state !== ImageryState.TRANSITIONING;
+    }
 
-      return shouldRemoveTile;
-    },
-  },
+    return shouldRemoveTile;
+  }
 
   /**
    * Gets the {@link TerrainMesh} that is used for rendering this tile, if any.
@@ -107,224 +129,455 @@ Object.defineProperties(GlobeSurfaceTile.prototype, {
    * {@link TerrainFillMesh#mesh} property of the {@link GlobeSurfaceTile#fill}.
    * If there is no fill, it returns undefined.
    *
-   * @memberof GlobeSurfaceTile.prototype
    * @type {TerrainMesh}
    */
-  renderedMesh: {
-    get: function () {
-      if (defined(this.vertexArray)) {
-        return this.mesh;
-      } else if (defined(this.fill)) {
-        return this.fill.mesh;
-      }
-      return undefined;
-    },
-  },
-});
-
-GlobeSurfaceTile.prototype.pick = function (
-  ray,
-  mode,
-  projection,
-  cullBackFaces,
-  result,
-) {
-  if (!defined(this.renderedMesh)) {
+  get renderedMesh() {
+    if (defined(this.vertexArray)) {
+      return this.mesh;
+    } else if (defined(this.fill)) {
+      return this.fill.mesh;
+    }
     return undefined;
   }
-  const value = this.renderedMesh.pick(ray, cullBackFaces, mode, projection);
-  return Cartesian3.clone(value, result);
-};
 
-GlobeSurfaceTile.prototype.freeResources = function () {
-  if (defined(this.waterMaskTexture)) {
-    --this.waterMaskTexture.referenceCount;
-    if (this.waterMaskTexture.referenceCount === 0) {
-      this.waterMaskTexture.destroy();
+  /**
+   * @param {Ray} ray
+   * @param {SceneMode} mode
+   * @param {MapProjection} projection
+   * @param {boolean} cullBackFaces
+   * @param {Cartesian3} result
+   */
+  pick(ray, mode, projection, cullBackFaces, result) {
+    if (!defined(this.renderedMesh)) {
+      return undefined;
     }
-    this.waterMaskTexture = undefined;
+    const value = this.renderedMesh.pick(ray, cullBackFaces, mode, projection);
+    return Cartesian3.clone(value, result);
   }
 
-  this.terrainData = undefined;
+  freeResources() {
+    if (defined(this.waterMaskTexture)) {
+      --this.waterMaskTexture.referenceCount;
+      if (this.waterMaskTexture.referenceCount === 0) {
+        this.waterMaskTexture.destroy();
+      }
+      this.waterMaskTexture = undefined;
+    }
 
-  this.terrainState = TerrainState.UNLOADED;
-  this.mesh = undefined;
-  this.fill = this.fill && this.fill.destroy();
+    if (defined(this.vectorData)) {
+      VectorPipeline.freeResources(this.vectorData);
+      this.vectorData = undefined;
+    }
 
-  const imageryList = this.imagery;
-  for (let i = 0, len = imageryList.length; i < len; ++i) {
-    imageryList[i].freeResources();
-  }
-  this.imagery.length = 0;
+    this.terrainData = undefined;
 
-  this.freeVertexArray();
-};
+    this.terrainState = TerrainState.UNLOADED;
+    this.mesh = undefined;
+    this.fill = this.fill && this.fill.destroy();
 
-GlobeSurfaceTile.prototype.freeVertexArray = function () {
-  GlobeSurfaceTile._freeVertexArray(this.vertexArray);
-  this.vertexArray = undefined;
-  GlobeSurfaceTile._freeVertexArray(this.wireframeVertexArray);
-  this.wireframeVertexArray = undefined;
-};
+    const imageryList = this.imagery;
+    for (let i = 0, len = imageryList.length; i < len; ++i) {
+      imageryList[i].freeResources();
+    }
+    this.imagery.length = 0;
 
-GlobeSurfaceTile.initialize = function (
-  tile,
-  terrainProvider,
-  imageryLayerCollection,
-) {
-  let surfaceTile = tile.data;
-  if (!defined(surfaceTile)) {
-    surfaceTile = tile.data = new GlobeSurfaceTile();
+    this.freeVertexArray();
   }
 
-  if (tile.state === QuadtreeTileLoadState.START) {
-    prepareNewTile(tile, terrainProvider, imageryLayerCollection);
-    tile.state = QuadtreeTileLoadState.LOADING;
+  freeVertexArray() {
+    GlobeSurfaceTile._freeVertexArray(this.vertexArray);
+    this.vertexArray = undefined;
+    GlobeSurfaceTile._freeVertexArray(this.wireframeVertexArray);
+    this.wireframeVertexArray = undefined;
   }
-};
 
-GlobeSurfaceTile.processStateMachine = function (
-  tile,
-  frameState,
-  terrainProvider,
-  imageryLayerCollection,
-  quadtree,
-  vertexArraysToDestroy,
-  terrainOnly,
-) {
-  GlobeSurfaceTile.initialize(tile, terrainProvider, imageryLayerCollection);
+  /**
+   * @param {QuadtreeTile} tile
+   * @param {TerrainProvider} terrainProvider
+   * @param {VectorProvider} vectorProvider
+   * @param {ImageryLayerCollection} imageryLayerCollection
+   */
+  static initialize(
+    tile,
+    terrainProvider,
+    vectorProvider,
+    imageryLayerCollection,
+  ) {
+    if (!defined(tile.data)) {
+      tile.data = new GlobeSurfaceTile();
+    }
 
-  const surfaceTile = tile.data;
+    if (tile.state === QuadtreeTileLoadState.START) {
+      prepareNewTile(
+        tile,
+        terrainProvider,
+        vectorProvider,
+        imageryLayerCollection,
+      );
+      tile.state = QuadtreeTileLoadState.LOADING;
+    }
+  }
 
-  if (tile.state === QuadtreeTileLoadState.LOADING) {
-    processTerrainStateMachine(
+  /**
+   * @param {QuadtreeTile} tile
+   * @param {FrameState} frameState
+   * @param {TerrainProvider} terrainProvider
+   * @param {VectorProvider} vectorProvider
+   * @param {ImageryLayerCollection} imageryLayerCollection
+   * @param {QuadtreePrimitive} quadtree
+   * @param {*} vertexArraysToDestroy
+   * @param {*} terrainOnly
+   */
+  static processStateMachine(
+    tile,
+    frameState,
+    terrainProvider,
+    vectorProvider,
+    imageryLayerCollection,
+    quadtree,
+    vertexArraysToDestroy,
+    terrainOnly,
+  ) {
+    GlobeSurfaceTile.initialize(
       tile,
-      frameState,
       terrainProvider,
+      vectorProvider,
       imageryLayerCollection,
-      quadtree,
-      vertexArraysToDestroy,
     );
-  }
 
-  // From here down we're loading imagery, not terrain. We don't want to load imagery until
-  // we're certain that the terrain tiles are actually visible, though. We'll load terrainOnly
-  // in these scenarios:
-  //   * our bounding volume isn't accurate so we're not certain this tile is really visible (see GlobeSurfaceTileProvider#loadTile).
-  //   * we want to upsample from this tile but don't plan to render it (see processTerrainStateMachine).
-  if (terrainOnly) {
-    return;
-  }
+    const surfaceTile = tile.data;
 
-  const wasAlreadyRenderable = tile.renderable;
+    if (tile.state === QuadtreeTileLoadState.LOADING) {
+      processTerrainStateMachine(
+        tile,
+        frameState,
+        terrainProvider,
+        vectorProvider,
+        imageryLayerCollection,
+        quadtree,
+        vertexArraysToDestroy,
+      );
+    }
 
-  // The terrain is renderable as soon as we have a valid vertex array.
-  tile.renderable = defined(surfaceTile.vertexArray);
+    // From here down we're loading imagery, not terrain. We don't want to load imagery until
+    // we're certain that the terrain tiles are actually visible, though. We'll load terrainOnly
+    // in these scenarios:
+    //   * our bounding volume isn't accurate so we're not certain this tile is really visible (see GlobeSurfaceTileProvider#loadTile).
+    //   * we want to upsample from this tile but don't plan to render it (see processTerrainStateMachine).
+    if (terrainOnly) {
+      return;
+    }
 
-  // But it's not done loading until it's in the READY state.
-  const isTerrainDoneLoading = surfaceTile.terrainState === TerrainState.READY;
+    const wasAlreadyRenderable = tile.renderable;
 
-  // If this tile's terrain and imagery are just upsampled from its parent, mark the tile as
-  // upsampled only.  We won't refine a tile if its four children are upsampled only.
-  tile.upsampledFromParent =
-    defined(surfaceTile.terrainData) &&
-    surfaceTile.terrainData.wasCreatedByUpsampling();
+    // The terrain is renderable as soon as we have a valid vertex array.
+    tile.renderable = defined(surfaceTile.vertexArray);
 
-  const isImageryDoneLoading = surfaceTile.processImagery(
-    tile,
-    terrainProvider,
-    frameState,
-  );
+    // But it's not done loading until it's in the READY state.
+    const isTerrainDoneLoading =
+      surfaceTile.terrainState === TerrainState.READY;
+
+    // If this tile's terrain and imagery are just upsampled from its parent, mark the tile as
+    // upsampled only.  We won't refine a tile if its four children are upsampled only.
+    tile.upsampledFromParent =
+      defined(surfaceTile.terrainData) &&
+      surfaceTile.terrainData.wasCreatedByUpsampling();
+
+    const isImageryDoneLoading = surfaceTile.processImagery(
+      tile,
+      terrainProvider,
+      frameState,
+    );
+
+    if (isTerrainDoneLoading && isImageryDoneLoading) {
+      const callbacks = tile._loadedCallbacks;
+      const newCallbacks = {};
+      for (const layerId in callbacks) {
+        if (callbacks.hasOwnProperty(layerId)) {
+          if (!callbacks[layerId](tile)) {
+            newCallbacks[layerId] = callbacks[layerId];
+          }
+        }
+      }
+      tile._loadedCallbacks = newCallbacks;
+
+      tile.state = QuadtreeTileLoadState.DONE;
+    }
+
+    // Once a tile is renderable, it stays renderable, because doing otherwise would
+    // cause detail (or maybe even the entire globe) to vanish when adding a new
+    // imagery layer. `GlobeSurfaceTileProvider._onLayerAdded` sets renderable to
+    // false for all affected tiles that are not currently being rendered.
+    if (wasAlreadyRenderable) {
+      tile.renderable = true;
+    }
+  }
+
+  /**
+   * @param {QuadtreeTile} tile
+   * @param {TerrainProvider} terrainProvider
+   * @param {FrameState} frameState
+   * @param {boolean} skipLoading
+   */
+  processImagery(tile, terrainProvider, frameState, skipLoading) {
+    const surfaceTile = /** @type {GlobeSurfaceTile} */ (tile.data);
+    let isUpsampledOnly = tile.upsampledFromParent;
+    let isAnyTileLoaded = false;
+    let isDoneLoading = true;
+
+    // Transition imagery states
+    const tileImageryCollection = surfaceTile.imagery;
+    let i, len;
+    for (i = 0, len = tileImageryCollection.length; i < len; ++i) {
+      const tileImagery = tileImageryCollection[i];
+      if (!defined(tileImagery.loadingImagery)) {
+        isUpsampledOnly = false;
+        continue;
+      }
 
-  if (isTerrainDoneLoading && isImageryDoneLoading) {
-    const callbacks = tile._loadedCallbacks;
-    const newCallbacks = {};
-    for (const layerId in callbacks) {
-      if (callbacks.hasOwnProperty(layerId)) {
-        if (!callbacks[layerId](tile)) {
-          newCallbacks[layerId] = callbacks[layerId];
+      if (tileImagery.loadingImagery.state === ImageryState.PLACEHOLDER) {
+        const imageryLayer = tileImagery.loadingImagery.imageryLayer;
+        if (imageryLayer.ready) {
+          // Remove the placeholder and add the actual skeletons (if any)
+          // at the same position.  Then continue the loop at the same index.
+          tileImagery.freeResources();
+          tileImageryCollection.splice(i, 1);
+          imageryLayer._createTileImagerySkeletons(tile, terrainProvider, i);
+          --i;
+          len = tileImageryCollection.length;
+          continue;
+        } else {
+          isUpsampledOnly = false;
         }
       }
+
+      const thisTileDoneLoading = tileImagery.processStateMachine(
+        tile,
+        frameState,
+        skipLoading,
+      );
+      isDoneLoading = isDoneLoading && thisTileDoneLoading;
+
+      // The imagery is renderable as soon as we have any renderable imagery for this region.
+      isAnyTileLoaded =
+        isAnyTileLoaded ||
+        thisTileDoneLoading ||
+        defined(tileImagery.readyImagery);
+
+      isUpsampledOnly =
+        isUpsampledOnly &&
+        defined(tileImagery.loadingImagery) &&
+        (tileImagery.loadingImagery.state === ImageryState.FAILED ||
+          tileImagery.loadingImagery.state === ImageryState.INVALID);
     }
-    tile._loadedCallbacks = newCallbacks;
 
-    tile.state = QuadtreeTileLoadState.DONE;
+    tile.upsampledFromParent = isUpsampledOnly;
+
+    // Allow rendering if any available layers are loaded
+    tile.renderable = tile.renderable && (isAnyTileLoaded || isDoneLoading);
+
+    return isDoneLoading;
   }
 
-  // Once a tile is renderable, it stays renderable, because doing otherwise would
-  // cause detail (or maybe even the entire globe) to vanish when adding a new
-  // imagery layer. `GlobeSurfaceTileProvider._onLayerAdded` sets renderable to
-  // false for all affected tiles that are not currently being rendered.
-  if (wasAlreadyRenderable) {
-    tile.renderable = true;
+  /**
+   * @param {Ellipsoid} ellipsoid
+   * @param {FrameState} frameState
+   */
+  addGeodeticSurfaceNormals(ellipsoid, frameState) {
+    toggleGeodeticSurfaceNormals(this, true, ellipsoid, frameState);
   }
-};
 
-GlobeSurfaceTile.prototype.processImagery = function (
-  tile,
-  terrainProvider,
-  frameState,
-  skipLoading,
-) {
-  const surfaceTile = tile.data;
-  let isUpsampledOnly = tile.upsampledFromParent;
-  let isAnyTileLoaded = false;
-  let isDoneLoading = true;
-
-  // Transition imagery states
-  const tileImageryCollection = surfaceTile.imagery;
-  let i, len;
-  for (i = 0, len = tileImageryCollection.length; i < len; ++i) {
-    const tileImagery = tileImageryCollection[i];
-    if (!defined(tileImagery.loadingImagery)) {
-      isUpsampledOnly = false;
-      continue;
+  /**
+   * @param {FrameState} frameState
+   */
+  removeGeodeticSurfaceNormals(frameState) {
+    toggleGeodeticSurfaceNormals(this, false, undefined, frameState);
+  }
+
+  /**
+   * @param {QuadtreeTile} tile
+   * @param {FrameState} frameState
+   * @param {QuadtreePrimitive} quadtree
+   */
+  updateExaggeration(tile, frameState, quadtree) {
+    const surfaceTile = this;
+    const mesh = surfaceTile.renderedMesh;
+    if (mesh === undefined) {
+      return;
     }
 
-    if (tileImagery.loadingImagery.state === ImageryState.PLACEHOLDER) {
-      const imageryLayer = tileImagery.loadingImagery.imageryLayer;
-      if (imageryLayer.ready) {
-        // Remove the placeholder and add the actual skeletons (if any)
-        // at the same position.  Then continue the loop at the same index.
-        tileImagery.freeResources();
-        tileImageryCollection.splice(i, 1);
-        imageryLayer._createTileImagerySkeletons(tile, terrainProvider, i);
-        --i;
-        len = tileImageryCollection.length;
-        continue;
-      } else {
-        isUpsampledOnly = false;
+    // Check the tile's terrain encoding to see if it has been exaggerated yet
+    const exaggeration = frameState.verticalExaggeration;
+    const exaggerationRelativeHeight =
+      frameState.verticalExaggerationRelativeHeight;
+    const hasExaggerationScale = exaggeration !== 1.0;
+
+    const encoding = mesh.encoding;
+    const encodingExaggerationScaleChanged =
+      encoding.exaggeration !== exaggeration;
+    const encodingRelativeHeightChanged =
+      encoding.exaggerationRelativeHeight !== exaggerationRelativeHeight;
+    const exaggerationChanged =
+      encodingExaggerationScaleChanged || encodingRelativeHeightChanged;
+
+    if (exaggerationChanged) {
+      // Turning exaggeration scale on/off requires adding or removing geodetic surface normals
+      // Relative height only translates, so it has no effect on normals
+      if (encodingExaggerationScaleChanged) {
+        if (hasExaggerationScale && !encoding.hasGeodeticSurfaceNormals) {
+          const ellipsoid = tile.tilingScheme.ellipsoid;
+          surfaceTile.addGeodeticSurfaceNormals(ellipsoid, frameState);
+        } else if (
+          !hasExaggerationScale &&
+          encoding.hasGeodeticSurfaceNormals
+        ) {
+          surfaceTile.removeGeodeticSurfaceNormals(frameState);
+        }
+      }
+
+      encoding.exaggeration = exaggeration;
+      encoding.exaggerationRelativeHeight = exaggerationRelativeHeight;
+
+      // Notify the quadtree that this tile's height has changed
+      if (quadtree !== undefined) {
+        quadtree._tileToUpdateHeights.push(tile);
+        const customData = tile.customData;
+        for (const data of customData) {
+          // Restart the level so that a height update is triggered
+          data.level = -1;
+        }
       }
+
+      mesh.updateExaggeration(exaggeration, exaggerationRelativeHeight);
     }
+  }
 
-    const thisTileDoneLoading = tileImagery.processStateMachine(
-      tile,
-      frameState,
-      skipLoading,
-    );
-    isDoneLoading = isDoneLoading && thisTileDoneLoading;
+  /**
+   * @param {SceneMode} mode
+   */
+  updateSceneMode(mode) {
+    const surfaceTile = this;
+    const mesh = surfaceTile.renderedMesh;
+    if (mesh === undefined) {
+      return;
+    }
+
+    mesh.updateSceneMode(mode);
+  }
 
-    // The imagery is renderable as soon as we have any renderable imagery for this region.
-    isAnyTileLoaded =
-      isAnyTileLoaded ||
-      thisTileDoneLoading ||
-      defined(tileImagery.readyImagery);
+  /**
+   * @param {Context} context
+   * @param {TerrainMesh} mesh
+   */
+  static _createVertexArrayForMesh(context, mesh) {
+    const typedArray = mesh.vertices;
+    const buffer = Buffer.createVertexBuffer({
+      context: context,
+      typedArray: typedArray,
+      usage: BufferUsage.STATIC_DRAW,
+    });
+    const attributes = mesh.encoding.getAttributes(buffer);
+
+    const indexBuffers = mesh.indices.indexBuffers || {};
+    let indexBuffer = indexBuffers[context.id];
+    if (!defined(indexBuffer) || indexBuffer.isDestroyed()) {
+      const indices = mesh.indices;
+      indexBuffer = Buffer.createIndexBuffer({
+        context: context,
+        typedArray: indices,
+        usage: BufferUsage.STATIC_DRAW,
+        // @ts-expect-error https://github.com/CesiumGS/cesium/issues/13420
+        indexDatatype: IndexDatatype.fromSizeInBytes(indices.BYTES_PER_ELEMENT),
+      });
+      indexBuffer.vertexArrayDestroyable = false;
+      indexBuffer.referenceCount = 1;
+      indexBuffers[context.id] = indexBuffer;
+      mesh.indices.indexBuffers = indexBuffers;
+    } else {
+      ++indexBuffer.referenceCount;
+    }
 
-    isUpsampledOnly =
-      isUpsampledOnly &&
-      defined(tileImagery.loadingImagery) &&
-      (tileImagery.loadingImagery.state === ImageryState.FAILED ||
-        tileImagery.loadingImagery.state === ImageryState.INVALID);
+    return new VertexArray({
+      context: context,
+      attributes: attributes,
+      indexBuffer: indexBuffer,
+    });
   }
 
-  tile.upsampledFromParent = isUpsampledOnly;
+  /**
+   * @param {VertexArray} vertexArray
+   */
+  static _freeVertexArray(vertexArray) {
+    if (defined(vertexArray)) {
+      // @ts-expect-error Missing types.
+      const indexBuffer = vertexArray.indexBuffer;
 
-  // Allow rendering if any available layers are loaded
-  tile.renderable = tile.renderable && (isAnyTileLoaded || isDoneLoading);
+      if (!vertexArray.isDestroyed()) {
+        vertexArray.destroy();
+      }
 
-  return isDoneLoading;
-};
+      if (
+        defined(indexBuffer) &&
+        !indexBuffer.isDestroyed() &&
+        defined(indexBuffer.referenceCount)
+      ) {
+        --indexBuffer.referenceCount;
+        if (indexBuffer.referenceCount === 0) {
+          indexBuffer.destroy();
+        }
+      }
+    }
+  }
+
+  /**
+   * @param {QuadtreeTile} tile
+   */
+  _findAncestorTileWithTerrainData(tile) {
+    let sourceTile = tile.parent;
+
+    while (
+      defined(sourceTile) &&
+      (!defined(sourceTile.data) ||
+        !defined(sourceTile.data.terrainData) ||
+        sourceTile.data.terrainData.wasCreatedByUpsampling())
+    ) {
+      sourceTile = sourceTile.parent;
+    }
+
+    return sourceTile;
+  }
 
+  /**
+   * @param {QuadtreeTile} tile
+   * @param {QuadtreeTile} sourceTile
+   * @param {Cartesian4} result
+   */
+  _computeWaterMaskTranslationAndScale(tile, sourceTile, result) {
+    const sourceTileRectangle = sourceTile.rectangle;
+    const tileRectangle = tile.rectangle;
+    const tileWidth = tileRectangle.width;
+    const tileHeight = tileRectangle.height;
+
+    const scaleX = tileWidth / sourceTileRectangle.width;
+    const scaleY = tileHeight / sourceTileRectangle.height;
+    result.x =
+      (scaleX * (tileRectangle.west - sourceTileRectangle.west)) / tileWidth;
+    result.y =
+      (scaleY * (tileRectangle.south - sourceTileRectangle.south)) / tileHeight;
+    result.z = scaleX;
+    result.w = scaleY;
+
+    return result;
+  }
+}
+
+/**
+ * @param {GlobeSurfaceTile} surfaceTile
+ * @param {boolean} enabled
+ * @param {Ellipsoid} ellipsoid
+ * @param {FrameState} frameState
+ * @ignore
+ */
 function toggleGeodeticSurfaceNormals(
   surfaceTile,
   enabled,
@@ -376,85 +629,22 @@ function toggleGeodeticSurfaceNormals(
   surfaceTile.wireframeVertexArray = undefined;
 }
 
-GlobeSurfaceTile.prototype.addGeodeticSurfaceNormals = function (
-  ellipsoid,
-  frameState,
-) {
-  toggleGeodeticSurfaceNormals(this, true, ellipsoid, frameState);
-};
-
-GlobeSurfaceTile.prototype.removeGeodeticSurfaceNormals = function (
-  frameState,
-) {
-  toggleGeodeticSurfaceNormals(this, false, undefined, frameState);
-};
-
-GlobeSurfaceTile.prototype.updateExaggeration = function (
+/**
+ * @param {QuadtreeTile} tile
+ * @param {TerrainProvider} terrainProvider
+ * @param {VectorProvider} vectorProvider
+ * @param {ImageryLayerCollection} imageryLayerCollection
+ * @ignore
+ */
+function prepareNewTile(
   tile,
-  frameState,
-  quadtree,
+  terrainProvider,
+  vectorProvider,
+  imageryLayerCollection,
 ) {
-  const surfaceTile = this;
-  const mesh = surfaceTile.renderedMesh;
-  if (mesh === undefined) {
-    return;
-  }
-
-  // Check the tile's terrain encoding to see if it has been exaggerated yet
-  const exaggeration = frameState.verticalExaggeration;
-  const exaggerationRelativeHeight =
-    frameState.verticalExaggerationRelativeHeight;
-  const hasExaggerationScale = exaggeration !== 1.0;
-
-  const encoding = mesh.encoding;
-  const encodingExaggerationScaleChanged =
-    encoding.exaggeration !== exaggeration;
-  const encodingRelativeHeightChanged =
-    encoding.exaggerationRelativeHeight !== exaggerationRelativeHeight;
-  const exaggerationChanged =
-    encodingExaggerationScaleChanged || encodingRelativeHeightChanged;
-
-  if (exaggerationChanged) {
-    // Turning exaggeration scale on/off requires adding or removing geodetic surface normals
-    // Relative height only translates, so it has no effect on normals
-    if (encodingExaggerationScaleChanged) {
-      if (hasExaggerationScale && !encoding.hasGeodeticSurfaceNormals) {
-        const ellipsoid = tile.tilingScheme.ellipsoid;
-        surfaceTile.addGeodeticSurfaceNormals(ellipsoid, frameState);
-      } else if (!hasExaggerationScale && encoding.hasGeodeticSurfaceNormals) {
-        surfaceTile.removeGeodeticSurfaceNormals(frameState);
-      }
-    }
-
-    encoding.exaggeration = exaggeration;
-    encoding.exaggerationRelativeHeight = exaggerationRelativeHeight;
-
-    // Notify the quadtree that this tile's height has changed
-    if (quadtree !== undefined) {
-      quadtree._tileToUpdateHeights.push(tile);
-      const customData = tile.customData;
-      for (const data of customData) {
-        // Restart the level so that a height update is triggered
-        data.level = -1;
-      }
-    }
-
-    mesh.updateExaggeration(exaggeration, exaggerationRelativeHeight);
-  }
-};
-
-GlobeSurfaceTile.prototype.updateSceneMode = function (mode) {
-  const surfaceTile = this;
-  const mesh = surfaceTile.renderedMesh;
-  if (mesh === undefined) {
-    return;
-  }
-
-  mesh.updateSceneMode(mode);
-};
-
-function prepareNewTile(tile, terrainProvider, imageryLayerCollection) {
+  /** @type {boolean} */
   let available = terrainProvider.getTileDataAvailable(
+    // @ts-expect-error Missing types.
     tile.x,
     tile.y,
     tile.level,
@@ -463,7 +653,7 @@ function prepareNewTile(tile, terrainProvider, imageryLayerCollection) {
   if (!defined(available) && defined(tile.parent)) {
     // Provider doesn't know if this tile is available. Does the parent tile know?
     const parent = tile.parent;
-    const parentSurfaceTile = parent.data;
+    const parentSurfaceTile = /** @type {GlobeSurfaceTile} */ (parent.data);
     if (defined(parentSurfaceTile) && defined(parentSurfaceTile.terrainData)) {
       available = parentSurfaceTile.terrainData.isChildAvailable(
         parent.x,
@@ -474,12 +664,15 @@ function prepareNewTile(tile, terrainProvider, imageryLayerCollection) {
     }
   }
 
+  const surfaceTile = /** @type {GlobeSurfaceTile} */ (tile.data);
+
   if (available === false) {
     // This tile is not available, so mark it failed so we start upsampling right away.
-    tile.data.terrainState = TerrainState.FAILED;
+    surfaceTile.terrainState = TerrainState.FAILED;
   }
 
   // Map imagery tiles to this terrain tile
+  // @ts-expect-error Missing types.
   for (let i = 0, len = imageryLayerCollection.length; i < len; ++i) {
     const layer = imageryLayerCollection.get(i);
     if (layer.show) {
@@ -488,15 +681,26 @@ function prepareNewTile(tile, terrainProvider, imageryLayerCollection) {
   }
 }
 
+/**
+ * @param {QuadtreeTile} tile
+ * @param {FrameState} frameState
+ * @param {TerrainProvider} terrainProvider
+ * @param {VectorProvider} vectorProvider
+ * @param {ImageryLayerCollection} imageryLayerCollection
+ * @param {QuadtreePrimitive} quadtree
+ * @param {*} vertexArraysToDestroy
+ * @ignore
+ */
 function processTerrainStateMachine(
   tile,
   frameState,
   terrainProvider,
+  vectorProvider,
   imageryLayerCollection,
   quadtree,
   vertexArraysToDestroy,
 ) {
-  const surfaceTile = tile.data;
+  const surfaceTile = /** @type {GlobeSurfaceTile} */ (tile.data);
 
   // If this tile is FAILED, we'll need to upsample from the parent. If the parent isn't
   // ready for that, let's push it along.
@@ -505,15 +709,19 @@ function processTerrainStateMachine(
     surfaceTile.terrainState === TerrainState.FAILED &&
     parent !== undefined
   ) {
+    const parentSurfaceTile = /** @type {GlobeSurfaceTile|undefined} */ (
+      parent.data
+    );
     const parentReady =
-      parent.data !== undefined &&
-      parent.data.terrainData !== undefined &&
-      parent.data.terrainData.canUpsample !== false;
+      parentSurfaceTile !== undefined &&
+      parentSurfaceTile.terrainData !== undefined &&
+      parentSurfaceTile.terrainData.canUpsample !== false;
     if (!parentReady) {
       GlobeSurfaceTile.processStateMachine(
         parent,
         frameState,
         terrainProvider,
+        vectorProvider,
         imageryLayerCollection,
         quadtree,
         vertexArraysToDestroy,
@@ -573,6 +781,7 @@ function processTerrainStateMachine(
   if (
     surfaceTile.terrainState >= TerrainState.RECEIVED &&
     surfaceTile.waterMaskTexture === undefined &&
+    // @ts-expect-error Missing types.
     terrainProvider.hasWaterMask
   ) {
     const terrainData = surfaceTile.terrainData;
@@ -580,8 +789,11 @@ function processTerrainStateMachine(
       createWaterMaskTextureIfNeeded(frameState.context, surfaceTile);
     } else {
       const sourceTile = surfaceTile._findAncestorTileWithTerrainData(tile);
-      if (defined(sourceTile) && defined(sourceTile.data.waterMaskTexture)) {
-        surfaceTile.waterMaskTexture = sourceTile.data.waterMaskTexture;
+      const sourceSurfaceTile = /** @type {GlobeSurfaceTile|undefined} */ (
+        sourceTile?.data
+      );
+      if (defined(sourceTile) && defined(sourceSurfaceTile.waterMaskTexture)) {
+        surfaceTile.waterMaskTexture = sourceSurfaceTile.waterMaskTexture;
         ++surfaceTile.waterMaskTexture.referenceCount;
         surfaceTile._computeWaterMaskTranslationAndScale(
           tile,
@@ -593,6 +805,16 @@ function processTerrainStateMachine(
   }
 }
 
+/**
+ * @param {GlobeSurfaceTile} surfaceTile
+ * @param {QuadtreeTile} tile
+ * @param {FrameState} frameState
+ * @param {TerrainProvider} terrainProvider
+ * @param {number} x
+ * @param {number} y
+ * @param {number} level
+ * @ignore
+ */
 function upsample(surfaceTile, tile, frameState, terrainProvider, x, y, level) {
   const parent = tile.parent;
   if (!parent) {
@@ -601,7 +823,8 @@ function upsample(surfaceTile, tile, frameState, terrainProvider, x, y, level) {
     return;
   }
 
-  const sourceData = parent.data.terrainData;
+  const parentSurfaceTile = /** @type {GlobeSurfaceTile} */ (parent.data);
+  const sourceData = parentSurfaceTile.terrainData;
   const sourceX = parent.x;
   const sourceY = parent.y;
   const sourceLevel = parent.level;
@@ -612,6 +835,7 @@ function upsample(surfaceTile, tile, frameState, terrainProvider, x, y, level) {
   }
 
   const terrainDataPromise = sourceData.upsample(
+    // @ts-expect-error Missing types.
     terrainProvider.tilingScheme,
     sourceX,
     sourceY,
@@ -642,7 +866,16 @@ function upsample(surfaceTile, tile, frameState, terrainProvider, x, y, level) {
     });
 }
 
+/**
+ * @param {GlobeSurfaceTile} surfaceTile
+ * @param {TerrainProvider} terrainProvider
+ * @param {number} x
+ * @param {number} y
+ * @param {number} level
+ * @ignore
+ */
 function requestTileGeometry(surfaceTile, terrainProvider, x, y, level) {
+  /** @param {HeightmapTerrainData} terrainData */
   function success(terrainData) {
     if (!defined(terrainData)) {
       // Throttled due to low priority - try again later.
@@ -656,6 +889,7 @@ function requestTileGeometry(surfaceTile, terrainProvider, x, y, level) {
     surfaceTile.request = undefined;
   }
 
+  /** @param {Error} error */
   function failure(error) {
     if (surfaceTile.request.state === RequestState.CANCELLED) {
       // Cancelled due to low priority - try again later.
@@ -671,15 +905,19 @@ function requestTileGeometry(surfaceTile, terrainProvider, x, y, level) {
     surfaceTile.request = undefined;
 
     const message = `Failed to obtain terrain tile X: ${x} Y: ${y} Level: ${level}. Error message: "${error}"`;
+    // @ts-expect-error Missing types.
     terrainProvider._requestError = TileProviderError.reportError(
+      // @ts-expect-error Missing types.
       terrainProvider._requestError,
       terrainProvider,
+      // @ts-expect-error Missing types.
       terrainProvider.errorEvent,
       message,
       x,
       y,
       level,
     );
+    // @ts-expect-error Missing types.
     if (terrainProvider._requestError.retry) {
       doRequest();
     }
@@ -695,6 +933,7 @@ function requestTileGeometry(surfaceTile, terrainProvider, x, y, level) {
     surfaceTile.request = request;
 
     const requestPromise = terrainProvider.requestTileGeometry(
+      // @ts-expect-error Missing types.
       x,
       y,
       level,
@@ -732,7 +971,17 @@ const scratchCreateMeshOptions = {
   throttle: true,
 };
 
+/**
+ * @param {GlobeSurfaceTile} surfaceTile
+ * @param {FrameState} frameState
+ * @param {TerrainProvider} terrainProvider
+ * @param {number} x
+ * @param {number} y
+ * @param {number} level
+ * @ignore
+ */
 function transform(surfaceTile, frameState, terrainProvider, x, y, level) {
+  // @ts-expect-error Missing types.
   const tilingScheme = terrainProvider.tilingScheme;
 
   const createMeshOptions = scratchCreateMeshOptions;
@@ -765,61 +1014,16 @@ function transform(surfaceTile, frameState, terrainProvider, x, y, level) {
     });
 }
 
-GlobeSurfaceTile._createVertexArrayForMesh = function (context, mesh) {
-  const typedArray = mesh.vertices;
-  const buffer = Buffer.createVertexBuffer({
-    context: context,
-    typedArray: typedArray,
-    usage: BufferUsage.STATIC_DRAW,
-  });
-  const attributes = mesh.encoding.getAttributes(buffer);
-
-  const indexBuffers = mesh.indices.indexBuffers || {};
-  let indexBuffer = indexBuffers[context.id];
-  if (!defined(indexBuffer) || indexBuffer.isDestroyed()) {
-    const indices = mesh.indices;
-    indexBuffer = Buffer.createIndexBuffer({
-      context: context,
-      typedArray: indices,
-      usage: BufferUsage.STATIC_DRAW,
-      indexDatatype: IndexDatatype.fromSizeInBytes(indices.BYTES_PER_ELEMENT),
-    });
-    indexBuffer.vertexArrayDestroyable = false;
-    indexBuffer.referenceCount = 1;
-    indexBuffers[context.id] = indexBuffer;
-    mesh.indices.indexBuffers = indexBuffers;
-  } else {
-    ++indexBuffer.referenceCount;
-  }
-
-  return new VertexArray({
-    context: context,
-    attributes: attributes,
-    indexBuffer: indexBuffer,
-  });
-};
-
-GlobeSurfaceTile._freeVertexArray = function (vertexArray) {
-  if (defined(vertexArray)) {
-    const indexBuffer = vertexArray.indexBuffer;
-
-    if (!vertexArray.isDestroyed()) {
-      vertexArray.destroy();
-    }
-
-    if (
-      defined(indexBuffer) &&
-      !indexBuffer.isDestroyed() &&
-      defined(indexBuffer.referenceCount)
-    ) {
-      --indexBuffer.referenceCount;
-      if (indexBuffer.referenceCount === 0) {
-        indexBuffer.destroy();
-      }
-    }
-  }
-};
-
+/**
+ * @param {GlobeSurfaceTile} surfaceTile
+ * @param {Context} context
+ * @param {TerrainProvider} terrainProvider
+ * @param {number} x
+ * @param {number} y
+ * @param {number} level
+ * @param {*} vertexArraysToDestroy
+ * @ignore
+ */
 function createResources(
   surfaceTile,
   context,
@@ -838,6 +1042,10 @@ function createResources(
     surfaceTile.fill && surfaceTile.fill.destroy(vertexArraysToDestroy);
 }
 
+/**
+ * @param {Context} context
+ * @ignore
+ */
 function getContextWaterMaskData(context) {
   let data = context.cache.tile_waterMaskData;
 
@@ -875,6 +1083,11 @@ function getContextWaterMaskData(context) {
   return data;
 }
 
+/**
+ * @param {Context} context
+ * @param {GlobeSurfaceTile} surfaceTile
+ * @ignore
+ */
 function createWaterMaskTextureIfNeeded(context, surfaceTile) {
   const waterMask = surfaceTile.terrainData.waterMask;
   const waterMaskData = getContextWaterMaskData(context);
@@ -928,40 +1141,4 @@ function createWaterMaskTextureIfNeeded(context, surfaceTile) {
   );
 }
 
-GlobeSurfaceTile.prototype._findAncestorTileWithTerrainData = function (tile) {
-  let sourceTile = tile.parent;
-
-  while (
-    defined(sourceTile) &&
-    (!defined(sourceTile.data) ||
-      !defined(sourceTile.data.terrainData) ||
-      sourceTile.data.terrainData.wasCreatedByUpsampling())
-  ) {
-    sourceTile = sourceTile.parent;
-  }
-
-  return sourceTile;
-};
-
-GlobeSurfaceTile.prototype._computeWaterMaskTranslationAndScale = function (
-  tile,
-  sourceTile,
-  result,
-) {
-  const sourceTileRectangle = sourceTile.rectangle;
-  const tileRectangle = tile.rectangle;
-  const tileWidth = tileRectangle.width;
-  const tileHeight = tileRectangle.height;
-
-  const scaleX = tileWidth / sourceTileRectangle.width;
-  const scaleY = tileHeight / sourceTileRectangle.height;
-  result.x =
-    (scaleX * (tileRectangle.west - sourceTileRectangle.west)) / tileWidth;
-  result.y =
-    (scaleY * (tileRectangle.south - sourceTileRectangle.south)) / tileHeight;
-  result.z = scaleX;
-  result.w = scaleY;
-
-  return result;
-};
 export default GlobeSurfaceTile;