@cesium/engine 22.3.0 → 23.0.0

package/Source/Scene/GltfVertexBufferLoader.js

@@ -17,127 +17,121 @@ import CesiumMath from "../Core/Math.js";
  * Implements the {@link ResourceLoader} interface.
  * </p>
  *
- * @alias GltfVertexBufferLoader
- * @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 {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 {number} [options.bufferViewId] The bufferView ID corresponding to the vertex buffer.
- * @param {object} [options.primitive] The primitive containing the Draco extension.
- * @param {object} [options.draco] The Draco extension object.
- * @param {string} [options.attributeSemantic] The attribute semantic, e.g. POSITION or NORMAL.
- * @param {number} [options.accessorId] The accessor id.
- * @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.
- * @param {boolean} [options.loadBuffer=false] Load vertex buffer as a GPU vertex buffer.
- * @param {boolean} [options.loadTypedArray=false] Load vertex buffer as a typed array.
- *
- * @exception {DeveloperError} One of options.bufferViewId and options.draco must be defined.
- * @exception {DeveloperError} When options.draco is defined options.attributeSemantic must also be defined.
- * @exception {DeveloperError} When options.draco is defined options.accessorId must also be defined.
- *
  * @private
  */
-function GltfVertexBufferLoader(options) {
-  options = options ?? Frozen.EMPTY_OBJECT;
-  const resourceCache = options.resourceCache;
-  const gltf = options.gltf;
-  const gltfResource = options.gltfResource;
-  const baseResource = options.baseResource;
-  const bufferViewId = options.bufferViewId;
-  const primitive = options.primitive;
-  const draco = options.draco;
-  const attributeSemantic = options.attributeSemantic;
-  const accessorId = options.accessorId;
-  const cacheKey = options.cacheKey;
-  const spz = options.spz;
-  const asynchronous = options.asynchronous ?? true;
-  const loadBuffer = options.loadBuffer ?? false;
-  const loadTypedArray = options.loadTypedArray ?? false;
-
-  //>>includeStart('debug', pragmas.debug);
-  Check.typeOf.func("options.resourceCache", resourceCache);
-  Check.typeOf.object("options.gltf", gltf);
-  Check.typeOf.object("options.gltfResource", gltfResource);
-  Check.typeOf.object("options.baseResource", baseResource);
-  if (!loadBuffer && !loadTypedArray) {
-    throw new DeveloperError(
-      "At least one of loadBuffer and loadTypedArray must be true.",
-    );
-  }
-
-  const hasBufferViewId = defined(bufferViewId);
-  const hasPrimitive = defined(primitive);
-  const hasDraco = hasDracoCompression(draco, attributeSemantic);
-  const hasAttributeSemantic = defined(attributeSemantic);
-  const hasAccessorId = defined(accessorId);
-  const hasSpz = defined(spz);
-  if (hasBufferViewId === (hasDraco !== hasSpz)) {
-    throw new DeveloperError(
-      "One of options.bufferViewId, options.draco, or options.spz must be defined.",
-    );
-  }
+class GltfVertexBufferLoader 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 {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 {number} [options.bufferViewId] The bufferView ID corresponding to the vertex buffer.
+   * @param {object} [options.primitive] The primitive containing the Draco extension.
+   * @param {object} [options.draco] The Draco extension object.
+   * @param {string} [options.attributeSemantic] The attribute semantic, e.g. POSITION or NORMAL.
+   * @param {number} [options.accessorId] The accessor id.
+   * @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.
+   * @param {boolean} [options.loadBuffer=false] Load vertex buffer as a GPU vertex buffer.
+   * @param {boolean} [options.loadTypedArray=false] Load vertex buffer as a typed array.
+   *
+   * @exception {DeveloperError} One of options.bufferViewId and options.draco must be defined.
+   * @exception {DeveloperError} When options.draco is defined options.attributeSemantic must also be defined.
+   * @exception {DeveloperError} When options.draco is defined options.accessorId must also be defined.
+   */
+  constructor(options) {
+    super();
+
+    options = options ?? Frozen.EMPTY_OBJECT;
+    const resourceCache = options.resourceCache;
+    const gltf = options.gltf;
+    const gltfResource = options.gltfResource;
+    const baseResource = options.baseResource;
+    const bufferViewId = options.bufferViewId;
+    const primitive = options.primitive;
+    const draco = options.draco;
+    const attributeSemantic = options.attributeSemantic;
+    const accessorId = options.accessorId;
+    const cacheKey = options.cacheKey;
+    const spz = options.spz;
+    const asynchronous = options.asynchronous ?? true;
+    const loadBuffer = options.loadBuffer ?? false;
+    const loadTypedArray = options.loadTypedArray ?? false;
+
+    //>>includeStart('debug', pragmas.debug);
+    Check.typeOf.func("options.resourceCache", resourceCache);
+    Check.typeOf.object("options.gltf", gltf);
+    Check.typeOf.object("options.gltfResource", gltfResource);
+    Check.typeOf.object("options.baseResource", baseResource);
+    if (!loadBuffer && !loadTypedArray) {
+      throw new DeveloperError(
+        "At least one of loadBuffer and loadTypedArray must be true.",
+      );
+    }
 
-  if (hasDraco && !hasAttributeSemantic) {
-    throw new DeveloperError(
-      "When options.draco is defined options.attributeSemantic must also be defined.",
-    );
-  }
+    const hasBufferViewId = defined(bufferViewId);
+    const hasPrimitive = defined(primitive);
+    const hasDraco = hasDracoCompression(draco, attributeSemantic);
+    const hasAttributeSemantic = defined(attributeSemantic);
+    const hasAccessorId = defined(accessorId);
+    const hasSpz = defined(spz);
+    if (hasBufferViewId === (hasDraco !== hasSpz)) {
+      throw new DeveloperError(
+        "One of options.bufferViewId, options.draco, or options.spz must be defined.",
+      );
+    }
 
-  if (hasDraco && !hasAccessorId) {
-    throw new DeveloperError(
-      "When options.draco is defined options.accessorId must also be defined.",
-    );
-  }
+    if (hasDraco && !hasAttributeSemantic) {
+      throw new DeveloperError(
+        "When options.draco is defined options.attributeSemantic must also be defined.",
+      );
+    }
 
-  if (hasDraco && !hasPrimitive) {
-    throw new DeveloperError(
-      "When options.draco is defined options.primitive must also be defined.",
-    );
-  }
+    if (hasDraco && !hasAccessorId) {
+      throw new DeveloperError(
+        "When options.draco is defined options.accessorId must also be defined.",
+      );
+    }
 
-  if (hasDraco) {
-    Check.typeOf.object("options.primitive", primitive);
-    Check.typeOf.object("options.draco", draco);
-    Check.typeOf.string("options.attributeSemantic", attributeSemantic);
-    Check.typeOf.number("options.accessorId", accessorId);
-  }
+    if (hasDraco && !hasPrimitive) {
+      throw new DeveloperError(
+        "When options.draco is defined options.primitive must also be defined.",
+      );
+    }
 
-  //>>includeEnd('debug');
-
-  this._resourceCache = resourceCache;
-  this._gltfResource = gltfResource;
-  this._baseResource = baseResource;
-  this._gltf = gltf;
-  this._bufferViewId = bufferViewId;
-  this._primitive = primitive;
-  this._draco = draco;
-  this._spz = spz;
-  this._attributeSemantic = attributeSemantic;
-  this._accessorId = accessorId;
-  this._cacheKey = cacheKey;
-  this._asynchronous = asynchronous;
-  this._loadBuffer = loadBuffer;
-  this._loadTypedArray = loadTypedArray;
-  this._bufferViewLoader = undefined;
-  this._dracoLoader = undefined;
-  this._quantization = undefined;
-  this._typedArray = undefined;
-  this._buffer = undefined;
-  this._state = ResourceLoaderState.UNLOADED;
-  this._promise = undefined;
-}
+    if (hasDraco) {
+      Check.typeOf.object("options.primitive", primitive);
+      Check.typeOf.object("options.draco", draco);
+      Check.typeOf.string("options.attributeSemantic", attributeSemantic);
+      Check.typeOf.number("options.accessorId", accessorId);
+    }
 
-if (defined(Object.create)) {
-  GltfVertexBufferLoader.prototype = Object.create(ResourceLoader.prototype);
-  GltfVertexBufferLoader.prototype.constructor = GltfVertexBufferLoader;
-}
+    //>>includeEnd('debug');
+
+    this._resourceCache = resourceCache;
+    this._gltfResource = gltfResource;
+    this._baseResource = baseResource;
+    this._gltf = gltf;
+    this._bufferViewId = bufferViewId;
+    this._primitive = primitive;
+    this._draco = draco;
+    this._spz = spz;
+    this._attributeSemantic = attributeSemantic;
+    this._accessorId = accessorId;
+    this._cacheKey = cacheKey;
+    this._asynchronous = asynchronous;
+    this._loadBuffer = loadBuffer;
+    this._loadTypedArray = loadTypedArray;
+    this._bufferViewLoader = undefined;
+    this._dracoLoader = undefined;
+    this._quantization = undefined;
+    this._typedArray = undefined;
+    this._buffer = undefined;
+    this._state = ResourceLoaderState.UNLOADED;
+    this._promise = undefined;
+  }
 
-Object.defineProperties(GltfVertexBufferLoader.prototype, {
   /**
    * The cache key of the resource.
    *
@@ -147,11 +141,10 @@ Object.defineProperties(GltfVertexBufferLoader.prototype, {
    * @readonly
    * @private
    */
-  cacheKey: {
-    get: function () {
-      return this._cacheKey;
-    },
-  },
+  get cacheKey() {
+    return this._cacheKey;
+  }
+
   /**
    * The vertex buffer. This is only defined when <code>loadAsTypedArray</code> is false.
    *
@@ -161,11 +154,10 @@ Object.defineProperties(GltfVertexBufferLoader.prototype, {
    * @readonly
    * @private
    */
-  buffer: {
-    get: function () {
-      return this._buffer;
-    },
-  },
+  get buffer() {
+    return this._buffer;
+  }
+
   /**
    * The typed array containing vertex buffer data. This is only defined when <code>loadAsTypedArray</code> is true.
    *
@@ -175,11 +167,10 @@ Object.defineProperties(GltfVertexBufferLoader.prototype, {
    * @readonly
    * @private
    */
-  typedArray: {
-    get: function () {
-      return this._typedArray;
-    },
-  },
+  get typedArray() {
+    return this._typedArray;
+  }
+
   /**
    * Information about the quantized vertex attribute after Draco decode.
    *
@@ -189,44 +180,150 @@ Object.defineProperties(GltfVertexBufferLoader.prototype, {
    * @readonly
    * @private
    */
-  quantization: {
-    get: function () {
-      return this._quantization;
-    },
-  },
-});
+  get quantization() {
+    return this._quantization;
+  }
 
-function hasDracoCompression(draco, semantic) {
-  return (
-    defined(draco) &&
-    defined(draco.attributes) &&
-    defined(draco.attributes[semantic])
-  );
-}
+  /**
+   * Loads the resource.
+   * @returns {Promise<GltfVertexBufferLoader>} A promise which resolves to the loader when the resource loading is completed.
+   * @private
+   */
+  async load() {
+    if (defined(this._promise)) {
+      return this._promise;
+    }
 
-/**
- * Loads the resource.
- * @returns {Promise<GltfVertexBufferLoader>} A promise which resolves to the loader when the resource loading is completed.
- * @private
- */
-GltfVertexBufferLoader.prototype.load = async function () {
-  if (defined(this._promise)) {
+    if (defined(this._spz)) {
+      this._promise = loadFromSpz(this);
+      return this._promise;
+    }
+
+    if (hasDracoCompression(this._draco, this._attributeSemantic)) {
+      this._promise = loadFromDraco(this);
+      return this._promise;
+    }
+
+    this._promise = loadFromBufferView(this);
     return this._promise;
   }
 
-  if (defined(this._spz)) {
-    this._promise = loadFromSpz(this);
-    return this._promise;
+  /**
+   * Processes the resource until it becomes ready.
+   *
+   * @param {FrameState} frameState The frame state.
+   * @private
+   */
+  process(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._dracoLoader)) {
+      try {
+        const ready = this._dracoLoader.process(frameState);
+        if (!ready) {
+          return false;
+        }
+      } catch (error) {
+        handleError(this, error);
+      }
+
+      processDraco(this);
+    }
+
+    if (defined(this._spzLoader)) {
+      try {
+        const ready = this._spzLoader.process(frameState);
+        if (!ready) {
+          return false;
+        }
+      } catch (error) {
+        handleError(this, error);
+      }
+
+      processSpz(this);
+    }
+
+    let buffer;
+    const typedArray = this._typedArray;
+    if (this._loadBuffer && this._asynchronous) {
+      const vertexBufferJob = scratchVertexBufferJob;
+      vertexBufferJob.set(typedArray, frameState.context);
+      const jobScheduler = frameState.jobScheduler;
+      if (!jobScheduler.execute(vertexBufferJob, JobType.BUFFER)) {
+        // Job scheduler is full. Try again next frame.
+        return false;
+      }
+      buffer = vertexBufferJob.buffer;
+    } else if (this._loadBuffer) {
+      buffer = createVertexBuffer(typedArray, frameState.context);
+    }
+
+    // Unload everything except the vertex buffer
+    this.unload();
+
+    this._buffer = buffer;
+    this._typedArray = this._loadTypedArray ? typedArray : undefined;
+    this._state = ResourceLoaderState.READY;
+    this._resourceCache.statistics.addGeometryLoader(this);
+    return true;
   }
 
-  if (hasDracoCompression(this._draco, this._attributeSemantic)) {
-    this._promise = loadFromDraco(this);
-    return this._promise;
+  /**
+   * Unloads the resource.
+   * @private
+   */
+  unload() {
+    if (defined(this._buffer)) {
+      this._buffer.destroy();
+    }
+
+    const resourceCache = this._resourceCache;
+
+    if (
+      defined(this._bufferViewLoader) &&
+      !this._bufferViewLoader.isDestroyed()
+    ) {
+      resourceCache.unload(this._bufferViewLoader);
+    }
+
+    if (defined(this._dracoLoader)) {
+      resourceCache.unload(this._dracoLoader);
+    }
+
+    if (defined(this._spzLoader)) {
+      resourceCache.unload(this._spzLoader);
+    }
+
+    this._bufferViewLoader = undefined;
+    this._dracoLoader = undefined;
+    this._spzLoader = undefined;
+    this._typedArray = undefined;
+    this._buffer = undefined;
+    this._gltf = undefined;
+    this._primitive = undefined;
   }
+}
 
-  this._promise = loadFromBufferView(this);
-  return this._promise;
-};
+function hasDracoCompression(draco, semantic) {
+  return (
+    defined(draco) &&
+    defined(draco.attributes) &&
+    defined(draco.attributes[semantic])
+  );
+}
 
 function getQuantizationInformation(
   dracoQuantization,
@@ -496,20 +593,22 @@ function handleError(vertexBufferLoader, error) {
   throw vertexBufferLoader.getError(errorMessage, error);
 }
 
-function CreateVertexBufferJob() {
-  this.typedArray = undefined;
-  this.context = undefined;
-  this.buffer = undefined;
-}
+class CreateVertexBufferJob {
+  constructor() {
+    this.typedArray = undefined;
+    this.context = undefined;
+    this.buffer = undefined;
+  }
 
-CreateVertexBufferJob.prototype.set = function (typedArray, context) {
-  this.typedArray = typedArray;
-  this.context = context;
-};
+  set(typedArray, context) {
+    this.typedArray = typedArray;
+    this.context = context;
+  }
 
-CreateVertexBufferJob.prototype.execute = function () {
-  this.buffer = createVertexBuffer(this.typedArray, this.context);
-};
+  execute() {
+    this.buffer = createVertexBuffer(this.typedArray, this.context);
+  }
+}
 
 function createVertexBuffer(typedArray, context) {
   const buffer = Buffer.createVertexBuffer({
@@ -523,112 +622,4 @@ function createVertexBuffer(typedArray, context) {
 
 const scratchVertexBufferJob = new CreateVertexBufferJob();
 
-/**
- * Processes the resource until it becomes ready.
- *
- * @param {FrameState} frameState The frame state.
- * @private
- */
-GltfVertexBufferLoader.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._dracoLoader)) {
-    try {
-      const ready = this._dracoLoader.process(frameState);
-      if (!ready) {
-        return false;
-      }
-    } catch (error) {
-      handleError(this, error);
-    }
-
-    processDraco(this);
-  }
-
-  if (defined(this._spzLoader)) {
-    try {
-      const ready = this._spzLoader.process(frameState);
-      if (!ready) {
-        return false;
-      }
-    } catch (error) {
-      handleError(this, error);
-    }
-
-    processSpz(this);
-  }
-
-  let buffer;
-  const typedArray = this._typedArray;
-  if (this._loadBuffer && this._asynchronous) {
-    const vertexBufferJob = scratchVertexBufferJob;
-    vertexBufferJob.set(typedArray, frameState.context);
-    const jobScheduler = frameState.jobScheduler;
-    if (!jobScheduler.execute(vertexBufferJob, JobType.BUFFER)) {
-      // Job scheduler is full. Try again next frame.
-      return false;
-    }
-    buffer = vertexBufferJob.buffer;
-  } else if (this._loadBuffer) {
-    buffer = createVertexBuffer(typedArray, frameState.context);
-  }
-
-  // Unload everything except the vertex buffer
-  this.unload();
-
-  this._buffer = buffer;
-  this._typedArray = this._loadTypedArray ? typedArray : undefined;
-  this._state = ResourceLoaderState.READY;
-  this._resourceCache.statistics.addGeometryLoader(this);
-  return true;
-};
-
-/**
- * Unloads the resource.
- * @private
- */
-GltfVertexBufferLoader.prototype.unload = function () {
-  if (defined(this._buffer)) {
-    this._buffer.destroy();
-  }
-
-  const resourceCache = this._resourceCache;
-
-  if (
-    defined(this._bufferViewLoader) &&
-    !this._bufferViewLoader.isDestroyed()
-  ) {
-    resourceCache.unload(this._bufferViewLoader);
-  }
-
-  if (defined(this._dracoLoader)) {
-    resourceCache.unload(this._dracoLoader);
-  }
-
-  if (defined(this._spzLoader)) {
-    resourceCache.unload(this._spzLoader);
-  }
-
-  this._bufferViewLoader = undefined;
-  this._dracoLoader = undefined;
-  this._spzLoader = undefined;
-  this._typedArray = undefined;
-  this._buffer = undefined;
-  this._gltf = undefined;
-  this._primitive = undefined;
-};
-
 export default GltfVertexBufferLoader;