Add existing to tracked

node_modules/@cesium/engine/Source/Scene/GltfIndexBufferLoader.js

@@ -0,0 +1,404 @@
+import Check from "../Core/Check.js";
+import ComponentDatatype from "../Core/ComponentDatatype.js";
+import Frozen from "../Core/Frozen.js";
+import defined from "../Core/defined.js";
+import deprecationWarning from "../Core/deprecationWarning.js";
+import DeveloperError from "../Core/DeveloperError.js";
+import IndexDatatype from "../Core/IndexDatatype.js";
+import Buffer from "../Renderer/Buffer.js";
+import BufferUsage from "../Renderer/BufferUsage.js";
+import JobType from "./JobType.js";
+import ResourceLoader from "./ResourceLoader.js";
+import ResourceLoaderState from "./ResourceLoaderState.js";
+
+/**
+ * Loads an index buffer from a glTF accessor.
+ * <p>
+ * Implements the {@link ResourceLoader} interface.
+ * </p>
+ *
+ * @private
+ */
+class GltfIndexBufferLoader 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 {number} options.accessorId The accessor ID corresponding to the index buffer.
+   * @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 {object} [options.primitive] The primitive containing the Draco extension.
+   * @param {object} [options.draco] The Draco extension object.
+   * @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 the index buffer as a GPU index buffer.
+   * @param {boolean} [options.loadTypedArray=false] Load the index buffer as a typed array.
+   */
+  constructor(options) {
+    super();
+
+    options = options ?? Frozen.EMPTY_OBJECT;
+    const resourceCache = options.resourceCache;
+    const gltf = options.gltf;
+    const accessorId = options.accessorId;
+    const gltfResource = options.gltfResource;
+    const baseResource = options.baseResource;
+    const primitive = options.primitive;
+    const draco = options.draco;
+    const cacheKey = options.cacheKey;
+    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.number("options.accessorId", accessorId);
+    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.",
+      );
+    }
+    //>>includeEnd('debug');
+
+    const indexDatatype = gltf.accessors[accessorId].componentType;
+
+    this._resourceCache = resourceCache;
+    this._gltfResource = gltfResource;
+    this._baseResource = baseResource;
+    this._gltf = gltf;
+    this._accessorId = accessorId;
+    this._indexDatatype = indexDatatype;
+    this._primitive = primitive;
+    this._draco = draco;
+    this._cacheKey = cacheKey;
+    this._asynchronous = asynchronous;
+    this._loadBuffer = loadBuffer;
+    this._loadTypedArray = loadTypedArray;
+    this._bufferViewLoader = undefined;
+    this._dracoLoader = undefined;
+    this._typedArray = undefined;
+    this._buffer = undefined;
+    this._state = ResourceLoaderState.UNLOADED;
+    this._promise = undefined;
+  }
+
+  /**
+   * The cache key of the resource.
+   *
+   *
+   * @type {string}
+   * @readonly
+   * @private
+   */
+  get cacheKey() {
+    return this._cacheKey;
+  }
+
+  /**
+   * The index buffer. This is only defined when <code>loadBuffer</code> is true.
+   *
+   *
+   * @type {Buffer}
+   * @readonly
+   * @private
+   */
+  get buffer() {
+    return this._buffer;
+  }
+
+  /**
+   * The typed array containing indices. This is only defined when <code>loadTypedArray</code> is true.
+   *
+   *
+   * @type {Uint8Array|Uint16Array|Uint32Array}
+   * @readonly
+   * @private
+   */
+  get typedArray() {
+    return this._typedArray;
+  }
+
+  /**
+   * The index datatype after decode.
+   *
+   *
+   * @type {IndexDatatype}
+   * @readonly
+   * @private
+   */
+  get indexDatatype() {
+    return this._indexDatatype;
+  }
+
+  /**
+   * Loads the resource.
+   * @returns {Promise<GltfIndexBufferLoader>} A promise which resolves to the loader when the resource loading is completed.
+   * @private
+   */
+  async load() {
+    if (defined(this._promise)) {
+      return this._promise;
+    }
+
+    if (defined(this._draco)) {
+      this._promise = loadFromDraco(this);
+      return this._promise;
+    }
+
+    this._promise = loadFromBufferView(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;
+    }
+
+    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;
+  }
+
+  /**
+   * 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);
+    }
+
+    this._bufferViewLoader = undefined;
+    this._dracoLoader = undefined;
+    this._typedArray = undefined;
+    this._buffer = undefined;
+    this._gltf = undefined;
+    this._primitive = undefined;
+  }
+}
+
+class CreateIndexBufferJob {
+  constructor() {
+    this.typedArray = undefined;
+    this.indexDatatype = undefined;
+    this.context = undefined;
+    this.buffer = undefined;
+  }
+
+  set(typedArray, indexDatatype, context) {
+    this.typedArray = typedArray;
+    this.indexDatatype = indexDatatype;
+    this.context = context;
+  }
+
+  execute() {
+    this.buffer = createIndexBuffer(
+      this.typedArray,
+      this.indexDatatype,
+      this.context,
+    );
+  }
+}
+
+function createIndexBuffer(typedArray, indexDatatype, context) {
+  const buffer = Buffer.createIndexBuffer({
+    typedArray: typedArray,
+    context: context,
+    usage: BufferUsage.STATIC_DRAW,
+    indexDatatype: indexDatatype,
+  });
+  buffer.vertexArrayDestroyable = false;
+  return buffer;
+}
+
+const scratchIndexBufferJob = new CreateIndexBufferJob();
+
+async function loadFromDraco(indexBufferLoader) {
+  indexBufferLoader._state = ResourceLoaderState.LOADING;
+  const resourceCache = indexBufferLoader._resourceCache;
+
+  try {
+    const dracoLoader = resourceCache.getDracoLoader({
+      gltf: indexBufferLoader._gltf,
+      primitive: indexBufferLoader._primitive,
+      draco: indexBufferLoader._draco,
+      gltfResource: indexBufferLoader._gltfResource,
+      baseResource: indexBufferLoader._baseResource,
+    });
+    indexBufferLoader._dracoLoader = dracoLoader;
+    await dracoLoader.load();
+
+    if (indexBufferLoader.isDestroyed()) {
+      return;
+    }
+
+    // Now wait for process() to run to finish loading
+    indexBufferLoader._state = ResourceLoaderState.LOADED;
+    return indexBufferLoader;
+  } catch (error) {
+    if (indexBufferLoader.isDestroyed()) {
+      return;
+    }
+
+    handleError(indexBufferLoader, error);
+  }
+}
+
+async function loadFromBufferView(indexBufferLoader) {
+  const gltf = indexBufferLoader._gltf;
+  const accessorId = indexBufferLoader._accessorId;
+  const accessor = gltf.accessors[accessorId];
+  const bufferViewId = accessor.bufferView;
+
+  indexBufferLoader._state = ResourceLoaderState.LOADING;
+  const resourceCache = indexBufferLoader._resourceCache;
+  try {
+    const bufferViewLoader = resourceCache.getBufferViewLoader({
+      gltf: gltf,
+      bufferViewId: bufferViewId,
+      gltfResource: indexBufferLoader._gltfResource,
+      baseResource: indexBufferLoader._baseResource,
+    });
+    indexBufferLoader._bufferViewLoader = bufferViewLoader;
+
+    await bufferViewLoader.load();
+    if (indexBufferLoader.isDestroyed()) {
+      return;
+    }
+
+    const bufferViewTypedArray = bufferViewLoader.typedArray;
+    indexBufferLoader._typedArray = createIndicesTypedArray(
+      indexBufferLoader,
+      bufferViewTypedArray,
+    );
+    indexBufferLoader._state = ResourceLoaderState.PROCESSING;
+    return indexBufferLoader;
+  } catch (error) {
+    if (indexBufferLoader.isDestroyed()) {
+      return;
+    }
+
+    handleError(indexBufferLoader, error);
+  }
+}
+
+function createIndicesTypedArray(indexBufferLoader, bufferViewTypedArray) {
+  const gltf = indexBufferLoader._gltf;
+  const accessorId = indexBufferLoader._accessorId;
+  const accessor = gltf.accessors[accessorId];
+  const count = accessor.count;
+  const indexDatatype = accessor.componentType;
+  const indexSize = IndexDatatype.getSizeInBytes(indexDatatype);
+
+  let arrayBuffer = bufferViewTypedArray.buffer;
+  let byteOffset = bufferViewTypedArray.byteOffset + accessor.byteOffset;
+
+  if (byteOffset % indexSize !== 0) {
+    const byteLength = count * indexSize;
+    const view = new Uint8Array(arrayBuffer, byteOffset, byteLength);
+    const copy = new Uint8Array(view);
+    arrayBuffer = copy.buffer;
+    byteOffset = 0;
+    deprecationWarning(
+      "index-buffer-unaligned",
+      `The index array is not aligned to a ${indexSize}-byte boundary.`,
+    );
+  }
+
+  let typedArray;
+  if (indexDatatype === IndexDatatype.UNSIGNED_BYTE) {
+    typedArray = new Uint8Array(arrayBuffer, byteOffset, count);
+  } else if (indexDatatype === IndexDatatype.UNSIGNED_SHORT) {
+    typedArray = new Uint16Array(arrayBuffer, byteOffset, count);
+  } else if (indexDatatype === IndexDatatype.UNSIGNED_INT) {
+    typedArray = new Uint32Array(arrayBuffer, byteOffset, count);
+  }
+
+  return typedArray;
+}
+
+function handleError(indexBufferLoader, error) {
+  indexBufferLoader.unload();
+  indexBufferLoader._state = ResourceLoaderState.FAILED;
+  const errorMessage = "Failed to load index buffer";
+  throw indexBufferLoader.getError(errorMessage, error);
+}
+
+export default GltfIndexBufferLoader;