@cesium/engine 2.1.0 → 2.3.0

package/Source/Scene/Cesium3DTile.js

@@ -52,6 +52,10 @@ import Pass from "../Renderer/Pass.js";
  *
  * @alias Cesium3DTile
  * @constructor
+ * @param {Cesium3DTileset} tileset The tileset
+ * @param {Resource} baseResource The base resource for the tileset
+ * @param {object} header The JSON header for the tile
+ * @param {Cesium3DTile} parent The parent tile of the new tile
  */
 function Cesium3DTile(tileset, baseResource, header, parent) {
   this._tileset = tileset;
@@ -255,8 +259,6 @@ function Cesium3DTile(tileset, baseResource, header, parent) {
   this._content = content;
   this._contentResource = contentResource;
   this._contentState = contentState;
-  this._contentReadyToProcessPromise = undefined;
-  this._contentReadyPromise = undefined;
   this._expiredContent = undefined;
 
   this._serverKey = serverKey;
@@ -574,13 +576,29 @@ Object.defineProperties(Cesium3DTile.prototype, {
     },
   },
 
+  /**
+   * Determines if the tile is visible within the current field of view
+   *
+   * @memberof Cesium3DTile.prototype
+   *
+   * @type {boolean}
+   * @readonly
+   *
+   * @private
+   */
+  isVisible: {
+    get: function () {
+      return this._visible && this._inRequestVolume;
+    },
+  },
+
   /**
    * Returns the <code>extras</code> property in the tileset JSON for this tile, which contains application specific metadata.
    * Returns <code>undefined</code> if <code>extras</code> does not exist.
    *
    * @memberof Cesium3DTile.prototype
    *
-   * @type {*}
+   * @type {object}
    * @readonly
    * @see {@link https://github.com/CesiumGS/3d-tiles/tree/main/specification#specifying-extensions-and-application-specific-extras|Extras in the 3D Tiles specification.}
    */
@@ -614,6 +632,27 @@ Object.defineProperties(Cesium3DTile.prototype, {
     },
   },
 
+  /**
+   * Determines if the tile's content is renderable. <code>false</code> if the
+   * tile has empty content or if it points to an external tileset or implicit content
+   *
+   * @memberof Cesium3DTile.prototype
+   *
+   * @type {boolean}
+   * @readonly
+   *
+   * @private
+   */
+  hasRenderableContent: {
+    get: function () {
+      return (
+        !this.hasEmptyContent &&
+        !this.hasTilesetContent &&
+        !this.hasImplicitContent
+      );
+    },
+  },
+
   /**
    * Determines if the tile has available content to render.  <code>true</code> if the tile's
    * content is ready or if it has expired content that renders while new content loads; otherwise,
@@ -629,10 +668,7 @@ Object.defineProperties(Cesium3DTile.prototype, {
   contentAvailable: {
     get: function () {
       return (
-        (this.contentReady &&
-          !this.hasEmptyContent &&
-          !this.hasTilesetContent &&
-          !this.hasImplicitContent) ||
+        (this.contentReady && this.hasRenderableContent) ||
         (defined(this._expiredContent) && !this.contentFailed)
       );
     },
@@ -673,8 +709,7 @@ Object.defineProperties(Cesium3DTile.prototype, {
   },
 
   /**
-   * Determines if the tile's content is expired. <code>true</code> if tile's
-   * content is expired; otherwise, <code>false</code>.
+   * Determines if the tile has renderable content which is unloaded
    *
    * @memberof Cesium3DTile.prototype
    *
@@ -683,15 +718,15 @@ Object.defineProperties(Cesium3DTile.prototype, {
    *
    * @private
    */
-  contentExpired: {
+  hasUnloadedRenderableContent: {
     get: function () {
-      return this._contentState === Cesium3DTileContentState.EXPIRED;
+      return this.hasRenderableContent && this.contentUnloaded;
     },
   },
 
   /**
-   * Determines if the tile's content failed to load.  <code>true</code> if the tile's
-   * content failed to load; otherwise, <code>false</code>.
+   * Determines if the tile's content is expired. <code>true</code> if tile's
+   * content is expired; otherwise, <code>false</code>.
    *
    * @memberof Cesium3DTile.prototype
    *
@@ -700,45 +735,26 @@ Object.defineProperties(Cesium3DTile.prototype, {
    *
    * @private
    */
-  contentFailed: {
+  contentExpired: {
     get: function () {
-      return this._contentState === Cesium3DTileContentState.FAILED;
+      return this._contentState === Cesium3DTileContentState.EXPIRED;
     },
   },
 
   /**
-   * Gets the promise that will be resolved when the tile's content is ready to process.
-   * This happens after the content is downloaded but before the content is ready
-   * to render.
-   * <p>
-   * The promise remains <code>undefined</code> until the tile's content is requested.
-   * </p>
-   *
-   * @type {Promise<Cesium3DTileContent>}
-   * @readonly
+   * Determines if the tile's content failed to load.  <code>true</code> if the tile's
+   * content failed to load; otherwise, <code>false</code>.
    *
-   * @private
-   */
-  contentReadyToProcessPromise: {
-    get: function () {
-      return this._contentReadyToProcessPromise;
-    },
-  },
-
-  /**
-   * Gets the promise that will be resolved when the tile's content is ready to render.
-   * <p>
-   * The promise remains <code>undefined</code> until the tile's content is requested.
-   * </p>
+   * @memberof Cesium3DTile.prototype
    *
-   * @type {Promise<Cesium3DTileContent>}
+   * @type {boolean}
    * @readonly
    *
    * @private
    */
-  contentReadyPromise: {
+  contentFailed: {
     get: function () {
-      return this._contentReadyPromise;
+      return this._contentState === Cesium3DTileContentState.FAILED;
     },
   },
 
@@ -757,13 +773,20 @@ Object.defineProperties(Cesium3DTile.prototype, {
 });
 
 const scratchCartesian = new Cartesian3();
+
+/**
+ * @private
+ * @param {Cesium3DTile} tile
+ * @param {FrameState} frameState
+ * @returns {Boolean}
+ */
 function isPriorityDeferred(tile, frameState) {
-  const tileset = tile._tileset;
+  const { tileset, boundingSphere } = tile;
+  const { radius, center } = boundingSphere;
+  const { camera } = frameState;
 
-  // If closest point on line is inside the sphere then set foveatedFactor to 0. Otherwise, the dot product is with the line from camera to the point on the sphere that is closest to the line.
-  const camera = frameState.camera;
-  const boundingSphere = tile.boundingSphere;
-  const radius = boundingSphere.radius;
+  // If closest point on line is inside the sphere then set foveatedFactor to 0.
+  // Otherwise, the dot product is with the line from camera to the point on the sphere that is closest to the line.
   const scaledCameraDirection = Cartesian3.multiplyByScalar(
     camera.directionWC,
     tile._centerZDepth,
@@ -777,7 +800,7 @@ function isPriorityDeferred(tile, frameState) {
   // The distance from the camera's view direction to the tile.
   const toLine = Cartesian3.subtract(
     closestPointOnLine,
-    boundingSphere.center,
+    center,
     scratchCartesian
   );
   const distanceToCenterLine = Cartesian3.magnitude(toLine);
@@ -795,7 +818,7 @@ function isPriorityDeferred(tile, frameState) {
       scratchCartesian
     );
     const closestOnSphere = Cartesian3.add(
-      boundingSphere.center,
+      center,
       scaledToLine,
       scratchCartesian
     );
@@ -818,7 +841,7 @@ function isPriorityDeferred(tile, frameState) {
   // Skip this feature if: non-skipLevelOfDetail and replace refine, if the foveated settings are turned off, if tile is progressive resolution and replace refine and skipLevelOfDetail (will help get rid of ancestor artifacts faster)
   // Or if the tile is a preload of any kind
   const replace = tile.refine === Cesium3DTileRefine.REPLACE;
-  const skipLevelOfDetail = tileset._skipLevelOfDetail;
+  const skipLevelOfDetail = tileset.isSkippingLevelOfDetail;
   if (
     (replace && !skipLevelOfDetail) ||
     !tileset.foveatedScreenSpaceError ||
@@ -864,6 +887,9 @@ const scratchJulianDate = new JulianDate();
  * Get the tile's screen space error.
  *
  * @private
+ * @param {FrameState} frameState
+ * @param {Boolean} useParentGeometricError
+ * @param {number} progressiveResolutionHeightFraction
  */
 Cesium3DTile.prototype.getScreenSpaceError = function (
   frameState,
@@ -882,9 +908,8 @@ Cesium3DTile.prototype.getScreenSpaceError = function (
     // Leaf tiles do not have any error so save the computation
     return 0.0;
   }
-  const camera = frameState.camera;
+  const { camera, context } = frameState;
   let frustum = camera.frustum;
-  const context = frameState.context;
   const width = context.drawingBufferWidth;
   const height = context.drawingBufferHeight * heightFraction;
   let error;
@@ -892,8 +917,9 @@ Cesium3DTile.prototype.getScreenSpaceError = function (
     frameState.mode === SceneMode.SCENE2D ||
     frustum instanceof OrthographicFrustum
   ) {
-    if (defined(frustum._offCenterFrustum)) {
-      frustum = frustum._offCenterFrustum;
+    const offCenterFrustum = frustum.offCenterFrustum;
+    if (defined(offCenterFrustum)) {
+      frustum = offCenterFrustum;
     }
     const pixelSize =
       Math.max(frustum.top - frustum.bottom, frustum.right - frustum.left) /
@@ -902,7 +928,7 @@ Cesium3DTile.prototype.getScreenSpaceError = function (
   } else {
     // Avoid divide by zero when viewer is inside the tile
     const distance = Math.max(this._distanceToCamera, CesiumMath.EPSILON7);
-    const sseDenominator = camera.frustum.sseDenominator;
+    const sseDenominator = frustum.sseDenominator;
     error = (geometricError * height) / (distance * sseDenominator);
     if (tileset.dynamicScreenSpaceError) {
       const density = tileset._dynamicScreenSpaceErrorComputedDensity;
@@ -917,6 +943,12 @@ Cesium3DTile.prototype.getScreenSpaceError = function (
   return error;
 };
 
+/**
+ * @private
+ * @param {Cesium3DTileset} tileset
+ * @param {Cesium3DTile} tile
+ * @returns {Boolean}
+ */
 function isPriorityProgressiveResolution(tileset, tile) {
   if (
     tileset.progressiveResolutionHeightFraction <= 0.0 ||
@@ -944,11 +976,17 @@ function isPriorityProgressiveResolution(tileset, tile) {
   return isProgressiveResolutionTile;
 }
 
+/**
+ * @private
+ * @param {Cesium3DTileset} tileset
+ * @param {Cesium3DTile} tile
+ * @returns {number}
+ */
 function getPriorityReverseScreenSpaceError(tileset, tile) {
   const parent = tile.parent;
   const useParentScreenSpaceError =
     defined(parent) &&
-    (!tileset._skipLevelOfDetail ||
+    (!tileset.isSkippingLevelOfDetail ||
       tile._screenSpaceError === 0.0 ||
       parent.hasTilesetContent ||
       parent.hasImplicitContent);
@@ -962,10 +1000,15 @@ function getPriorityReverseScreenSpaceError(tileset, tile) {
  * Update the tile's visibility.
  *
  * @private
+ * @param {FrameState} frameState
  */
 Cesium3DTile.prototype.updateVisibility = function (frameState) {
-  const parent = this.parent;
-  const tileset = this._tileset;
+  const { parent, tileset } = this;
+  if (this._updatedVisibilityFrame === tileset._updatedVisibilityFrame) {
+    // The tile has already been updated for this frame
+    return;
+  }
+
   const parentTransform = defined(parent)
     ? parent.computedTransform
     : tileset.modelMatrix;
@@ -996,6 +1039,8 @@ Cesium3DTile.prototype.updateVisibility = function (frameState) {
     this
   );
   this.priorityDeferred = isPriorityDeferred(this, frameState);
+
+  this._updatedVisibilityFrame = tileset._updatedVisibilityFrame;
 };
 
 /**
@@ -1018,25 +1063,35 @@ Cesium3DTile.prototype.updateExpiration = function () {
   }
 };
 
+/**
+ * @private
+ * @param {Cesium3DTile} tile
+ */
 function updateExpireDate(tile) {
-  if (defined(tile.expireDuration)) {
-    const expireDurationDate = JulianDate.now(scratchJulianDate);
-    JulianDate.addSeconds(
-      expireDurationDate,
-      tile.expireDuration,
-      expireDurationDate
-    );
+  if (!defined(tile.expireDuration)) {
+    return;
+  }
+  const expireDurationDate = JulianDate.now(scratchJulianDate);
+  JulianDate.addSeconds(
+    expireDurationDate,
+    tile.expireDuration,
+    expireDurationDate
+  );
 
-    if (defined(tile.expireDate)) {
-      if (JulianDate.lessThan(tile.expireDate, expireDurationDate)) {
-        JulianDate.clone(expireDurationDate, tile.expireDate);
-      }
-    } else {
-      tile.expireDate = JulianDate.clone(expireDurationDate);
+  if (defined(tile.expireDate)) {
+    if (JulianDate.lessThan(tile.expireDate, expireDurationDate)) {
+      JulianDate.clone(expireDurationDate, tile.expireDate);
     }
+  } else {
+    tile.expireDate = JulianDate.clone(expireDurationDate);
   }
 }
 
+/**
+ * @private
+ * @param {Cesium3DTile} tile
+ * @returns {Function}
+ */
 function createPriorityFunction(tile) {
   return function () {
     return tile._priority;
@@ -1049,13 +1104,13 @@ function createPriorityFunction(tile) {
  * The request may not be made if the Cesium Request Scheduler can't prioritize it.
  * </p>
  *
- * @return {number} The number of requests that were attempted but not scheduled.
+ * @return {Promise<Cesium3DTileContent>|undefined} A promise that resolves when the request completes, or undefined if there is no request needed, or the request cannot be scheduled.
  * @private
  */
 Cesium3DTile.prototype.requestContent = function () {
   // empty contents don't require any HTTP requests
   if (this.hasEmptyContent) {
-    return 0;
+    return;
   }
 
   if (this.hasMultipleContents) {
@@ -1076,6 +1131,8 @@ Cesium3DTile.prototype.requestContent = function () {
  * </p>
  *
  * @private
+ * @param {Cesium3DTile} tile
+ * @returns {Promise<Cesium3DTileContent>|Promise<undefined>|undefined} A promise that resolves to the tile content once loaded, or a promise that resolves to undefined if the request was cancelled mid-flight, or undefined if the request cannot be scheduled this frame
  */
 function requestMultipleContents(tile) {
   let multipleContents = tile._content;
@@ -1097,86 +1154,120 @@ function requestMultipleContents(tile) {
     tile._content = multipleContents;
   }
 
-  const backloggedRequestCount = multipleContents.requestInnerContents();
-  if (backloggedRequestCount > 0) {
-    return backloggedRequestCount;
+  const promise = multipleContents.requestInnerContents();
+
+  if (!defined(promise)) {
+    // Request could not all be scheduled this frame
+    return;
   }
 
   tile._contentState = Cesium3DTileContentState.LOADING;
-  const contentReadyToProcessPromise = multipleContents.contentsFetchedPromise.then(
-    function () {
-      if (
-        tile._contentState !== Cesium3DTileContentState.LOADING ||
-        !defined(multipleContents.readyPromise)
-      ) {
-        // The tile or one of the inner content requests was canceled,
-        // short circuit.
-        return;
-      }
-
+  return promise
+    .then((content) => {
       if (tile.isDestroyed()) {
-        multipleContentFailed(
-          tile,
-          tileset,
-          "Tile was unloaded while content was loading"
-        );
+        // Tile is unloaded before the content can process
         return;
       }
 
-      tile._contentState = Cesium3DTileContentState.PROCESSING;
-      return multipleContents;
-    }
-  );
-  tile._contentReadyToProcessPromise = contentReadyToProcessPromise;
-  tile._contentReadyPromise = contentReadyToProcessPromise
-    .then(function (content) {
+      // Tile was canceled, try again later
       if (!defined(content)) {
-        // request was canceled, short circuit.
         return;
       }
 
-      return multipleContents.readyPromise;
+      tile._contentState = Cesium3DTileContentState.PROCESSING;
+      return multipleContents;
     })
-    .then(function (content) {
-      if (!defined(content)) {
-        // tile was canceled, short circuit.
-        return;
-      }
-
+    .catch((error) => {
       if (tile.isDestroyed()) {
-        multipleContentFailed(
-          tile,
-          tileset,
-          "Tile was unloaded while content was processing"
-        );
+        // Tile is unloaded before the content can process
         return;
       }
 
-      // Refresh style for expired content
-      tile._selectedFrame = 0;
-      tile.lastStyleTime = 0.0;
-
-      JulianDate.now(tile._loadTimestamp);
-      tile._contentState = Cesium3DTileContentState.READY;
-      return content;
-    })
-    .catch(function (error) {
-      multipleContentFailed(tile, tileset, error);
+      tile._contentState = Cesium3DTileContentState.FAILED;
+      throw error;
     });
-
-  return 0;
 }
 
-function multipleContentFailed(tile, tileset, error) {
-  // note: The Multiple3DTileContent handles decrementing the number of pending
-  // requests if the state is LOADING.
-  if (tile._contentState === Cesium3DTileContentState.PROCESSING) {
-    --tileset.statistics.numberOfTilesProcessing;
+async function processArrayBuffer(
+  tile,
+  tileset,
+  request,
+  expired,
+  requestPromise
+) {
+  const previousState = tile._contentState;
+  tile._contentState = Cesium3DTileContentState.LOADING;
+  ++tileset.statistics.numberOfPendingRequests;
+
+  let arrayBuffer;
+  try {
+    arrayBuffer = await requestPromise;
+  } catch (error) {
+    --tileset.statistics.numberOfPendingRequests;
+    if (tile.isDestroyed()) {
+      // Tile is unloaded before the content can process
+      return;
+    }
+
+    if (request.cancelled || request.state === RequestState.CANCELLED) {
+      // Cancelled due to low priority - try again later.
+      tile._contentState = previousState;
+      ++tileset.statistics.numberOfAttemptedRequests;
+      return;
+    }
+
+    tile._contentState = Cesium3DTileContentState.FAILED;
+    throw error;
+  }
+
+  if (tile.isDestroyed()) {
+    --tileset.statistics.numberOfPendingRequests;
+    // Tile is unloaded before the content can process
+    return;
+  }
+
+  if (request.cancelled || request.state === RequestState.CANCELLED) {
+    // Cancelled due to low priority - try again later.
+    tile._contentState = previousState;
+    --tileset.statistics.numberOfPendingRequests;
+    ++tileset.statistics.numberOfAttemptedRequests;
+    return;
   }
 
-  tile._contentState = Cesium3DTileContentState.FAILED;
+  try {
+    const content = await makeContent(tile, arrayBuffer);
+    --tileset.statistics.numberOfPendingRequests;
+
+    if (tile.isDestroyed()) {
+      // Tile is unloaded before the content can process
+      return;
+    }
+
+    if (expired) {
+      tile.expireDate = undefined;
+    }
+
+    tile._content = content;
+    tile._contentState = Cesium3DTileContentState.PROCESSING;
+
+    return content;
+  } catch (error) {
+    --tileset.statistics.numberOfPendingRequests;
+    if (tile.isDestroyed()) {
+      // Tile is unloaded before the content can process
+      return;
+    }
+
+    tile._contentState = Cesium3DTileContentState.FAILED;
+    throw error;
+  }
 }
 
+/**
+ * @private
+ * @param {Cesium3DTile} tile
+ * @returns {Promise<Cesium3DTileContent>|Promise<undefined>|undefined} A promise that resolves to the tile content once loaded; a promise that resolves to undefined if the tile was destroyed before processing can happen or the request was cancelled mid-flight; or undefined if the request cannot be scheduled this frame.
+ */
 function requestSingleContent(tile) {
   // it is important to clone here. The fetchArrayBuffer() below uses
   // throttling, but other uses of the resources do not.
@@ -1199,85 +1290,14 @@ function requestSingleContent(tile) {
 
   tile._request = request;
   resource.request = request;
-
+  const tileset = tile._tileset;
   const promise = resource.fetchArrayBuffer();
   if (!defined(promise)) {
-    return 1;
+    ++tileset.statistics.numberOfAttemptedRequests;
+    return;
   }
 
-  const previousState = tile._contentState;
-  const tileset = tile._tileset;
-  tile._contentState = Cesium3DTileContentState.LOADING;
-  ++tileset.statistics.numberOfPendingRequests;
-  const contentReadyToProcessPromise = promise.then(function (arrayBuffer) {
-    if (tile.isDestroyed()) {
-      // Tile is unloaded before the content finishes loading
-      singleContentFailed(tile, tileset);
-      return;
-    }
-
-    const content = makeContent(tile, arrayBuffer);
-
-    if (expired) {
-      tile.expireDate = undefined;
-    }
-
-    tile._content = content;
-    tile._contentState = Cesium3DTileContentState.PROCESSING;
-    return content;
-  });
-  tile._contentReadyToProcessPromise = contentReadyToProcessPromise;
-  tile._contentReadyPromise = contentReadyToProcessPromise
-    .then(function (content) {
-      if (!defined(content)) {
-        return;
-      }
-
-      --tileset.statistics.numberOfPendingRequests;
-      return content.readyPromise;
-    })
-    .then(function (content) {
-      if (!defined(content)) {
-        return;
-      }
-
-      if (tile.isDestroyed()) {
-        // Tile is unloaded before the content finishes processing
-        singleContentFailed(tile, tileset);
-        return;
-      }
-      updateExpireDate(tile);
-
-      // Refresh style for expired content
-      tile._selectedFrame = 0;
-      tile.lastStyleTime = 0.0;
-
-      JulianDate.now(tile._loadTimestamp);
-      tile._contentState = Cesium3DTileContentState.READY;
-      return content;
-    })
-    .catch(function (error) {
-      if (request.state === RequestState.CANCELLED) {
-        // Cancelled due to low priority - try again later.
-        tile._contentState = previousState;
-        --tileset.statistics.numberOfPendingRequests;
-        ++tileset.statistics.numberOfAttemptedRequests;
-        return Promise.reject("Cancelled");
-      }
-      singleContentFailed(tile, tileset);
-      return Promise.reject(error);
-    });
-
-  return 0;
-}
-
-function singleContentFailed(tile, tileset) {
-  if (tile._contentState === Cesium3DTileContentState.PROCESSING) {
-    --tileset.statistics.numberOfTilesProcessing;
-  } else {
-    --tileset.statistics.numberOfPendingRequests;
-  }
-  tile._contentState = Cesium3DTileContentState.FAILED;
+  return processArrayBuffer(tile, tileset, request, expired, promise);
 }
 
 /**
@@ -1288,10 +1308,10 @@ function singleContentFailed(tile, tileset) {
  *
  * @param {Cesium3DTile} tile The tile
  * @param {ArrayBuffer} arrayBuffer The downloaded payload containing data for the content
- * @return {Cesium3DTileContent} A content object
+ * @return {Promise<Cesium3DTileContent>} A content object
  * @private
  */
-function makeContent(tile, arrayBuffer) {
+async function makeContent(tile, arrayBuffer) {
   const preprocessed = preprocess3DTileContent(arrayBuffer);
 
   // Vector and Geometry tile rendering do not support the skip LOD optimization.
@@ -1314,21 +1334,29 @@ function makeContent(tile, arrayBuffer) {
 
   let content;
   const contentFactory = Cesium3DTileContentFactory[preprocessed.contentType];
+  if (tile.isDestroyed()) {
+    return;
+  }
+
   if (defined(preprocessed.binaryPayload)) {
-    content = contentFactory(
-      tileset,
-      tile,
-      tile._contentResource,
-      preprocessed.binaryPayload.buffer,
-      0
+    content = await Promise.resolve(
+      contentFactory(
+        tileset,
+        tile,
+        tile._contentResource,
+        preprocessed.binaryPayload.buffer,
+        0
+      )
     );
   } else {
     // JSON formats
-    content = contentFactory(
-      tileset,
-      tile,
-      tile._contentResource,
-      preprocessed.jsonPayload
+    content = await Promise.resolve(
+      contentFactory(
+        tileset,
+        tile,
+        tile._contentResource,
+        preprocessed.jsonPayload
+      )
     );
   }
 
@@ -1372,18 +1400,12 @@ Cesium3DTile.prototype.cancelRequests = function () {
  * @private
  */
 Cesium3DTile.prototype.unloadContent = function () {
-  if (
-    this.hasEmptyContent ||
-    this.hasTilesetContent ||
-    this.hasImplicitContent
-  ) {
+  if (!this.hasRenderableContent) {
     return;
   }
 
   this._content = this._content && this._content.destroy();
   this._contentState = Cesium3DTileContentState.UNLOADED;
-  this._contentReadyToProcessPromise = undefined;
-  this._contentReadyPromise = undefined;
 
   this.lastStyleTime = 0.0;
   this.clippingPlanesDirty = this._clippingPlanesState === 0;
@@ -1402,6 +1424,12 @@ Cesium3DTile.prototype.unloadContent = function () {
 
 const scratchProjectedBoundingSphere = new BoundingSphere();
 
+/**
+ * @private
+ * @param {Cesium3DTile} tile
+ * @param {FrameState} frameState
+ * @returns {TileBoundingVolume}
+ */
 function getBoundingVolume(tile, frameState) {
   if (
     frameState.mode !== SceneMode.SCENE3D &&
@@ -1424,6 +1452,12 @@ function getBoundingVolume(tile, frameState) {
     : tile._boundingVolume;
 }
 
+/**
+ * @private
+ * @param {Cesium3DTile} tile
+ * @param {FrameState} frameState
+ * @returns {TileBoundingVolume}
+ */
 function getContentBoundingVolume(tile, frameState) {
   if (
     frameState.mode !== SceneMode.SCENE3D &&
@@ -1581,6 +1615,13 @@ const scratchRectangle = new Rectangle();
 const scratchOrientedBoundingBox = new OrientedBoundingBox();
 const scratchTransform = new Matrix4();
 
+/**
+ * @private
+ * @param {Array} box An array of 12 numbers that define an oriented bounding box
+ * @param {Matrix4} transform
+ * @param {TileBoundingVolume} [result]
+ * @returns {TileOrientedBoundingBox}
+ */
 function createBox(box, transform, result) {
   let center = Cartesian3.fromElements(box[0], box[1], box[2], scratchCenter);
   let halfAxes = Matrix3.fromArray(box, 3, scratchHalfAxes);
@@ -1597,6 +1638,14 @@ function createBox(box, transform, result) {
   return new TileOrientedBoundingBox(center, halfAxes);
 }
 
+/**
+ * @private
+ * @param {Array} region An array of six numbers that define a bounding geographic region in EPSG:4979 coordinates with the order [west, south, east, north, minimum height, maximum height]
+ * @param {Matrix4} transform
+ * @param {Matrix4} initialTransform
+ * @param {TileOrientedBoundingBox} [result]
+ * @returns {TileOrientedBoundingBox}
+ */
 function createBoxFromTransformedRegion(
   region,
   transform,
@@ -1637,6 +1686,14 @@ function createBoxFromTransformedRegion(
   return new TileOrientedBoundingBox(center, halfAxes);
 }
 
+/**
+ * @private
+ * @param {Array} region An array of six numbers that define a bounding geographic region in EPSG:4979 coordinates with the order [west, south, east, north, minimum height, maximum height]
+ * @param {Matrix4} transform
+ * @param {Matrix4} initialTransform
+ * @param {TileBoundingVolume} [result]
+ * @returns {TileBoundingVolume}
+ */
 function createRegion(region, transform, initialTransform, result) {
   if (
     !Matrix4.equalsEpsilon(transform, initialTransform, CesiumMath.EPSILON8)
@@ -1662,6 +1719,13 @@ function createRegion(region, transform, initialTransform, result) {
   });
 }
 
+/**
+ * @private
+ * @param {Array} sphere An array of four numbers that define a bounding sphere
+ * @param {Matrix4} transform
+ * @param {TileBoundingVolume} [result]
+ * @returns {TileBoundingSphere}
+ */
 function createSphere(sphere, transform, result) {
   let center = Cartesian3.fromElements(
     sphere[0],
@@ -1710,19 +1774,15 @@ Cesium3DTile.prototype.createBoundingVolume = function (
     );
   }
 
-  if (defined(boundingVolumeHeader.box)) {
-    return createBox(boundingVolumeHeader.box, transform, result);
+  const { box, region, sphere } = boundingVolumeHeader;
+  if (defined(box)) {
+    return createBox(box, transform, result);
   }
-  if (defined(boundingVolumeHeader.region)) {
-    return createRegion(
-      boundingVolumeHeader.region,
-      transform,
-      this._initialTransform,
-      result
-    );
+  if (defined(region)) {
+    return createRegion(region, transform, this._initialTransform, result);
   }
-  if (defined(boundingVolumeHeader.sphere)) {
-    return createSphere(boundingVolumeHeader.sphere, transform, result);
+  if (defined(sphere)) {
+    return createSphere(sphere, transform, result);
   }
   throw new RuntimeError(
     "boundingVolume must contain a sphere, region, or box"
@@ -1733,10 +1793,11 @@ Cesium3DTile.prototype.createBoundingVolume = function (
  * Update the tile's transform. The transform is applied to the tile's bounding volumes.
  *
  * @private
+ * @param {Matrix4} parentTransform
  */
 Cesium3DTile.prototype.updateTransform = function (parentTransform) {
   parentTransform = defaultValue(parentTransform, Matrix4.IDENTITY);
-  const computedTransform = Matrix4.multiply(
+  const computedTransform = Matrix4.multiplyTransformation(
     parentTransform,
     this.transform,
     scratchTransform
@@ -1799,6 +1860,13 @@ Cesium3DTile.prototype.updateGeometricErrorScale = function () {
   }
 };
 
+/**
+ * @private
+ * @param {Cesium3DTile} tile
+ * @param {Cesium3DTileset} tileset
+ * @param {FrameState} frameState
+ * @param {object} passOptions
+ */
 function applyDebugSettings(tile, tileset, frameState, passOptions) {
   if (!passOptions.isRender) {
     return;
@@ -1806,8 +1874,6 @@ function applyDebugSettings(tile, tileset, frameState, passOptions) {
 
   const hasContentBoundingVolume =
     defined(tile._contentHeader) && defined(tile._contentHeader.boundingVolume);
-  const empty =
-    tile.hasEmptyContent || tile.hasTilesetContent || tile.hasImplicitContent;
 
   const showVolume =
     tileset.debugShowBoundingVolume ||
@@ -1816,7 +1882,7 @@ function applyDebugSettings(tile, tileset, frameState, passOptions) {
     let color;
     if (!tile._finalResolution) {
       color = Color.YELLOW;
-    } else if (empty) {
+    } else if (!tile.hasRenderableContent) {
       color = Color.DARKGRAY;
     } else {
       color = Color.WHITE;
@@ -1892,15 +1958,24 @@ function applyDebugSettings(tile, tileset, frameState, passOptions) {
   }
 }
 
+/**
+ * @private
+ * @param {Cesium3DTile} tile
+ * @param {Cesium3DTileset} tileset
+ * @param {FrameState} frameState
+ */
 function updateContent(tile, tileset, frameState) {
-  const content = tile._content;
   const expiredContent = tile._expiredContent;
 
   // expired content is not supported for multiple contents
   if (!tile.hasMultipleContents && defined(expiredContent)) {
     if (!tile.contentReady) {
       // Render the expired content while the content loads
-      expiredContent.update(tileset, frameState);
+      try {
+        expiredContent.update(tileset, frameState);
+      } catch (error) {
+        // Eat error for expired content
+      }
       return;
     }
 
@@ -1909,14 +1984,30 @@ function updateContent(tile, tileset, frameState) {
     tile._expiredContent = undefined;
   }
 
-  content.update(tileset, frameState);
+  if (!defined(tile.content)) {
+    // Implicit placeholder tile
+    return;
+  }
+
+  try {
+    tile.content.update(tileset, frameState);
+  } catch (error) {
+    tile._contentState = Cesium3DTileContentState.FAILED;
+    throw error;
+  }
 }
 
+/**
+ * Compute and compare ClippingPlanes state:
+ *  - enabled-ness - are clipping planes enabled? is this tile clipped?
+ *  - clipping plane count
+ *  - clipping function (union v. intersection)
+
+ * @private
+ * @param {Cesium3DTile} tile 
+ * @param {Cesium3DTileset} tileset 
+ */
 function updateClippingPlanes(tile, tileset) {
-  // Compute and compare ClippingPlanes state:
-  // - enabled-ness - are clipping planes enabled? is this tile clipped?
-  // - clipping plane count
-  // - clipping function (union v. intersection)
   const clippingPlanes = tileset.clippingPlanes;
   let currentClippingPlanesState = 0;
   if (defined(clippingPlanes) && tile._isClipped && clippingPlanes.enabled) {
@@ -1933,20 +2024,23 @@ function updateClippingPlanes(tile, tileset) {
  * Get the draw commands needed to render this tile.
  *
  * @private
+ * @param {Cesium3DTileset} tileset
+ * @param {FrameState} frameState
+ * @param {object} passOptions
  */
 Cesium3DTile.prototype.update = function (tileset, frameState, passOptions) {
-  const commandStart = frameState.commandList.length;
+  const { commandList } = frameState;
+  const commandStart = commandList.length;
 
   updateClippingPlanes(this, tileset);
   applyDebugSettings(this, tileset, frameState, passOptions);
   updateContent(this, tileset, frameState);
 
-  const commandEnd = frameState.commandList.length;
-  const commandsLength = commandEnd - commandStart;
-  this._commandsLength = commandsLength;
+  const commandEnd = commandList.length;
+  this._commandsLength = commandEnd - commandStart;
 
-  for (let i = 0; i < commandsLength; ++i) {
-    const command = frameState.commandList[commandStart + i];
+  for (let i = commandStart; i < commandEnd; ++i) {
+    const command = commandList[i];
     const translucent = command.pass === Pass.TRANSLUCENT;
     command.depthForTranslucentClassification = translucent;
   }
@@ -1965,26 +2059,68 @@ const scratchCommandList = [];
  * @private
  */
 Cesium3DTile.prototype.process = function (tileset, frameState) {
+  if (!this.contentExpired && !this.contentReady && this._content.ready) {
+    updateExpireDate(this);
+
+    // Refresh style for expired content
+    this._selectedFrame = 0;
+    this.lastStyleTime = 0.0;
+
+    JulianDate.now(this._loadTimestamp);
+    this._contentState = Cesium3DTileContentState.READY;
+
+    if (!this.hasTilesetContent && !this.hasImplicitContent) {
+      // RESEARCH_IDEA: ability to unload tiles (without content) for an
+      // external tileset when all the tiles are unloaded.
+      tileset._statistics.incrementLoadCounts(this.content);
+      ++tileset._statistics.numberOfTilesWithContentReady;
+      ++tileset._statistics.numberOfLoadedTilesTotal;
+
+      // Add to the tile cache. Previously expired tiles are already in the cache and won't get re-added.
+      tileset._cache.add(this);
+    }
+  }
+
   const savedCommandList = frameState.commandList;
   frameState.commandList = scratchCommandList;
 
-  this._content.update(tileset, frameState);
+  try {
+    this._content.update(tileset, frameState);
+  } catch (error) {
+    this._contentState = Cesium3DTileContentState.FAILED;
+    throw error;
+  }
 
   scratchCommandList.length = 0;
   frameState.commandList = savedCommandList;
 };
 
+/**
+ * @private
+ * @param {number} normalizedValue
+ * @param {number} numberOfDigits
+ * @param {number} leftShift
+ * @returns {number}
+ */
 function isolateDigits(normalizedValue, numberOfDigits, leftShift) {
   const scaled = normalizedValue * Math.pow(10, numberOfDigits);
   const integer = parseInt(scaled);
   return integer * Math.pow(10, leftShift);
 }
 
+/**
+ * @private
+ * @param {number} value
+ * @param {number} minimum
+ * @param {number} maximum
+ * @returns {number}
+ */
 function priorityNormalizeAndClamp(value, minimum, maximum) {
+  // Subtract epsilon since we only want decimal digits present in the output.
   return Math.max(
     CesiumMath.normalize(value, minimum, maximum) - CesiumMath.EPSILON7,
     0.0
-  ); // Subtract epsilon since we only want decimal digits present in the output.
+  );
 }
 
 /**
@@ -2044,7 +2180,8 @@ Cesium3DTile.prototype.updatePriority = function () {
 
   // Map 0-1 then convert to digit. Include a distance sort when doing non-skipLOD and replacement refinement, helps things like non-skipLOD photogrammetry
   const useDistance =
-    !tileset._skipLevelOfDetail && this.refine === Cesium3DTileRefine.REPLACE;
+    !tileset.isSkippingLevelOfDetail &&
+    this.refine === Cesium3DTileRefine.REPLACE;
   const normalizedPreferredSorting = useDistance
     ? priorityNormalizeAndClamp(
         this._priorityHolder._distanceToCamera,
@@ -2118,4 +2255,5 @@ Cesium3DTile.prototype.destroy = function () {
     this._debugViewerRequestVolume && this._debugViewerRequestVolume.destroy();
   return destroyObject(this);
 };
+
 export default Cesium3DTile;