@cesium/engine 2.0.0 → 2.2.0

package/Source/Scene/GltfDracoLoader.js

@@ -15,13 +15,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 {Object} options.draco The Draco extension object.
+ * @param {object} options.gltf The glTF JSON.
+ * @param {object} options.draco The Draco extension object.
  * @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
  */
@@ -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,26 +63,12 @@ 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.
    *
    * @memberof GltfDracoLoader.prototype
    *
-   * @type {String}
+   * @type {string}
    * @readonly
    * @private
    */
@@ -96,7 +82,7 @@ Object.defineProperties(GltfDracoLoader.prototype, {
    *
    * @memberof GltfDracoLoader.prototype
    *
-   * @type {Object}
+   * @type {object}
    * @readonly
    * @private
    */
@@ -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.
+ * @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

@@ -17,13 +17,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.imageId The image ID.
+ * @param {object} options.gltf The glTF JSON.
+ * @param {number} options.imageId The image 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
  */
@@ -68,26 +68,12 @@ 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.
    *
    * @memberof GltfImageLoader.prototype
    *
-   * @type {String}
+   * @type {string}
    * @readonly
    * @private
    */
@@ -128,10 +114,14 @@ Object.defineProperties(GltfImageLoader.prototype, {
 
 /**
  * Loads the resource.
- * @returns {Promise.<GltfImageLoader>} A promise which resolves to the loader when the resource loading is completed.
+ * @returns {Promise<GltfImageLoader>} A promise which resolves to the loader when the resource loading is completed.
  * @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);
   }