@cesium/engine 2.1.0 → 2.2.0

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);
 };
 
 /**

package/Source/Scene/GltfImageLoader.js

@@ -68,20 +68,6 @@ if (defined(Object.create)) {
 }
 
 Object.defineProperties(GltfImageLoader.prototype, {
-  /**
-   * A promise that resolves to the resource when the resource is ready, or undefined if the resource hasn't started loading.
-   *
-   * @memberof GltfImageLoader.prototype
-   *
-   * @type {Promise<GltfImageLoader>|undefined}
-   * @readonly
-   * @private
-   */
-  promise: {
-    get: function () {
-      return this._promise;
-    },
-  },
   /**
    * The cache key of the resource.
    *
@@ -132,6 +118,10 @@ Object.defineProperties(GltfImageLoader.prototype, {
  * @private
  */
 GltfImageLoader.prototype.load = function () {
+  if (defined(this._promise)) {
+    return this._promise;
+  }
+
   if (defined(this._bufferViewId)) {
     this._promise = loadFromBufferView(this);
     return this._promise;
@@ -158,78 +148,78 @@ function getImageAndMipLevels(image) {
   };
 }
 
-function loadFromBufferView(imageLoader) {
+async function loadFromBufferView(imageLoader) {
+  imageLoader._state = ResourceLoaderState.LOADING;
   const resourceCache = imageLoader._resourceCache;
-  const bufferViewLoader = resourceCache.loadBufferView({
-    gltf: imageLoader._gltf,
-    bufferViewId: imageLoader._bufferViewId,
-    gltfResource: imageLoader._gltfResource,
-    baseResource: imageLoader._baseResource,
-  });
+  try {
+    const bufferViewLoader = resourceCache.getBufferViewLoader({
+      gltf: imageLoader._gltf,
+      bufferViewId: imageLoader._bufferViewId,
+      gltfResource: imageLoader._gltfResource,
+      baseResource: imageLoader._baseResource,
+    });
+    imageLoader._bufferViewLoader = bufferViewLoader;
+    await bufferViewLoader.load();
 
-  imageLoader._bufferViewLoader = bufferViewLoader;
-  imageLoader._state = ResourceLoaderState.LOADING;
+    if (imageLoader.isDestroyed()) {
+      return;
+    }
 
-  return bufferViewLoader.promise
-    .then(function () {
-      if (imageLoader.isDestroyed()) {
-        return;
-      }
-
-      const typedArray = bufferViewLoader.typedArray;
-      return loadImageFromBufferTypedArray(typedArray).then(function (image) {
-        if (imageLoader.isDestroyed()) {
-          return;
-        }
-
-        const imageAndMipLevels = getImageAndMipLevels(image);
-
-        // Unload everything except the image
-        imageLoader.unload();
-
-        imageLoader._image = imageAndMipLevels.image;
-        imageLoader._mipLevels = imageAndMipLevels.mipLevels;
-        imageLoader._state = ResourceLoaderState.READY;
-        return imageLoader;
-      });
-    })
-    .catch(function (error) {
-      if (imageLoader.isDestroyed()) {
-        return;
-      }
-      return handleError(imageLoader, error, "Failed to load embedded image");
-    });
+    const typedArray = bufferViewLoader.typedArray;
+    const image = await loadImageFromBufferTypedArray(typedArray);
+    if (imageLoader.isDestroyed()) {
+      return;
+    }
+
+    const imageAndMipLevels = getImageAndMipLevels(image);
+
+    // Unload everything except the image
+    imageLoader.unload();
+
+    imageLoader._image = imageAndMipLevels.image;
+    imageLoader._mipLevels = imageAndMipLevels.mipLevels;
+    imageLoader._state = ResourceLoaderState.READY;
+
+    return imageLoader;
+  } catch (error) {
+    if (imageLoader.isDestroyed()) {
+      return;
+    }
+
+    return handleError(imageLoader, error, "Failed to load embedded image");
+  }
 }
 
-function loadFromUri(imageLoader) {
+async function loadFromUri(imageLoader) {
+  imageLoader._state = ResourceLoaderState.LOADING;
   const baseResource = imageLoader._baseResource;
   const uri = imageLoader._uri;
   const resource = baseResource.getDerivedResource({
     url: uri,
   });
-  imageLoader._state = ResourceLoaderState.LOADING;
-  return loadImageFromUri(resource)
-    .then(function (image) {
-      if (imageLoader.isDestroyed()) {
-        return;
-      }
-
-      const imageAndMipLevels = getImageAndMipLevels(image);
-
-      // Unload everything except the image
-      imageLoader.unload();
-
-      imageLoader._image = imageAndMipLevels.image;
-      imageLoader._mipLevels = imageAndMipLevels.mipLevels;
-      imageLoader._state = ResourceLoaderState.READY;
-      return imageLoader;
-    })
-    .catch(function (error) {
-      if (imageLoader.isDestroyed()) {
-        return;
-      }
-      return handleError(imageLoader, error, `Failed to load image: ${uri}`);
-    });
+
+  try {
+    const image = await loadImageFromUri(resource);
+    if (imageLoader.isDestroyed()) {
+      return;
+    }
+
+    const imageAndMipLevels = getImageAndMipLevels(image);
+
+    // Unload everything except the image
+    imageLoader.unload();
+
+    imageLoader._image = imageAndMipLevels.image;
+    imageLoader._mipLevels = imageAndMipLevels.mipLevels;
+    imageLoader._state = ResourceLoaderState.READY;
+
+    return imageLoader;
+  } catch (error) {
+    if (imageLoader.isDestroyed()) {
+      return;
+    }
+    return handleError(imageLoader, error, `Failed to load image: ${uri}`);
+  }
 }
 
 function handleError(imageLoader, error, errorMessage) {
@@ -269,7 +259,7 @@ function getMimeTypeFromTypedArray(typedArray) {
   throw new RuntimeError("Image format is not recognized");
 }
 
-function loadImageFromBufferTypedArray(typedArray) {
+async function loadImageFromBufferTypedArray(typedArray) {
   const mimeType = getMimeTypeFromTypedArray(typedArray);
   if (mimeType === "image/ktx2") {
     // Need to make a copy of the embedded KTX2 buffer otherwise the underlying
@@ -310,7 +300,10 @@ function loadImageFromUri(resource) {
  * @private
  */
 GltfImageLoader.prototype.unload = function () {
-  if (defined(this._bufferViewLoader)) {
+  if (
+    defined(this._bufferViewLoader) &&
+    !this._bufferViewLoader.isDestroyed()
+  ) {
     this._resourceCache.unload(this._bufferViewLoader);
   }