water-management-system/frontend/node_modules/@cesium/engine/Source/Scene/GltfIndexBufferLoader.js

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;