@cesium/engine 2.1.0 → 2.2.0

package/Source/Scene/GltfIndexBufferLoader.js

@@ -79,7 +79,6 @@ function GltfIndexBufferLoader(options) {
   this._buffer = undefined;
   this._state = ResourceLoaderState.UNLOADED;
   this._promise = undefined;
-  this._process = function (loader, frameState) {};
 }
 
 if (defined(Object.create)) {
@@ -88,20 +87,6 @@ if (defined(Object.create)) {
 }
 
 Object.defineProperties(GltfIndexBufferLoader.prototype, {
-  /**
-   * A promise that resolves to the resource when the resource is ready, or undefined if the resource has not yet started loading.
-   *
-   * @memberof GltfIndexBufferLoader.prototype
-   *
-   * @type {Promise<GltfIndexBufferLoader>|undefined}
-   * @readonly
-   * @private
-   */
-  promise: {
-    get: function () {
-      return this._promise;
-    },
-  },
   /**
    * The cache key of the resource.
    *
@@ -168,135 +153,72 @@ const scratchIndexBufferJob = new CreateIndexBufferJob();
  * @returns {Promise<GltfIndexBufferLoader>} A promise which resolves to the loader when the resource loading is completed.
  * @private
  */
-GltfIndexBufferLoader.prototype.load = function () {
-  let promise;
+GltfIndexBufferLoader.prototype.load = async function () {
+  if (defined(this._promise)) {
+    return this._promise;
+  }
 
   if (defined(this._draco)) {
-    promise = loadFromDraco(this);
-  } else {
-    promise = loadFromBufferView(this);
+    this._promise = loadFromDraco(this);
+    return this._promise;
   }
 
-  const that = this;
-  const processPromise = new Promise(function (resolve) {
-    that._process = function (loader, frameState) {
-      if (loader._state === ResourceLoaderState.READY) {
-        return;
-      }
-
-      const typedArray = loader._typedArray;
-      const indexDatatype = loader._indexDatatype;
-
-      if (defined(loader._dracoLoader)) {
-        loader._dracoLoader.process(frameState);
-      }
-
-      if (defined(loader._bufferViewLoader)) {
-        loader._bufferViewLoader.process(frameState);
-      }
-
-      if (!defined(typedArray)) {
-        // Buffer view hasn't been loaded yet
-        return;
-      }
-
-      let buffer;
-      if (loader._loadBuffer && loader._asynchronous) {
-        const indexBufferJob = scratchIndexBufferJob;
-        indexBufferJob.set(typedArray, indexDatatype, frameState.context);
-        const jobScheduler = frameState.jobScheduler;
-        if (!jobScheduler.execute(indexBufferJob, JobType.BUFFER)) {
-          // Job scheduler is full. Try again next frame.
-          return;
-        }
-        buffer = indexBufferJob.buffer;
-      } else if (loader._loadBuffer) {
-        buffer = createIndexBuffer(
-          typedArray,
-          indexDatatype,
-          frameState.context
-        );
-      }
-
-      // Unload everything except the index buffer and/or typed array.
-      loader.unload();
-
-      loader._buffer = buffer;
-      loader._typedArray = loader._loadTypedArray ? typedArray : undefined;
-      loader._state = ResourceLoaderState.READY;
-      resolve(loader);
-    };
-  });
-
-  this._promise = promise
-    .then(function () {
-      if (that.isDestroyed()) {
-        return;
-      }
-
-      return processPromise;
-    })
-    .catch(function (error) {
-      if (that.isDestroyed()) {
-        return;
-      }
-
-      return handleError(that, error);
-    });
-
+  this._promise = loadFromBufferView(this);
   return this._promise;
 };
 
-function loadFromDraco(indexBufferLoader) {
+async function loadFromDraco(indexBufferLoader) {
+  indexBufferLoader._state = ResourceLoaderState.LOADING;
   const resourceCache = indexBufferLoader._resourceCache;
-  const dracoLoader = resourceCache.loadDraco({
-    gltf: indexBufferLoader._gltf,
-    draco: indexBufferLoader._draco,
-    gltfResource: indexBufferLoader._gltfResource,
-    baseResource: indexBufferLoader._baseResource,
-  });
 
-  indexBufferLoader._dracoLoader = dracoLoader;
-  indexBufferLoader._state = ResourceLoaderState.LOADING;
+  try {
+    const dracoLoader = resourceCache.getDracoLoader({
+      gltf: indexBufferLoader._gltf,
+      draco: indexBufferLoader._draco,
+      gltfResource: indexBufferLoader._gltfResource,
+      baseResource: indexBufferLoader._baseResource,
+    });
+    indexBufferLoader._dracoLoader = dracoLoader;
+    await dracoLoader.load();
 
-  return dracoLoader.promise.then(function () {
     if (indexBufferLoader.isDestroyed()) {
       return;
     }
+
     // Now wait for process() to run to finish loading
-    const typedArray = dracoLoader.decodedData.indices.typedArray;
-    indexBufferLoader._typedArray = typedArray;
-    // The index datatype may be a smaller datatype after draco decode
-    indexBufferLoader._indexDatatype = ComponentDatatype.fromTypedArray(
-      typedArray
-    );
-    indexBufferLoader._state = ResourceLoaderState.PROCESSING;
+    indexBufferLoader._state = ResourceLoaderState.LOADED;
     return indexBufferLoader;
-  });
+  } catch (error) {
+    if (indexBufferLoader.isDestroyed()) {
+      return;
+    }
+
+    handleError(indexBufferLoader, error);
+  }
 }
 
-function loadFromBufferView(indexBufferLoader) {
+async function loadFromBufferView(indexBufferLoader) {
   const gltf = indexBufferLoader._gltf;
   const accessorId = indexBufferLoader._accessorId;
   const accessor = gltf.accessors[accessorId];
   const bufferViewId = accessor.bufferView;
 
-  const resourceCache = indexBufferLoader._resourceCache;
-  const bufferViewLoader = resourceCache.loadBufferView({
-    gltf: gltf,
-    bufferViewId: bufferViewId,
-    gltfResource: indexBufferLoader._gltfResource,
-    baseResource: indexBufferLoader._baseResource,
-  });
   indexBufferLoader._state = ResourceLoaderState.LOADING;
-  indexBufferLoader._bufferViewLoader = bufferViewLoader;
+  const resourceCache = indexBufferLoader._resourceCache;
+  try {
+    const bufferViewLoader = resourceCache.getBufferViewLoader({
+      gltf: gltf,
+      bufferViewId: bufferViewId,
+      gltfResource: indexBufferLoader._gltfResource,
+      baseResource: indexBufferLoader._baseResource,
+    });
+    indexBufferLoader._bufferViewLoader = bufferViewLoader;
 
-  return bufferViewLoader.promise.then(function () {
+    await bufferViewLoader.load();
     if (indexBufferLoader.isDestroyed()) {
       return;
     }
 
-    // Now wait for process() to run to finish loading
     const bufferViewTypedArray = bufferViewLoader.typedArray;
     indexBufferLoader._typedArray = createIndicesTypedArray(
       indexBufferLoader,
@@ -304,7 +226,13 @@ function loadFromBufferView(indexBufferLoader) {
     );
     indexBufferLoader._state = ResourceLoaderState.PROCESSING;
     return indexBufferLoader;
-  });
+  } catch (error) {
+    if (indexBufferLoader.isDestroyed()) {
+      return;
+    }
+
+    handleError(indexBufferLoader, error);
+  }
 }
 
 function createIndicesTypedArray(indexBufferLoader, bufferViewTypedArray) {
@@ -346,8 +274,7 @@ function handleError(indexBufferLoader, error) {
   indexBufferLoader.unload();
   indexBufferLoader._state = ResourceLoaderState.FAILED;
   const errorMessage = "Failed to load index buffer";
-  error = indexBufferLoader.getError(errorMessage, error);
-  return Promise.reject(error);
+  throw indexBufferLoader.getError(errorMessage, error);
 }
 
 function CreateIndexBufferJob() {
@@ -397,7 +324,64 @@ GltfIndexBufferLoader.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.LOADED &&
+    this._state !== ResourceLoaderState.PROCESSING
+  ) {
+    return false;
+  }
+
+  let typedArray = this._typedArray;
+  let indexDatatype = this._indexDatatype;
+
+  if (defined(this._dracoLoader)) {
+    try {
+      const ready = this._dracoLoader.process(frameState);
+      if (ready) {
+        const dracoLoader = this._dracoLoader;
+        typedArray = dracoLoader.decodedData.indices.typedArray;
+        this._typedArray = typedArray;
+        // The index datatype may be a smaller datatype after draco decode
+        indexDatatype = ComponentDatatype.fromTypedArray(typedArray);
+        this._indexDatatype = indexDatatype;
+      }
+    } catch (error) {
+      handleError(this, error);
+    }
+  }
+
+  if (!defined(typedArray)) {
+    // Buffer view hasn't been loaded yet
+    return false;
+  }
+
+  let buffer;
+  if (this._loadBuffer && this._asynchronous) {
+    const indexBufferJob = scratchIndexBufferJob;
+    indexBufferJob.set(typedArray, indexDatatype, frameState.context);
+    const jobScheduler = frameState.jobScheduler;
+    if (!jobScheduler.execute(indexBufferJob, JobType.BUFFER)) {
+      // Job scheduler is full. Try again next frame.
+      return false;
+    }
+    buffer = indexBufferJob.buffer;
+  } else if (this._loadBuffer) {
+    buffer = createIndexBuffer(typedArray, indexDatatype, frameState.context);
+  }
+
+  // Unload everything except the index buffer and/or typed array.
+  this.unload();
+
+  this._buffer = buffer;
+  this._typedArray = this._loadTypedArray ? typedArray : undefined;
+  this._state = ResourceLoaderState.READY;
+
+  this._resourceCache.statistics.addGeometryLoader(this);
+  return true;
 };
 
 /**
@@ -411,7 +395,10 @@ GltfIndexBufferLoader.prototype.unload = function () {
 
   const resourceCache = this._resourceCache;
 
-  if (defined(this._bufferViewLoader)) {
+  if (
+    defined(this._bufferViewLoader) &&
+    !this._bufferViewLoader.isDestroyed()
+  ) {
     resourceCache.unload(this._bufferViewLoader);
   }
 

package/Source/Scene/GltfJsonLoader.js

@@ -68,20 +68,6 @@ if (defined(Object.create)) {
 }
 
 Object.defineProperties(GltfJsonLoader.prototype, {
-  /**
-   * A promise that resolves to the resource when the resource is ready, or undefined if the resource hasn't started loading.
-   *
-   * @memberof GltfJsonLoader.prototype
-   *
-   * @type {Promise<GltfJsonLoader>|undefined}
-   * @readonly
-   * @private
-   */
-  promise: {
-    get: function () {
-      return this._promise;
-    },
-  },
   /**
    * The cache key of the resource.
    *
@@ -117,56 +103,55 @@ Object.defineProperties(GltfJsonLoader.prototype, {
  * @returns {Promise<GltfJsonLoader>} A promise which resolves to the loader when the resource loading is completed.
  * @private
  */
-GltfJsonLoader.prototype.load = function () {
+GltfJsonLoader.prototype.load = async function () {
+  if (defined(this._promise)) {
+    return this._promise;
+  }
+
   this._state = ResourceLoaderState.LOADING;
 
-  let processPromise;
   if (defined(this._gltfJson)) {
-    processPromise = processGltfJson(this, this._gltfJson);
-  } else if (defined(this._typedArray)) {
-    processPromise = processGltfTypedArray(this, this._typedArray);
-  } else {
-    processPromise = loadFromUri(this);
+    this._promise = processGltfJson(this, this._gltfJson);
+    return this._promise;
   }
 
-  const that = this;
-  this._promise = processPromise
-    .then(function (gltf) {
-      if (that.isDestroyed()) {
-        return;
-      }
-      that._gltf = gltf;
-      that._state = ResourceLoaderState.READY;
-      return that;
-    })
-    .catch(function (error) {
-      if (that.isDestroyed()) {
-        return;
-      }
-      return handleError(that, error);
-    });
+  if (defined(this._typedArray)) {
+    this._promise = processGltfTypedArray(this, this._typedArray);
+    return this._promise;
+  }
 
+  this._promise = loadFromUri(this);
   return this._promise;
 };
 
-function loadFromUri(gltfJsonLoader) {
-  return gltfJsonLoader._fetchGltf().then(function (arrayBuffer) {
+async function loadFromUri(gltfJsonLoader) {
+  let typedArray;
+  try {
+    const arrayBuffer = await gltfJsonLoader._fetchGltf();
     if (gltfJsonLoader.isDestroyed()) {
       return;
     }
-    const typedArray = new Uint8Array(arrayBuffer);
-    return processGltfTypedArray(gltfJsonLoader, typedArray);
-  });
+
+    typedArray = new Uint8Array(arrayBuffer);
+  } catch (error) {
+    if (gltfJsonLoader.isDestroyed()) {
+      return;
+    }
+
+    handleError(gltfJsonLoader, error);
+  }
+
+  return processGltfTypedArray(gltfJsonLoader, typedArray);
 }
 
 function handleError(gltfJsonLoader, error) {
   gltfJsonLoader.unload();
   gltfJsonLoader._state = ResourceLoaderState.FAILED;
   const errorMessage = `Failed to load glTF: ${gltfJsonLoader._gltfResource.url}`;
-  return Promise.reject(gltfJsonLoader.getError(errorMessage, error));
+  throw gltfJsonLoader.getError(errorMessage, error);
 }
 
-function upgradeVersion(gltfJsonLoader, gltf) {
+async function upgradeVersion(gltfJsonLoader, gltf) {
   if (
     defined(gltf.asset) &&
     gltf.asset.version === "2.0" &&
@@ -188,23 +173,25 @@ function upgradeVersion(gltfJsonLoader, gltf) {
         url: buffer.uri,
       });
       const resourceCache = gltfJsonLoader._resourceCache;
-      const bufferLoader = resourceCache.loadExternalBuffer({
+      const bufferLoader = resourceCache.getExternalBufferLoader({
         resource: resource,
       });
-
       gltfJsonLoader._bufferLoaders.push(bufferLoader);
 
       promises.push(
-        bufferLoader.promise.then(function (bufferLoader) {
+        bufferLoader.load().then(function () {
+          if (bufferLoader.isDestroyed()) {
+            return;
+          }
+
           buffer.extras._pipeline.source = bufferLoader.typedArray;
         })
       );
     }
   });
 
-  return Promise.all(promises).then(function () {
-    updateVersion(gltf);
-  });
+  await Promise.all(promises);
+  updateVersion(gltf);
 }
 
 function decodeDataUris(gltf) {
@@ -233,42 +220,54 @@ function loadEmbeddedBuffers(gltfJsonLoader, gltf) {
     const source = buffer.extras._pipeline.source;
     if (defined(source) && !defined(buffer.uri)) {
       const resourceCache = gltfJsonLoader._resourceCache;
-      const bufferLoader = resourceCache.loadEmbeddedBuffer({
+      const bufferLoader = resourceCache.getEmbeddedBufferLoader({
         parentResource: gltfJsonLoader._gltfResource,
         bufferId: bufferId,
         typedArray: source,
       });
-
       gltfJsonLoader._bufferLoaders.push(bufferLoader);
-      promises.push(bufferLoader.promise);
+      promises.push(bufferLoader.load());
     }
   });
   return Promise.all(promises);
 }
 
-function processGltfJson(gltfJsonLoader, gltf) {
-  addPipelineExtras(gltf);
-
-  return decodeDataUris(gltf)
-    .then(function () {
-      return upgradeVersion(gltfJsonLoader, gltf);
-    })
-    .then(function () {
-      addDefaults(gltf);
-      return loadEmbeddedBuffers(gltfJsonLoader, gltf);
-    })
-    .then(function () {
-      removePipelineExtras(gltf);
-      return gltf;
-    });
+async function processGltfJson(gltfJsonLoader, gltf) {
+  try {
+    addPipelineExtras(gltf);
+
+    await decodeDataUris(gltf);
+    await upgradeVersion(gltfJsonLoader, gltf);
+    addDefaults(gltf);
+    await loadEmbeddedBuffers(gltfJsonLoader, gltf);
+    removePipelineExtras(gltf);
+
+    gltfJsonLoader._gltf = gltf;
+    gltfJsonLoader._state = ResourceLoaderState.READY;
+    return gltfJsonLoader;
+  } catch (error) {
+    if (gltfJsonLoader.isDestroyed()) {
+      return;
+    }
+
+    handleError(gltfJsonLoader, error);
+  }
 }
 
-function processGltfTypedArray(gltfJsonLoader, typedArray) {
+async function processGltfTypedArray(gltfJsonLoader, typedArray) {
   let gltf;
-  if (getMagic(typedArray) === "glTF") {
-    gltf = parseGlb(typedArray);
-  } else {
-    gltf = getJsonFromTypedArray(typedArray);
+  try {
+    if (getMagic(typedArray) === "glTF") {
+      gltf = parseGlb(typedArray);
+    } else {
+      gltf = getJsonFromTypedArray(typedArray);
+    }
+  } catch (error) {
+    if (gltfJsonLoader.isDestroyed()) {
+      return;
+    }
+
+    handleError(gltfJsonLoader, error);
   }
 
   return processGltfJson(gltfJsonLoader, gltf);
@@ -282,7 +281,9 @@ GltfJsonLoader.prototype.unload = function () {
   const bufferLoaders = this._bufferLoaders;
   const bufferLoadersLength = bufferLoaders.length;
   for (let i = 0; i < bufferLoadersLength; ++i) {
-    this._resourceCache.unload(bufferLoaders[i]);
+    bufferLoaders[i] =
+      !bufferLoaders[i].isDestroyed() &&
+      this._resourceCache.unload(bufferLoaders[i]);
   }
   this._bufferLoaders.length = 0;