@cesium/engine 2.0.0 → 2.2.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
   );
@@ -232,21 +232,25 @@ Object.defineProperties(GlobeSurfaceTileProvider.prototype, {
   /**
    * Gets a value indicating whether or not the provider is ready for use.
    * @memberof GlobeSurfaceTileProvider.prototype
-   * @type {Boolean}
+   * @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,7 +347,9 @@ 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);
@@ -357,9 +357,14 @@ function updateCredits(surface, frameState) {
 
   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.addCredit(layer.imageryProvider.credit);
     }
   }
 }
@@ -562,27 +567,27 @@ 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.
+ * @param {number} level The tile level for which to get the maximum geometric error.
+ * @returns {number} The maximum geometric error in meters.
  */
 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.
@@ -993,7 +998,7 @@ const tileDirectionScratch = new Cartesian3();
  * Determines the priority for loading this tile. Lower priority values load sooner.
  * @param {QuadtreeTile} tile The tile.
  * @param {FrameState} frameState The frame state.
- * @returns {Number} The load priority value.
+ * @returns {number} The load priority value.
  */
 GlobeSurfaceTileProvider.prototype.computeTileLoadPriority = function (
   tile,
@@ -1142,7 +1147,7 @@ function computeOccludeePoint(
  * @param {QuadtreeTile} tile The tile instance.
  * @param {FrameState} frameState The state information of the current rendering frame.
  *
- * @returns {Number} The distance from the camera to the closest point on the tile, in meters.
+ * @returns {number} The distance from the camera to the closest point on the tile, in meters.
  */
 GlobeSurfaceTileProvider.prototype.computeDistanceToTile = function (
   tile,
@@ -1357,7 +1362,7 @@ function updateTileBoundingRegion(tile, tileProvider, frameState) {
  * If this object was destroyed, it should not be used; calling any function other than
  * <code>isDestroyed</code> will result in a {@link DeveloperError} exception.
  *
- * @returns {Boolean} True if this object was destroyed; otherwise, false.
+ * @returns {boolean} True if this object was destroyed; otherwise, false.
  *
  * @see GlobeSurfaceTileProvider#destroy
  */
@@ -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)) {
@@ -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;

package/Source/Scene/GlobeTranslucency.js

@@ -34,7 +34,7 @@ Object.defineProperties(GlobeTranslucency.prototype, {
    *
    * @memberof GlobeTranslucency.prototype
    *
-   * @type {Boolean}
+   * @type {boolean}
    * @default false
    *
    * @see GlobeTranslucency#frontFaceAlpha
@@ -61,7 +61,7 @@ Object.defineProperties(GlobeTranslucency.prototype, {
    *
    * @memberof GlobeTranslucency.prototype
    *
-   * @type {Number}
+   * @type {number}
    * @default 1.0
    *
    * @see GlobeTranslucency#enabled
@@ -141,7 +141,7 @@ Object.defineProperties(GlobeTranslucency.prototype, {
    *
    * @memberof GlobeTranslucency.prototype
    *
-   * @type {Number}
+   * @type {number}
    * @default 1.0
    *
    * @see GlobeTranslucency#enabled

package/Source/Scene/GltfBufferViewLoader.js

@@ -16,13 +16,13 @@ import ResourceLoaderState from "./ResourceLoaderState.js";
  * @constructor
  * @augments ResourceLoader
  *
- * @param {Object} options Object with the following properties:
+ * @param {object} options Object with the following properties:
  * @param {ResourceCache} options.resourceCache The {@link ResourceCache} (to avoid circular dependencies).
- * @param {Object} options.gltf The glTF JSON.
- * @param {Number} options.bufferViewId The buffer view ID.
+ * @param {object} options.gltf The glTF JSON.
+ * @param {number} options.bufferViewId The buffer view ID.
  * @param {Resource} options.gltfResource The {@link Resource} containing the glTF.
  * @param {Resource} options.baseResource The {@link Resource} that paths in the glTF JSON are relative to.
- * @param {String} [options.cacheKey] The cache key of the resource.
+ * @param {string} [options.cacheKey] The cache key of the resource.
  *
  * @private
  */
@@ -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,26 +95,12 @@ 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.
    *
    * @memberof GltfBufferViewLoader.prototype
    *
-   * @type {String}
+   * @type {string}
    * @readonly
    * @private
    */
@@ -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);
   }