@cesium/engine 2.1.0 → 2.3.0

package/Source/Scene/GlobeSurfaceTileProvider.js

@@ -127,19 +127,19 @@ function GlobeSurfaceTileProvider(options) {
 
   this._errorEvent = new Event();
 
-  this._imageryLayers.layerAdded.addEventListener(
+  this._removeLayerAddedListener = this._imageryLayers.layerAdded.addEventListener(
     GlobeSurfaceTileProvider.prototype._onLayerAdded,
     this
   );
-  this._imageryLayers.layerRemoved.addEventListener(
+  this._removeLayerRemovedListener = this._imageryLayers.layerRemoved.addEventListener(
     GlobeSurfaceTileProvider.prototype._onLayerRemoved,
     this
   );
-  this._imageryLayers.layerMoved.addEventListener(
+  this._removeLayerMovedListener = this._imageryLayers.layerMoved.addEventListener(
     GlobeSurfaceTileProvider.prototype._onLayerMoved,
     this
   );
-  this._imageryLayers.layerShownOrHidden.addEventListener(
+  this._removeLayerShownListener = this._imageryLayers.layerShownOrHidden.addEventListener(
     GlobeSurfaceTileProvider.prototype._onLayerShownOrHidden,
     this
   );
@@ -233,20 +233,24 @@ Object.defineProperties(GlobeSurfaceTileProvider.prototype, {
    * Gets a value indicating whether or not the provider is ready for use.
    * @memberof GlobeSurfaceTileProvider.prototype
    * @type {boolean}
+   * @deprecated
    */
   ready: {
     get: function () {
       return (
-        this._terrainProvider.ready &&
+        defined(this._terrainProvider) &&
+        // TerrainProvider.ready is deprecated; This is here for backwards compatibility
+        this._terrainProvider._ready &&
         (this._imageryLayers.length === 0 ||
-          this._imageryLayers.get(0).imageryProvider.ready)
+          // ImageryProvider.ready is deprecated; This is here for backwards compatibility
+          (this._imageryLayers.get(0).ready &&
+            this._imageryLayers.get(0).imageryProvider._ready))
       );
     },
   },
 
   /**
-   * Gets the tiling scheme used by the provider.  This property should
-   * not be accessed before {@link GlobeSurfaceTileProvider#ready} returns true.
+   * Gets the tiling scheme used by the provider.
    * @memberof GlobeSurfaceTileProvider.prototype
    * @type {TilingScheme}
    */
@@ -294,12 +298,6 @@ Object.defineProperties(GlobeSurfaceTileProvider.prototype, {
         return;
       }
 
-      //>>includeStart('debug', pragmas.debug);
-      if (!defined(terrainProvider)) {
-        throw new DeveloperError("terrainProvider is required.");
-      }
-      //>>includeEnd('debug');
-
       this._terrainProvider = terrainProvider;
 
       if (defined(this._quadtree)) {
@@ -349,17 +347,24 @@ GlobeSurfaceTileProvider.prototype.update = function (frameState) {
 function updateCredits(surface, frameState) {
   const creditDisplay = frameState.creditDisplay;
   if (
-    surface._terrainProvider.ready &&
+    defined(surface._terrainProvider) &&
+    // ready is deprecated; This is here for backwards compatibility
+    surface._terrainProvider._ready &&
     defined(surface._terrainProvider.credit)
   ) {
-    creditDisplay.addCredit(surface._terrainProvider.credit);
+    creditDisplay.addCreditToNextFrame(surface._terrainProvider.credit);
   }
 
   const imageryLayers = surface._imageryLayers;
   for (let i = 0, len = imageryLayers.length; i < len; ++i) {
-    const imageryProvider = imageryLayers.get(i).imageryProvider;
-    if (imageryProvider.ready && defined(imageryProvider.credit)) {
-      creditDisplay.addCredit(imageryProvider.credit);
+    const layer = imageryLayers.get(i);
+    // ImageryProvider.ready is deprecated; This is here for backwards compatibility
+    if (
+      layer.ready &&
+      layer.imageryProvider._ready &&
+      defined(layer.imageryProvider.credit)
+    ) {
+      creditDisplay.addCreditToNextFrame(layer.imageryProvider.credit);
     }
   }
 }
@@ -562,8 +567,7 @@ GlobeSurfaceTileProvider.prototype.cancelReprojections = function () {
 };
 
 /**
- * Gets the maximum geometric error allowed in a tile at a given level, in meters.  This function should not be
- * called before {@link GlobeSurfaceTileProvider#ready} returns true.
+ * Gets the maximum geometric error allowed in a tile at a given level, in meters.
  *
  * @param {number} level The tile level for which to get the maximum geometric error.
  * @returns {number} The maximum geometric error in meters.
@@ -571,18 +575,19 @@ GlobeSurfaceTileProvider.prototype.cancelReprojections = function () {
 GlobeSurfaceTileProvider.prototype.getLevelMaximumGeometricError = function (
   level
 ) {
+  if (!defined(this._terrainProvider)) {
+    return 0;
+  }
+
   return this._terrainProvider.getLevelMaximumGeometricError(level);
 };
 
 /**
  * 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 GlobeSurfaceTileProvider#ready} returns true.
+ * until {@link QuadtreeTile#state} is no longer {@link QuadtreeTileLoadState#LOADING}.
  *
  * @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.
  */
 GlobeSurfaceTileProvider.prototype.loadTile = function (frameState, tile) {
   // We don't want to load imagery until we're certain that the terrain tiles are actually visible.
@@ -1384,6 +1389,14 @@ GlobeSurfaceTileProvider.prototype.isDestroyed = function () {
 GlobeSurfaceTileProvider.prototype.destroy = function () {
   this._tileProvider = this._tileProvider && this._tileProvider.destroy();
   this._clippingPlanes = this._clippingPlanes && this._clippingPlanes.destroy();
+  this._removeLayerAddedListener =
+    this._removeLayerAddedListener && this._removeLayerAddedListener();
+  this._removeLayerRemovedListener =
+    this._removeLayerRemovedListener && this._removeLayerRemovedListener();
+  this._removeLayerMovedListener =
+    this._removeLayerMovedListener && this._removeLayerMovedListener();
+  this._removeLayerShownListener =
+    this._removeLayerShownListener && this._removeLayerShownListener();
 
   return destroyObject(this);
 };
@@ -1436,13 +1449,16 @@ function getTileReadyCallback(tileImageriesToFree, layer, terrainProvider) {
 }
 
 GlobeSurfaceTileProvider.prototype._onLayerAdded = function (layer, index) {
+  if (this.isDestroyed()) {
+    return;
+  }
+
   if (layer.show) {
     const terrainProvider = this._terrainProvider;
 
     const that = this;
-    const imageryProvider = layer.imageryProvider;
     const tileImageryUpdatedEvent = this._imageryLayersUpdatedEvent;
-    imageryProvider._reload = function () {
+    const reloadFunction = function () {
       // Clear the layer's cache
       layer._imageryCache = {};
 
@@ -1504,6 +1520,11 @@ GlobeSurfaceTileProvider.prototype._onLayerAdded = function (layer, index) {
       });
     };
 
+    if (layer.ready) {
+      const imageryProvider = layer.imageryProvider;
+      imageryProvider._reload = reloadFunction;
+    }
+
     // create TileImageries for this layer for all previously loaded tiles
     this._quadtree.forEachLoadedTile(function (tile) {
       if (layer._createTileImagerySkeletons(tile, terrainProvider)) {
@@ -2077,7 +2098,7 @@ function addDrawCommandsForTile(tileProvider, tile, frameState) {
       tileCreditIndex < tileCreditLength;
       ++tileCreditIndex
     ) {
-      creditDisplay.addCredit(tileCredits[tileCreditIndex]);
+      creditDisplay.addCreditToNextFrame(tileCredits[tileCreditIndex]);
     }
   }
 
@@ -2124,7 +2145,9 @@ function addDrawCommandsForTile(tileProvider, tile, frameState) {
   const oceanNormalMap = tileProvider.oceanNormalMap;
   const showOceanWaves = showReflectiveOcean && defined(oceanNormalMap);
   const hasVertexNormals =
-    tileProvider.terrainProvider.ready &&
+    defined(tileProvider.terrainProvider) &&
+    // ready is deprecated; This is here for backwards compatibility
+    tileProvider.terrainProvider._ready &&
     tileProvider.terrainProvider.hasVertexNormals;
   const enableFog =
     frameState.fog.enabled && frameState.fog.renderable && !cameraUnderground;
@@ -2696,7 +2719,7 @@ function addDrawCommandsForTile(tileProvider, tile, frameState) {
           creditIndex < creditLength;
           ++creditIndex
         ) {
-          creditDisplay.addCredit(credits[creditIndex]);
+          creditDisplay.addCreditToNextFrame(credits[creditIndex]);
         }
       }
 

package/Source/Scene/GltfBufferViewLoader.js

@@ -87,7 +87,6 @@ function GltfBufferViewLoader(options) {
   this._typedArray = undefined;
   this._state = ResourceLoaderState.UNLOADED;
   this._promise = undefined;
-  this._process = function (loader, frameState) {};
 }
 
 if (defined(Object.create)) {
@@ -96,20 +95,6 @@ if (defined(Object.create)) {
 }
 
 Object.defineProperties(GltfBufferViewLoader.prototype, {
-  /**
-   * A promise that resolves to the resource when the resource is ready, or undefined if the resource hasn't started loading.
-   *
-   * @memberof GltfBufferViewLoader.prototype
-   *
-   * @type {Promise<GltfBufferViewLoader>|undefined}
-   * @readonly
-   * @private
-   */
-  promise: {
-    get: function () {
-      return this._promise;
-    },
-  },
   /**
    * The cache key of the resource.
    *
@@ -140,31 +125,28 @@ Object.defineProperties(GltfBufferViewLoader.prototype, {
   },
 });
 
-/**
- * Loads the resource.
- * @returns {Promise<GltfBufferViewLoader>} A promise which resolves to the loader when the resource loading is completed.
- * @private
- */
-GltfBufferViewLoader.prototype.load = function () {
-  const bufferLoader = getBufferLoader(this);
-  this._bufferLoader = bufferLoader;
-  this._state = ResourceLoaderState.LOADING;
+async function loadResources(loader) {
+  try {
+    const bufferLoader = getBufferLoader(loader);
+    loader._bufferLoader = bufferLoader;
+    await bufferLoader.load();
 
-  const that = this;
-  const bufferViewPromise = new Promise(function (resolve) {
-    that._process = function (loader, frameState) {
-      if (!loader._hasMeshopt) {
-        return;
-      }
+    if (loader.isDestroyed()) {
+      return;
+    }
 
-      if (!defined(loader._typedArray)) {
-        return;
-      }
+    const bufferTypedArray = bufferLoader.typedArray;
+    const bufferViewTypedArray = new Uint8Array(
+      bufferTypedArray.buffer,
+      bufferTypedArray.byteOffset + loader._byteOffset,
+      loader._byteLength
+    );
 
-      if (loader._state !== ResourceLoaderState.PROCESSING) {
-        return;
-      }
+    // Unload the buffer
+    loader.unload();
 
+    loader._typedArray = bufferViewTypedArray;
+    if (loader._hasMeshopt) {
       const count = loader._meshoptCount;
       const byteStride = loader._meshoptByteStride;
       const result = new Uint8Array(count * byteStride);
@@ -176,47 +158,35 @@ GltfBufferViewLoader.prototype.load = function () {
         loader._meshoptMode,
         loader._meshoptFilter
       );
-
       loader._typedArray = result;
-      loader._state = ResourceLoaderState.READY;
-      resolve(loader);
-    };
-  });
-
-  this._promise = bufferLoader.promise
-    .then(function () {
-      if (that.isDestroyed()) {
-        return;
-      }
-      const bufferTypedArray = bufferLoader.typedArray;
-      const bufferViewTypedArray = new Uint8Array(
-        bufferTypedArray.buffer,
-        bufferTypedArray.byteOffset + that._byteOffset,
-        that._byteLength
-      );
-
-      // Unload the buffer
-      that.unload();
-
-      that._typedArray = bufferViewTypedArray;
-      if (that._hasMeshopt) {
-        that._state = ResourceLoaderState.PROCESSING;
-        return bufferViewPromise;
-      }
+    }
+
+    loader._state = ResourceLoaderState.READY;
+    return loader;
+  } catch (error) {
+    if (loader.isDestroyed()) {
+      return;
+    }
+
+    loader.unload();
+    loader._state = ResourceLoaderState.FAILED;
+    const errorMessage = "Failed to load buffer view";
+    throw loader.getError(errorMessage, error);
+  }
+}
 
-      that._state = ResourceLoaderState.READY;
-      return that;
-    })
-    .catch(function (error) {
-      if (that.isDestroyed()) {
-        return;
-      }
-      that.unload();
-      that._state = ResourceLoaderState.FAILED;
-      const errorMessage = "Failed to load buffer view";
-      return Promise.reject(that.getError(errorMessage, error));
-    });
+/**
+ * Loads the resource.
+ * @returns {Promise<GltfBufferViewLoader>} A promise which resolves to the loader when the resource loading is completed.
+ * @private
+ */
+GltfBufferViewLoader.prototype.load = async function () {
+  if (defined(this._promise)) {
+    return this._promise;
+  }
 
+  this._state = ResourceLoaderState.LOADING;
+  this._promise = loadResources(this);
   return this._promise;
 };
 
@@ -228,36 +198,22 @@ function getBufferLoader(bufferViewLoader) {
     const resource = baseResource.getDerivedResource({
       url: buffer.uri,
     });
-    return resourceCache.loadExternalBuffer({
+    return resourceCache.getExternalBufferLoader({
       resource: resource,
     });
   }
-  return resourceCache.loadEmbeddedBuffer({
+  return resourceCache.getEmbeddedBufferLoader({
     parentResource: bufferViewLoader._gltfResource,
     bufferId: bufferViewLoader._bufferId,
   });
 }
 
-/**
- * Processes the resources. For a BufferView that does not have the EXT_meshopt_compression extension, there
- * is no processing that needs to happen, so this function returns immediately.
- *
- * @param {FrameState} frameState The frame state.
- */
-GltfBufferViewLoader.prototype.process = function (frameState) {
-  //>>includeStart('debug', pragmas.debug);
-  Check.typeOf.object("frameState", frameState);
-  //>>includeEnd('debug');
-
-  return this._process(this, frameState);
-};
-
 /**
  * Unloads the resource.
  * @private
  */
 GltfBufferViewLoader.prototype.unload = function () {
-  if (defined(this._bufferLoader)) {
+  if (defined(this._bufferLoader) && !this._bufferLoader.isDestroyed()) {
     this._resourceCache.unload(this._bufferLoader);
   }
 

package/Source/Scene/GltfDracoLoader.js

@@ -54,7 +54,7 @@ function GltfDracoLoader(options) {
   this._decodedData = undefined;
   this._state = ResourceLoaderState.UNLOADED;
   this._promise = undefined;
-  this._process = function (loader, frameState) {};
+  this._dracoError = undefined;
 }
 
 if (defined(Object.create)) {
@@ -63,20 +63,6 @@ if (defined(Object.create)) {
 }
 
 Object.defineProperties(GltfDracoLoader.prototype, {
-  /**
-   * A promise that resolves to the resource when the resource is ready.
-   *
-   * @memberof GltfDracoLoader.prototype
-   *
-   * @type {Promise<GltfDracoLoader>}
-   * @readonly
-   * @private
-   */
-  promise: {
-    get: function () {
-      return this._promise;
-    },
-  },
   /**
    * The cache key of the resource.
    *
@@ -107,107 +93,46 @@ Object.defineProperties(GltfDracoLoader.prototype, {
   },
 });
 
+async function loadResources(loader) {
+  const resourceCache = loader._resourceCache;
+  try {
+    const bufferViewLoader = resourceCache.getBufferViewLoader({
+      gltf: loader._gltf,
+      bufferViewId: loader._draco.bufferView,
+      gltfResource: loader._gltfResource,
+      baseResource: loader._baseResource,
+    });
+    loader._bufferViewLoader = bufferViewLoader;
+    await bufferViewLoader.load();
+
+    if (loader.isDestroyed()) {
+      return;
+    }
+
+    loader._bufferViewTypedArray = bufferViewLoader.typedArray;
+    loader._state = ResourceLoaderState.PROCESSING;
+    return loader;
+  } catch (error) {
+    if (loader.isDestroyed()) {
+      return;
+    }
+
+    handleError(loader, error);
+  }
+}
+
 /**
  * Loads the resource.
  * @returns {Promise<GltfDracoLoader>} A promise which resolves to the loader when the resource loading is completed.
  * @private
  */
-GltfDracoLoader.prototype.load = function () {
-  const resourceCache = this._resourceCache;
-  const bufferViewLoader = resourceCache.loadBufferView({
-    gltf: this._gltf,
-    bufferViewId: this._draco.bufferView,
-    gltfResource: this._gltfResource,
-    baseResource: this._baseResource,
-  });
-
-  this._bufferViewLoader = bufferViewLoader;
-  this._state = ResourceLoaderState.LOADING;
-  const that = this;
-  const dracoPromise = new Promise(function (resolve, reject) {
-    that._process = function (loader, frameState) {
-      if (!defined(loader._bufferViewTypedArray)) {
-        // Not ready to decode the Draco buffer
-        return;
-      }
-
-      if (defined(loader._decodePromise)) {
-        // Currently decoding
-        return;
-      }
-
-      const draco = loader._draco;
-      const gltf = loader._gltf;
-      const bufferViews = gltf.bufferViews;
-      const bufferViewId = draco.bufferView;
-      const bufferView = bufferViews[bufferViewId];
-      const compressedAttributes = draco.attributes;
-
-      const decodeOptions = {
-        // Need to make a copy of the typed array otherwise the underlying
-        // ArrayBuffer may be accessed on both the worker and the main thread. This
-        // leads to errors such as "ArrayBuffer at index 0 is already detached".
-        // PERFORMANCE_IDEA: Look into SharedArrayBuffer to get around this.
-        array: new Uint8Array(loader._bufferViewTypedArray),
-        bufferView: bufferView,
-        compressedAttributes: compressedAttributes,
-        dequantizeInShader: true,
-      };
-
-      const decodePromise = DracoLoader.decodeBufferView(decodeOptions);
-
-      if (!defined(decodePromise)) {
-        // Cannot schedule task this frame
-        return;
-      }
-
-      loader._decodePromise = decodePromise
-        .then(function (results) {
-          if (loader.isDestroyed()) {
-            resolve();
-            return;
-          }
-
-          // Unload everything except the decoded data
-          loader.unload();
-
-          loader._decodedData = {
-            indices: results.indexArray,
-            vertexAttributes: results.attributeData,
-          };
-          loader._state = ResourceLoaderState.READY;
-          resolve(loader);
-        })
-        .catch(function (e) {
-          if (loader.isDestroyed()) {
-            resolve();
-            return;
-          }
-
-          reject(e);
-        });
-    };
-  });
-
-  this._promise = bufferViewLoader.promise
-    .then(function () {
-      if (that.isDestroyed()) {
-        return;
-      }
-      // Now wait for process() to run to finish loading
-      that._bufferViewTypedArray = bufferViewLoader.typedArray;
-      that._state = ResourceLoaderState.PROCESSING;
-
-      return dracoPromise;
-    })
-    .catch(function (error) {
-      if (that.isDestroyed()) {
-        return;
-      }
-
-      return handleError(that, error);
-    });
+GltfDracoLoader.prototype.load = async function () {
+  if (defined(this._promise)) {
+    return this._promise;
+  }
 
+  this._state = ResourceLoaderState.LOADING;
+  this._promise = loadResources(this);
   return this._promise;
 };
 
@@ -215,7 +140,33 @@ function handleError(dracoLoader, error) {
   dracoLoader.unload();
   dracoLoader._state = ResourceLoaderState.FAILED;
   const errorMessage = "Failed to load Draco";
-  return Promise.reject(dracoLoader.getError(errorMessage, error));
+  throw dracoLoader.getError(errorMessage, error);
+}
+
+async function processDecode(loader, decodePromise) {
+  try {
+    const results = await decodePromise;
+    if (loader.isDestroyed()) {
+      return;
+    }
+
+    // Unload everything except the decoded data
+    loader.unload();
+
+    loader._decodedData = {
+      indices: results.indexArray,
+      vertexAttributes: results.attributeData,
+    };
+    loader._state = ResourceLoaderState.READY;
+    return loader._baseResource;
+  } catch (error) {
+    if (loader.isDestroyed()) {
+      return;
+    }
+
+    // Capture this error so it can be thrown on the next `process` call
+    loader._dracoError = error;
+  }
 }
 
 /**
@@ -229,7 +180,54 @@ GltfDracoLoader.prototype.process = function (frameState) {
   Check.typeOf.object("frameState", frameState);
   //>>includeEnd('debug');
 
-  return this._process(this, frameState);
+  if (this._state === ResourceLoaderState.READY) {
+    return true;
+  }
+
+  if (this._state !== ResourceLoaderState.PROCESSING) {
+    return false;
+  }
+
+  if (defined(this._dracoError)) {
+    handleError(this, this._dracoError);
+  }
+
+  if (!defined(this._bufferViewTypedArray)) {
+    // Not ready to decode the Draco buffer
+    return false;
+  }
+
+  if (defined(this._decodePromise)) {
+    // Currently decoding
+    return false;
+  }
+
+  const draco = this._draco;
+  const gltf = this._gltf;
+  const bufferViews = gltf.bufferViews;
+  const bufferViewId = draco.bufferView;
+  const bufferView = bufferViews[bufferViewId];
+  const compressedAttributes = draco.attributes;
+
+  const decodeOptions = {
+    // Need to make a copy of the typed array otherwise the underlying
+    // ArrayBuffer may be accessed on both the worker and the main thread. This
+    // leads to errors such as "ArrayBuffer at index 0 is already detached".
+    // PERFORMANCE_IDEA: Look into SharedArrayBuffer to get around this.
+    array: new Uint8Array(this._bufferViewTypedArray),
+    bufferView: bufferView,
+    compressedAttributes: compressedAttributes,
+    dequantizeInShader: true,
+  };
+
+  const decodePromise = DracoLoader.decodeBufferView(decodeOptions);
+
+  if (!defined(decodePromise)) {
+    // Cannot schedule task this frame
+    return false;
+  }
+
+  this._decodePromise = processDecode(this, decodePromise);
 };
 
 /**