@cesium/engine 22.2.0 → 23.0.0

package/Source/Scene/GltfTextureLoader.js

@@ -18,74 +18,68 @@ import resizeImageToNextPowerOfTwo from "../Core/resizeImageToNextPowerOfTwo.js"
  * Implements the {@link ResourceLoader} interface.
  * </p>
  *
- * @alias GltfTextureLoader
- * @constructor
- * @augments ResourceLoader
- *
- * @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.textureInfo The texture info 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 {SupportedImageFormats} options.supportedImageFormats The supported image formats.
- * @param {string} [options.cacheKey] The cache key of the resource.
- * @param {boolean} [options.asynchronous=true] Determines if WebGL resource creation will be spread out over several frames or block until all WebGL resources are created.
- *
  * @private
  */
-function GltfTextureLoader(options) {
-  options = options ?? Frozen.EMPTY_OBJECT;
-  const resourceCache = options.resourceCache;
-  const gltf = options.gltf;
-  const textureInfo = options.textureInfo;
-  const gltfResource = options.gltfResource;
-  const baseResource = options.baseResource;
-  const supportedImageFormats = options.supportedImageFormats;
-  const cacheKey = options.cacheKey;
-  const asynchronous = options.asynchronous ?? true;
-
-  //>>includeStart('debug', pragmas.debug);
-  Check.typeOf.func("options.resourceCache", resourceCache);
-  Check.typeOf.object("options.gltf", gltf);
-  Check.typeOf.object("options.textureInfo", textureInfo);
-  Check.typeOf.object("options.gltfResource", gltfResource);
-  Check.typeOf.object("options.baseResource", baseResource);
-  Check.typeOf.object("options.supportedImageFormats", supportedImageFormats);
-  //>>includeEnd('debug');
-
-  const textureId = textureInfo.index;
-
-  // imageId is guaranteed to be defined otherwise the GltfTextureLoader
-  // wouldn't have been created
-  const imageId = GltfLoaderUtil.getImageIdFromTexture({
-    gltf: gltf,
-    textureId: textureId,
-    supportedImageFormats: supportedImageFormats,
-  });
-
-  this._resourceCache = resourceCache;
-  this._gltf = gltf;
-  this._textureInfo = textureInfo;
-  this._imageId = imageId;
-  this._gltfResource = gltfResource;
-  this._baseResource = baseResource;
-  this._cacheKey = cacheKey;
-  this._asynchronous = asynchronous;
-  this._imageLoader = undefined;
-  this._image = undefined;
-  this._mipLevels = undefined;
-  this._texture = undefined;
-  this._state = ResourceLoaderState.UNLOADED;
-  this._promise = undefined;
-}
+class GltfTextureLoader extends ResourceLoader {
+  /**
+   * @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.textureInfo The texture info 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 {SupportedImageFormats} options.supportedImageFormats The supported image formats.
+   * @param {string} [options.cacheKey] The cache key of the resource.
+   * @param {boolean} [options.asynchronous=true] Determines if WebGL resource creation will be spread out over several frames or block until all WebGL resources are created.
+   */
+  constructor(options) {
+    super();
+
+    options = options ?? Frozen.EMPTY_OBJECT;
+    const resourceCache = options.resourceCache;
+    const gltf = options.gltf;
+    const textureInfo = options.textureInfo;
+    const gltfResource = options.gltfResource;
+    const baseResource = options.baseResource;
+    const supportedImageFormats = options.supportedImageFormats;
+    const cacheKey = options.cacheKey;
+    const asynchronous = options.asynchronous ?? true;
+
+    //>>includeStart('debug', pragmas.debug);
+    Check.typeOf.func("options.resourceCache", resourceCache);
+    Check.typeOf.object("options.gltf", gltf);
+    Check.typeOf.object("options.textureInfo", textureInfo);
+    Check.typeOf.object("options.gltfResource", gltfResource);
+    Check.typeOf.object("options.baseResource", baseResource);
+    Check.typeOf.object("options.supportedImageFormats", supportedImageFormats);
+    //>>includeEnd('debug');
+
+    const textureId = textureInfo.index;
+
+    // imageId is guaranteed to be defined otherwise the GltfTextureLoader
+    // wouldn't have been created
+    const imageId = GltfLoaderUtil.getImageIdFromTexture({
+      gltf: gltf,
+      textureId: textureId,
+      supportedImageFormats: supportedImageFormats,
+    });
 
-if (defined(Object.create)) {
-  GltfTextureLoader.prototype = Object.create(ResourceLoader.prototype);
-  GltfTextureLoader.prototype.constructor = GltfTextureLoader;
-}
+    this._resourceCache = resourceCache;
+    this._gltf = gltf;
+    this._textureInfo = textureInfo;
+    this._imageId = imageId;
+    this._gltfResource = gltfResource;
+    this._baseResource = baseResource;
+    this._cacheKey = cacheKey;
+    this._asynchronous = asynchronous;
+    this._imageLoader = undefined;
+    this._image = undefined;
+    this._mipLevels = undefined;
+    this._texture = undefined;
+    this._state = ResourceLoaderState.UNLOADED;
+    this._promise = undefined;
+  }
 
-Object.defineProperties(GltfTextureLoader.prototype, {
   /**
    * The cache key of the resource.
    *
@@ -95,11 +89,10 @@ Object.defineProperties(GltfTextureLoader.prototype, {
    * @readonly
    * @private
    */
-  cacheKey: {
-    get: function () {
-      return this._cacheKey;
-    },
-  },
+  get cacheKey() {
+    return this._cacheKey;
+  }
+
   /**
    * The texture.
    *
@@ -109,99 +102,148 @@ Object.defineProperties(GltfTextureLoader.prototype, {
    * @readonly
    * @private
    */
-  texture: {
-    get: function () {
-      return this._texture;
-    },
-  },
-});
+  get texture() {
+    return this._texture;
+  }
 
-const scratchTextureJob = new CreateTextureJob();
+  /**
+   * Loads the resource.
+   * @returns {Promise<GltfDracoLoader>} A promise which resolves to the loader when the resource loading is completed.
+   * @private
+   */
+  async load() {
+    if (defined(this._promise)) {
+      return this._promise;
+    }
 
-async function loadResources(loader) {
-  const resourceCache = loader._resourceCache;
-  try {
-    const imageLoader = resourceCache.getImageLoader({
-      gltf: loader._gltf,
-      imageId: loader._imageId,
-      gltfResource: loader._gltfResource,
-      baseResource: loader._baseResource,
-    });
-    loader._imageLoader = imageLoader;
-    await imageLoader.load();
+    this._state = ResourceLoaderState.LOADING;
+    this._promise = loadResources(this);
+    return this._promise;
+  }
 
-    if (loader.isDestroyed()) {
-      return;
+  /**
+   * Processes the resource until it becomes ready.
+   *
+   * @param {FrameState} frameState The frame state.
+   * @returns {boolean} true once all resourced are ready.
+   * @private
+   */
+  process(frameState) {
+    //>>includeStart('debug', pragmas.debug);
+    Check.typeOf.object("frameState", frameState);
+    //>>includeEnd('debug');
+
+    if (this._state === ResourceLoaderState.READY) {
+      return true;
     }
 
-    // Now wait for process() to run to finish loading
-    loader._image = imageLoader.image;
-    loader._mipLevels = imageLoader.mipLevels;
-    loader._state = ResourceLoaderState.LOADED;
+    if (
+      this._state !== ResourceLoaderState.LOADED &&
+      this._state !== ResourceLoaderState.PROCESSING
+    ) {
+      return false;
+    }
 
-    return loader;
-  } catch (error) {
-    if (loader.isDestroyed()) {
-      return;
+    if (defined(this._texture)) {
+      // Already created texture
+      return false;
     }
 
-    loader.unload();
-    loader._state = ResourceLoaderState.FAILED;
-    const errorMessage = "Failed to load texture";
-    throw loader.getError(errorMessage, error);
+    if (!defined(this._image)) {
+      // Not ready to create texture
+      return false;
+    }
+
+    this._state = ResourceLoaderState.PROCESSING;
+
+    let texture;
+    if (this._asynchronous) {
+      const textureJob = scratchTextureJob;
+      textureJob.set(
+        this._gltf,
+        this._textureInfo,
+        this._cacheKey,
+        this._image,
+        this._mipLevels,
+        frameState.context,
+      );
+      const jobScheduler = frameState.jobScheduler;
+      if (!jobScheduler.execute(textureJob, JobType.TEXTURE)) {
+        // Job scheduler is full. Try again next frame.
+        return false;
+      }
+      texture = textureJob.texture;
+    } else {
+      texture = createTexture(
+        this._gltf,
+        this._textureInfo,
+        this._cacheKey,
+        this._image,
+        this._mipLevels,
+        frameState.context,
+      );
+    }
+
+    // Unload everything except the texture
+    this.unload();
+
+    this._texture = texture;
+    this._state = ResourceLoaderState.READY;
+    this._resourceCache.statistics.addTextureLoader(this);
+    return true;
+  }
+
+  /**
+   * Unloads the resource.
+   * @private
+   */
+  unload() {
+    if (defined(this._texture)) {
+      this._texture.destroy();
+    }
+
+    if (defined(this._imageLoader) && !this._imageLoader.isDestroyed()) {
+      this._resourceCache.unload(this._imageLoader);
+    }
+
+    this._imageLoader = undefined;
+    this._image = undefined;
+    this._mipLevels = undefined;
+    this._texture = undefined;
+    this._gltf = undefined;
   }
 }
 
-/**
- * Loads the resource.
- * @returns {Promise<GltfDracoLoader>} A promise which resolves to the loader when the resource loading is completed.
- * @private
- */
-GltfTextureLoader.prototype.load = async function () {
-  if (defined(this._promise)) {
-    return this._promise;
+class CreateTextureJob {
+  constructor() {
+    this.gltf = undefined;
+    this.textureInfo = undefined;
+    this.textureId = undefined;
+    this.image = undefined;
+    this.context = undefined;
+    this.texture = undefined;
   }
 
-  this._state = ResourceLoaderState.LOADING;
-  this._promise = loadResources(this);
-  return this._promise;
-};
-
-function CreateTextureJob() {
-  this.gltf = undefined;
-  this.textureInfo = undefined;
-  this.textureId = undefined;
-  this.image = undefined;
-  this.context = undefined;
-  this.texture = undefined;
-}
+  set(gltf, textureInfo, textureId, image, mipLevels, context) {
+    this.gltf = gltf;
+    this.textureInfo = textureInfo;
+    this.textureId = textureId;
+    this.image = image;
+    this.mipLevels = mipLevels;
+    this.context = context;
+  }
 
-CreateTextureJob.prototype.set = function (
-  gltf,
-  textureInfo,
-  textureId,
-  image,
-  mipLevels,
-  context,
-) {
-  this.gltf = gltf;
-  this.textureInfo = textureInfo;
-  this.textureId = textureId;
-  this.image = image;
-  this.mipLevels = mipLevels;
-  this.context = context;
-};
-
-CreateTextureJob.prototype.execute = function () {
-  this.texture = createTexture(
-    this.gltf,
-    this.textureInfo,
-    this.textureId,
-    this.image,
-    this.mipLevels,
-    this.context,
-  );
-};
+  execute() {
+    this.texture = createTexture(
+      this.gltf,
+      this.textureInfo,
+      this.textureId,
+      this.image,
+      this.mipLevels,
+      this.context,
+    );
+  }
+}
 
 function createTexture(
   gltf,
@@ -304,96 +346,40 @@ function createTexture(
   return texture;
 }
 
-/**
- * Processes the resource until it becomes ready.
- *
- * @param {FrameState} frameState The frame state.
- * @returns {boolean} true once all resourced are ready.
- * @private
- */
-GltfTextureLoader.prototype.process = function (frameState) {
-  //>>includeStart('debug', pragmas.debug);
-  Check.typeOf.object("frameState", frameState);
-  //>>includeEnd('debug');
-
-  if (this._state === ResourceLoaderState.READY) {
-    return true;
-  }
-
-  if (
-    this._state !== ResourceLoaderState.LOADED &&
-    this._state !== ResourceLoaderState.PROCESSING
-  ) {
-    return false;
-  }
-
-  if (defined(this._texture)) {
-    // Already created texture
-    return false;
-  }
-
-  if (!defined(this._image)) {
-    // Not ready to create texture
-    return false;
-  }
+const scratchTextureJob = new CreateTextureJob();
 
-  this._state = ResourceLoaderState.PROCESSING;
+async function loadResources(loader) {
+  const resourceCache = loader._resourceCache;
+  try {
+    const imageLoader = resourceCache.getImageLoader({
+      gltf: loader._gltf,
+      imageId: loader._imageId,
+      gltfResource: loader._gltfResource,
+      baseResource: loader._baseResource,
+    });
+    loader._imageLoader = imageLoader;
+    await imageLoader.load();
 
-  let texture;
-  if (this._asynchronous) {
-    const textureJob = scratchTextureJob;
-    textureJob.set(
-      this._gltf,
-      this._textureInfo,
-      this._cacheKey,
-      this._image,
-      this._mipLevels,
-      frameState.context,
-    );
-    const jobScheduler = frameState.jobScheduler;
-    if (!jobScheduler.execute(textureJob, JobType.TEXTURE)) {
-      // Job scheduler is full. Try again next frame.
+    if (loader.isDestroyed()) {
       return;
     }
-    texture = textureJob.texture;
-  } else {
-    texture = createTexture(
-      this._gltf,
-      this._textureInfo,
-      this._cacheKey,
-      this._image,
-      this._mipLevels,
-      frameState.context,
-    );
-  }
-
-  // Unload everything except the texture
-  this.unload();
 
-  this._texture = texture;
-  this._state = ResourceLoaderState.READY;
-  this._resourceCache.statistics.addTextureLoader(this);
-  return true;
-};
+    // Now wait for process() to run to finish loading
+    loader._image = imageLoader.image;
+    loader._mipLevels = imageLoader.mipLevels;
+    loader._state = ResourceLoaderState.LOADED;
 
-/**
- * Unloads the resource.
- * @private
- */
-GltfTextureLoader.prototype.unload = function () {
-  if (defined(this._texture)) {
-    this._texture.destroy();
-  }
+    return loader;
+  } catch (error) {
+    if (loader.isDestroyed()) {
+      return;
+    }
 
-  if (defined(this._imageLoader) && !this._imageLoader.isDestroyed()) {
-    this._resourceCache.unload(this._imageLoader);
+    loader.unload();
+    loader._state = ResourceLoaderState.FAILED;
+    const errorMessage = "Failed to load texture";
+    throw loader.getError(errorMessage, error);
   }
-
-  this._imageLoader = undefined;
-  this._image = undefined;
-  this._mipLevels = undefined;
-  this._texture = undefined;
-  this._gltf = undefined;
-};
+}
 
 export default GltfTextureLoader;