@cesium/engine 2.1.0 → 2.3.0

package/Source/Scene/Multiple3DTileContent.js

@@ -1,4 +1,5 @@
 import defined from "../Core/defined.js";
+import deprecationWarning from "../Core/deprecationWarning.js";
 import destroyObject from "../Core/destroyObject.js";
 import DeveloperError from "../Core/DeveloperError.js";
 import Request from "../Core/Request.js";
@@ -54,6 +55,12 @@ function Multiple3DTileContent(tileset, tile, tilesetResource, contentsJson) {
   const contentCount = this._innerContentHeaders.length;
   this._arrayFetchPromises = new Array(contentCount);
   this._requests = new Array(contentCount);
+  this._ready = false;
+
+  this._resolveContent = undefined;
+  this._readyPromise = new Promise((resolve) => {
+    this._resolveContent = resolve;
+  });
 
   this._innerContentResources = new Array(contentCount);
   this._serverKeys = new Array(contentCount);
@@ -70,9 +77,6 @@ function Multiple3DTileContent(tileset, tile, tilesetResource, contentsJson) {
     this._innerContentResources[i] = contentResource;
     this._serverKeys[i] = serverKey;
   }
-
-  // undefined until the first time requests are scheduled
-  this._contentsFetchedPromise = undefined;
 }
 
 Object.defineProperties(Multiple3DTileContent.prototype, {
@@ -214,34 +218,41 @@ Object.defineProperties(Multiple3DTileContent.prototype, {
   },
 
   /**
-   * Part of the {@link Cesium3DTileContent} interface. This behaves
-   * differently for <code>Multiple3DTileContent</code>: it returns
-   * undefined if the inner contents have not yet been created. This
-   * is handled specially in {@link Cesium3DTile}.
+   * Returns true when the tile's content is ready to render; otherwise false
    *
    * @memberof Multiple3DTileContent.prototype
    *
-   * @type {Promise<Cesium3DTileContent>|undefined}
+   * @type {boolean}
    * @readonly
-   *
    * @private
    */
-  readyPromise: {
+  ready: {
     get: function () {
-      // The contents haven't been created yet, short-circuit. The tile
-      // will handle this as a special case
       if (!this._contentsCreated) {
-        return undefined;
+        return false;
       }
 
-      const readyPromises = this._contents.map(function (content) {
-        return content.readyPromise;
-      });
+      return this._ready;
+    },
+  },
 
-      const that = this;
-      return Promise.all(readyPromises).then(function () {
-        return that;
-      });
+  /**
+   * Gets the promise that will be resolved when the tile's content is ready to render.
+   *
+   * @memberof Multiple3DTileContent.prototype
+   *
+   * @type {Promise<Multiple3DTileContent>}
+   * @readonly
+   * @deprecated
+   * @private
+   */
+  readyPromise: {
+    get: function () {
+      deprecationWarning(
+        "Multiple3DTileContent.readyPromise",
+        "Multiple3DTileContent.readyPromise was deprecated in CesiumJS 1.104. It will be removed in 1.107. Wait for Multiple3DTileContent.ready to return true instead."
+      );
+      return this._readyPromise;
     },
   },
 
@@ -338,21 +349,6 @@ Object.defineProperties(Multiple3DTileContent.prototype, {
       });
     },
   },
-
-  /**
-   * A promise that resolves when all of the inner contents have been fetched.
-   * This promise is undefined until the first frame where all array buffer
-   * requests have been scheduled.
-   * @memberof Multiple3DTileContent.prototype
-   *
-   * @type {Promise}
-   * @private
-   */
-  contentsFetchedPromise: {
-    get: function () {
-      return this._contentsFetchedPromise;
-    },
-  },
 });
 
 function updatePendingRequests(multipleContents, deltaRequestCount) {
@@ -386,7 +382,7 @@ function cancelPendingRequests(multipleContents, originalContentState) {
  * requests are successfully scheduled.
  * </p>
  *
- * @return {number} The number of attempted requests that were unable to be scheduled.
+ * @return {Promise<void>|undefined} A promise that resolves when the request completes, or undefined if there is no request needed, or the request cannot be scheduled.
  * @private
  */
 Multiple3DTileContent.prototype.requestInnerContents = function () {
@@ -395,26 +391,26 @@ Multiple3DTileContent.prototype.requestInnerContents = function () {
   // if we can schedule all the requests at once. If not, no requests are
   // scheduled
   if (!canScheduleAllRequests(this._serverKeys)) {
-    return this._serverKeys.length;
+    this.tileset.statistics.numberOfAttemptedRequests += this._serverKeys.length;
+    return;
   }
 
   const contentHeaders = this._innerContentHeaders;
   updatePendingRequests(this, contentHeaders.length);
 
+  const originalCancelCount = this._cancelCount;
   for (let i = 0; i < contentHeaders.length; i++) {
     // The cancel count is needed to avoid a race condition where a content
     // is canceled multiple times.
     this._arrayFetchPromises[i] = requestInnerContent(
       this,
       i,
-      this._cancelCount,
+      originalCancelCount,
       this._tile._contentState
     );
   }
 
-  this._contentsFetchedPromise = createInnerContents(this);
-
-  return 0;
+  return createInnerContents(this);
 };
 
 /**
@@ -476,28 +472,39 @@ function requestInnerContent(
 
   const promise = contentResource.fetchArrayBuffer();
   if (!defined(promise)) {
-    return Promise.resolve(undefined);
+    return;
   }
 
   return promise
     .then(function (arrayBuffer) {
-      // Short circuit if another inner content was canceled.
+      // Pending requests have already been canceled.
       if (originalCancelCount < multipleContents._cancelCount) {
-        return undefined;
+        return;
+      }
+
+      if (
+        contentResource.request.cancelled ||
+        contentResource.request.state === RequestState.CANCELLED
+      ) {
+        cancelPendingRequests(multipleContents, originalContentState);
+        return;
       }
 
       updatePendingRequests(multipleContents, -1);
       return arrayBuffer;
     })
     .catch(function (error) {
-      // Short circuit if another inner content was canceled.
+      // Pending requests have already been canceled.
       if (originalCancelCount < multipleContents._cancelCount) {
-        return undefined;
+        return;
       }
 
-      if (contentResource.request.state === RequestState.CANCELLED) {
+      if (
+        contentResource.request.cancelled ||
+        contentResource.request.state === RequestState.CANCELLED
+      ) {
         cancelPendingRequests(multipleContents, originalContentState);
-        return undefined;
+        return;
       }
 
       updatePendingRequests(multipleContents, -1);
@@ -505,85 +512,90 @@ function requestInnerContent(
     });
 }
 
-function createInnerContents(multipleContents) {
+async function createInnerContents(multipleContents) {
   const originalCancelCount = multipleContents._cancelCount;
-  return Promise.all(multipleContents._arrayFetchPromises).then(function (
-    arrayBuffers
-  ) {
-    // Short circuit if inner contents were canceled
-    if (originalCancelCount < multipleContents._cancelCount) {
-      return undefined;
-    }
-
-    const contents = arrayBuffers.map(function (arrayBuffer, i) {
-      if (!defined(arrayBuffer)) {
-        // Content was not fetched. The error was handled in
-        // the fetch promise. Return undefined to indicate partial failure.
-        return undefined;
-      }
+  const arrayBuffers = await Promise.all(multipleContents._arrayFetchPromises);
+  // Request have been cancelled
+  if (originalCancelCount < multipleContents._cancelCount) {
+    return;
+  }
 
-      return createInnerContent(multipleContents, arrayBuffer, i);
-    });
+  const promises = arrayBuffers.map((arrayBuffer, i) =>
+    createInnerContent(multipleContents, arrayBuffer, i)
+  );
 
-    // Even if we had a partial success, mark that we finished creating
-    // contents
-    multipleContents._contentsCreated = true;
-    multipleContents._contents = contents.filter(defined);
-  });
+  // Even if we had a partial success (in which case the inner promise will be handled, but the content will not be returned), mark that we finished creating
+  // contents
+  const contents = await Promise.all(promises);
+  multipleContents._contentsCreated = true;
+  multipleContents._contents = contents.filter(defined);
+  return contents;
 }
 
-function createInnerContent(multipleContents, arrayBuffer, index) {
-  const preprocessed = preprocess3DTileContent(arrayBuffer);
-
-  if (preprocessed.contentType === Cesium3DTileContentType.EXTERNAL_TILESET) {
-    const error = new RuntimeError(
-      "External tilesets are disallowed inside multiple contents"
-    );
-
-    return handleInnerContentFailed(multipleContents, index, error);
+async function createInnerContent(multipleContents, arrayBuffer, index) {
+  if (!defined(arrayBuffer)) {
+    // Content was not fetched. The error was handled in
+    // the fetch promise. Return undefined to indicate partial failure.
+    return;
   }
 
-  multipleContents._disableSkipLevelOfDetail =
-    multipleContents._disableSkipLevelOfDetail ||
-    preprocessed.contentType === Cesium3DTileContentType.GEOMETRY ||
-    preprocessed.contentType === Cesium3DTileContentType.VECTOR;
+  try {
+    const preprocessed = preprocess3DTileContent(arrayBuffer);
 
-  const tileset = multipleContents._tileset;
-  const resource = multipleContents._innerContentResources[index];
-  const tile = multipleContents._tile;
-
-  let content;
-  const contentFactory = Cesium3DTileContentFactory[preprocessed.contentType];
-  if (defined(preprocessed.binaryPayload)) {
-    content = contentFactory(
-      tileset,
-      tile,
-      resource,
-      preprocessed.binaryPayload.buffer,
-      0
-    );
-  } else {
-    // JSON formats
-    content = contentFactory(tileset, tile, resource, preprocessed.jsonPayload);
-  }
+    if (preprocessed.contentType === Cesium3DTileContentType.EXTERNAL_TILESET) {
+      throw new RuntimeError(
+        "External tilesets are disallowed inside multiple contents"
+      );
+    }
 
-  const contentHeader = multipleContents._innerContentHeaders[index];
+    multipleContents._disableSkipLevelOfDetail =
+      multipleContents._disableSkipLevelOfDetail ||
+      preprocessed.contentType === Cesium3DTileContentType.GEOMETRY ||
+      preprocessed.contentType === Cesium3DTileContentType.VECTOR;
+
+    const tileset = multipleContents._tileset;
+    const resource = multipleContents._innerContentResources[index];
+    const tile = multipleContents._tile;
+
+    let content;
+    const contentFactory = Cesium3DTileContentFactory[preprocessed.contentType];
+    if (defined(preprocessed.binaryPayload)) {
+      content = await Promise.resolve(
+        contentFactory(
+          tileset,
+          tile,
+          resource,
+          preprocessed.binaryPayload.buffer,
+          0
+        )
+      );
+    } else {
+      // JSON formats
+      content = await Promise.resolve(
+        contentFactory(tileset, tile, resource, preprocessed.jsonPayload)
+      );
+    }
 
-  if (tile.hasImplicitContentMetadata) {
-    const subtree = tile.implicitSubtree;
-    const coordinates = tile.implicitCoordinates;
-    content.metadata = subtree.getContentMetadataView(coordinates, index);
-  } else if (!tile.hasImplicitContent) {
-    content.metadata = findContentMetadata(tileset, contentHeader);
-  }
+    const contentHeader = multipleContents._innerContentHeaders[index];
 
-  const groupMetadata = findGroupMetadata(tileset, contentHeader);
-  if (defined(groupMetadata)) {
-    content.group = new Cesium3DContentGroup({
-      metadata: groupMetadata,
-    });
+    if (tile.hasImplicitContentMetadata) {
+      const subtree = tile.implicitSubtree;
+      const coordinates = tile.implicitCoordinates;
+      content.metadata = subtree.getContentMetadataView(coordinates, index);
+    } else if (!tile.hasImplicitContent) {
+      content.metadata = findContentMetadata(tileset, contentHeader);
+    }
+
+    const groupMetadata = findGroupMetadata(tileset, contentHeader);
+    if (defined(groupMetadata)) {
+      content.group = new Cesium3DContentGroup({
+        metadata: groupMetadata,
+      });
+    }
+    return content;
+  } catch (error) {
+    handleInnerContentFailed(multipleContents, index, error);
   }
-  return content;
 }
 
 function handleInnerContentFailed(multipleContents, index, error) {
@@ -653,8 +665,15 @@ Multiple3DTileContent.prototype.applyStyle = function (style) {
 Multiple3DTileContent.prototype.update = function (tileset, frameState) {
   const contents = this._contents;
   const length = contents.length;
+  let ready = true;
   for (let i = 0; i < length; ++i) {
     contents[i].update(tileset, frameState);
+    ready = ready && contents[i].ready;
+  }
+
+  if (!this._ready && ready) {
+    this._ready = true;
+    this._resolveContent(this);
   }
 };
 

package/Source/Scene/Picking.js

@@ -92,8 +92,9 @@ function getPickOrthographicCullingVolume(
 ) {
   const camera = scene.camera;
   let frustum = camera.frustum;
-  if (defined(frustum._offCenterFrustum)) {
-    frustum = frustum._offCenterFrustum;
+  const offCenterFrustum = frustum.offCenterFrustum;
+  if (defined(offCenterFrustum)) {
+    frustum = offCenterFrustum;
   }
 
   let x = (2.0 * (drawingBufferPosition.x - viewport.x)) / viewport.width - 1.0;

package/Source/Scene/PointCloud.js

@@ -156,9 +156,8 @@ function PointCloud(options) {
   );
   this._splittingEnabled = false;
 
-  this._resolveReadyPromise = undefined;
-  this._rejectReadyPromise = undefined;
-  this._readyPromise = initialize(this, options);
+  this._error = undefined;
+  initialize(this, options);
 }
 
 Object.defineProperties(PointCloud.prototype, {
@@ -180,12 +179,6 @@ Object.defineProperties(PointCloud.prototype, {
     },
   },
 
-  readyPromise: {
-    get: function () {
-      return this._readyPromise;
-    },
-  },
-
   color: {
     get: function () {
       return Color.clone(this._highlightColor);
@@ -283,14 +276,6 @@ function initialize(pointCloud, options) {
   }
 
   pointCloud._pointsLength = parsedContent.pointsLength;
-
-  return new Promise(function (resolve, reject) {
-    pointCloud._resolveReadyPromise = function () {
-      pointCloud._ready = true;
-      resolve(pointCloud);
-    };
-    pointCloud._rejectReadyPromise = reject;
-  });
 }
 
 const scratchMin = new Cartesian3();
@@ -1280,7 +1265,7 @@ function decodeDraco(pointCloud, context) {
         })
         .catch(function (error) {
           pointCloud._decodingState = DecodingState.FAILED;
-          pointCloud._rejectReadyPromise(error);
+          pointCloud._error = error;
         });
     }
   }
@@ -1292,6 +1277,13 @@ const scratchScale = new Cartesian3();
 
 PointCloud.prototype.update = function (frameState) {
   const context = frameState.context;
+
+  if (defined(this._error)) {
+    const error = this._error;
+    this._error = undefined;
+    throw error;
+  }
+
   const decoding = decodeDraco(this, context);
   if (decoding) {
     return;
@@ -1309,7 +1301,7 @@ PointCloud.prototype.update = function (frameState) {
     createResources(this, frameState);
     modelMatrixDirty = true;
     shadersDirty = true;
-    this._resolveReadyPromise();
+    this._ready = true;
     this._parsedContent = undefined; // Unload
   }
 

package/Source/Scene/Primitive.js

@@ -9,6 +9,7 @@ import combine from "../Core/combine.js";
 import ComponentDatatype from "../Core/ComponentDatatype.js";
 import defaultValue from "../Core/defaultValue.js";
 import defined from "../Core/defined.js";
+import deprecationWarning from "../Core/deprecationWarning.js";
 import destroyObject from "../Core/destroyObject.js";
 import DeveloperError from "../Core/DeveloperError.js";
 import EncodedCartesian3 from "../Core/EncodedCartesian3.js";
@@ -350,6 +351,7 @@ function Primitive(options) {
   this._ready = false;
 
   const primitive = this;
+  // This is here for backwards compatibility. This promise wrapper can be removed once readyPromise is removed.
   this._readyPromise = new Promise((resolve, reject) => {
     primitive._completeLoad = (frameState, state, error) => {
       this._error = error;
@@ -486,6 +488,19 @@ Object.defineProperties(Primitive.prototype, {
    *
    * @type {boolean}
    * @readonly
+   *
+   * @example
+   * // Wait for a primitive to become ready before accessing attributes
+   * const removeListener = scene.postRender.addEventListener(() => {
+   *   if (!frustumPrimitive.ready) {
+   *     return;
+   *   }
+   *
+   *   const attributes = primitive.getGeometryInstanceAttributes('an id');
+   *   attributes.color = Cesium.ColorGeometryInstanceAttribute.toValue(Cesium.Color.AQUA);
+   *
+   *   removeListener();
+   * });
    */
   ready: {
     get: function () {
@@ -498,9 +513,14 @@ Object.defineProperties(Primitive.prototype, {
    * @memberof Primitive.prototype
    * @type {Promise<Primitive>}
    * @readonly
+   * @deprecated
    */
   readyPromise: {
     get: function () {
+      deprecationWarning(
+        "Primitive.readyPromise",
+        "Primitive.readyPromise was deprecated in CesiumJS 1.104. It will be removed in 1.107. Wait for Primitive.ready to return true instead."
+      );
       return this._readyPromise;
     },
   },

package/Source/Scene/QuadtreePrimitive.js

@@ -520,6 +520,7 @@ function selectTilesForRendering(primitive, frameState) {
   let i;
   const tileProvider = primitive._tileProvider;
   if (!defined(primitive._levelZeroTiles)) {
+    // ready is deprecated. This is here for backwards compatibility
     if (tileProvider.ready) {
       const tilingScheme = tileProvider.tilingScheme;
       primitive._levelZeroTiles = QuadtreeTile.createLevelZeroTiles(
@@ -1274,8 +1275,9 @@ function screenSpaceError(primitive, frameState, tile) {
 function screenSpaceError2D(primitive, frameState, tile) {
   const camera = frameState.camera;
   let frustum = camera.frustum;
-  if (defined(frustum._offCenterFrustum)) {
-    frustum = frustum._offCenterFrustum;
+  const offCenterFrustum = frustum.offCenterFrustum;
+  if (defined(offCenterFrustum)) {
+    frustum = offCenterFrustum;
   }
 
   const context = frameState.context;
@@ -1387,6 +1389,7 @@ const scratchPosition = new Cartesian3();
 const scratchArray = [];
 
 function updateHeights(primitive, frameState) {
+  // ready is deprecated. This is here for backwards compatibility.
   if (!primitive.tileProvider.ready) {
     return;
   }

package/Source/Scene/QuadtreeTileProvider.js

@@ -46,14 +46,14 @@ Object.defineProperties(QuadtreeTileProvider.prototype, {
    * Gets a value indicating whether or not the provider is ready for use.
    * @memberof QuadtreeTileProvider.prototype
    * @type {boolean}
+   * @deprecated
    */
   ready: {
     get: DeveloperError.throwInstantiationError,
   },
 
   /**
-   * Gets the tiling scheme used by the provider.  This property should
-   * not be accessed before {@link QuadtreeTileProvider#ready} returns true.
+   * Gets the tiling scheme used by the provider.
    * @memberof QuadtreeTileProvider.prototype
    * @type {TilingScheme}
    */
@@ -112,8 +112,7 @@ QuadtreeTileProvider.prototype.endUpdate =
   DeveloperError.throwInstantiationError;
 
 /**
- * Gets the maximum geometric error allowed in a tile at a given level, in meters.  This function should not be
- * called before {@link QuadtreeTileProvider#ready} returns true.
+ * Gets the maximum geometric error allowed in a tile at a given level, in meters.
  *
  * @see QuadtreeTileProvider#computeDefaultLevelZeroMaximumGeometricError
  *
@@ -128,8 +127,7 @@ QuadtreeTileProvider.prototype.getLevelMaximumGeometricError =
 
 /**
  * Loads, or continues loading, a given tile.  This function will continue to be called
- * until {@link QuadtreeTile#state} is no longer {@link QuadtreeTileLoadState#LOADING}.  This function should
- * not be called before {@link QuadtreeTileProvider#ready} returns true.
+ * until {@link QuadtreeTile#state} is no longer {@link QuadtreeTileLoadState#LOADING}.
  *
  * @memberof QuadtreeTileProvider
  * @function
@@ -137,8 +135,6 @@ QuadtreeTileProvider.prototype.getLevelMaximumGeometricError =
  * @param {Context} context The rendering context.
  * @param {FrameState} frameState The frame state.
  * @param {QuadtreeTile} tile The tile to load.
- *
- * @exception {DeveloperError} <code>loadTile</code> must not be called before the tile provider is ready.
  */
 QuadtreeTileProvider.prototype.loadTile =
   DeveloperError.throwInstantiationError;