water-management-system/frontend/node_modules/@cesium/engine/Source/Scene/GltfDracoLoader.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 DracoLoader from "./DracoLoader.js";
import ResourceLoader from "./ResourceLoader.js";
import ResourceLoaderState from "./ResourceLoaderState.js";
import VertexAttributeSemantic from "./VertexAttributeSemantic.js";

/**
 * Load a draco buffer from a glTF.
 * <p>
 * Implements the {@link ResourceLoader} interface.
 * </p>
 *
 * @private
 */
class GltfDracoLoader 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.primitive The primitive containing the Draco extension.
   * @param {object} options.draco The Draco extension 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 {string} [options.cacheKey] The cache key of the resource.
   */
  constructor(options) {
    super();

    options = options ?? Frozen.EMPTY_OBJECT;
    const resourceCache = options.resourceCache;
    const gltf = options.gltf;
    const primitive = options.primitive;
    const draco = options.draco;
    const gltfResource = options.gltfResource;
    const baseResource = options.baseResource;
    const cacheKey = options.cacheKey;

    //>>includeStart('debug', pragmas.debug);
    Check.typeOf.func("options.resourceCache", resourceCache);
    Check.typeOf.object("options.gltf", gltf);
    Check.typeOf.object("options.primitive", primitive);
    Check.typeOf.object("options.draco", draco);
    Check.typeOf.object("options.gltfResource", gltfResource);
    Check.typeOf.object("options.baseResource", baseResource);
    //>>includeEnd('debug');

    this._resourceCache = resourceCache;
    this._gltfResource = gltfResource;
    this._baseResource = baseResource;
    this._gltf = gltf;
    this._primitive = primitive;
    this._draco = draco;
    this._cacheKey = cacheKey;
    this._bufferViewLoader = undefined;
    this._bufferViewTypedArray = undefined;
    this._decodePromise = undefined;
    this._decodedData = undefined;
    this._state = ResourceLoaderState.UNLOADED;
    this._promise = undefined;
    this._dracoError = undefined;
  }

  /**
   * The cache key of the resource.
   *
   *
   * @type {string}
   * @readonly
   * @private
   */
  get cacheKey() {
    return this._cacheKey;
  }

  /**
   * The decoded data.
   *
   *
   * @type {object}
   * @readonly
   * @private
   */
  get decodedData() {
    return this._decodedData;
  }

  /**
   * 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;
    }

    this._state = ResourceLoaderState.LOADING;
    this._promise = loadResources(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.PROCESSING) {
      return false;
    }

    if (defined(this._dracoError)) {
      handleError(this, this._dracoError);
    }

    if (!defined(this._bufferViewTypedArray)) {
      // Not ready to decode the Draco buffer
      return false;
    }

    if (defined(this._decodePromise)) {
      // Currently decoding
      return false;
    }

    const draco = this._draco;
    const primitive = this._primitive;
    const gltf = this._gltf;
    const bufferViews = gltf.bufferViews;
    const bufferViewId = draco.bufferView;
    const bufferView = bufferViews[bufferViewId];
    const compressedAttributes = draco.attributes;

    // Skip de-quantization transform if present for floating point attributes.
    // They will stay quantized in memory and be dequantized in the shader.
    const attributesToSkipTransform = [];

    for (const attribute in primitive.attributes) {
      if (primitive.attributes.hasOwnProperty(attribute)) {
        const dracoAttributeType = getDracoAttributeType(attribute);
        if (defined(dracoAttributeType)) {
          const accessor = gltf.accessors[primitive.attributes[attribute]];
          if (accessor.componentType === ComponentDatatype.FLOAT) {
            if (!attributesToSkipTransform.includes(dracoAttributeType)) {
              attributesToSkipTransform.push(dracoAttributeType);
            }
          }
        }
      }
    }

    const decodeOptions = {
      // Need to make a copy of the typed array otherwise the underlying
      // ArrayBuffer may be accessed on both the worker and the main thread. This
      // leads to errors such as "ArrayBuffer at index 0 is already detached".
      // PERFORMANCE_IDEA: Look into SharedArrayBuffer to get around this.
      array: new Uint8Array(this._bufferViewTypedArray),
      bufferView: bufferView,
      compressedAttributes: compressedAttributes,
      dequantizeInShader: true,
      attributesToSkipTransform: attributesToSkipTransform,
    };

    const decodePromise = DracoLoader.decodeBufferView(decodeOptions);

    if (!defined(decodePromise)) {
      // Cannot schedule task this frame
      return false;
    }

    this._decodePromise = processDecode(this, decodePromise);
  }

  /**
   * Unloads the resource.
   * @private
   */
  unload() {
    if (defined(this._bufferViewLoader)) {
      this._resourceCache.unload(this._bufferViewLoader);
    }

    this._bufferViewLoader = undefined;
    this._bufferViewTypedArray = undefined;
    this._decodedData = undefined;
    this._gltf = undefined;
    this._primitive = undefined;
  }
}

async function loadResources(loader) {
  const resourceCache = loader._resourceCache;
  try {
    const bufferViewLoader = resourceCache.getBufferViewLoader({
      gltf: loader._gltf,
      bufferViewId: loader._draco.bufferView,
      gltfResource: loader._gltfResource,
      baseResource: loader._baseResource,
    });
    loader._bufferViewLoader = bufferViewLoader;
    await bufferViewLoader.load();

    if (loader.isDestroyed()) {
      return;
    }

    loader._bufferViewTypedArray = bufferViewLoader.typedArray;
    loader._state = ResourceLoaderState.PROCESSING;
    return loader;
  } catch (error) {
    if (loader.isDestroyed()) {
      return;
    }

    handleError(loader, error);
  }
}

function handleError(dracoLoader, error) {
  dracoLoader.unload();
  dracoLoader._state = ResourceLoaderState.FAILED;
  const errorMessage = "Failed to load Draco";
  throw dracoLoader.getError(errorMessage, error);
}

async function processDecode(loader, decodePromise) {
  try {
    const results = await decodePromise;
    if (loader.isDestroyed()) {
      return;
    }

    // Unload everything except the decoded data
    loader.unload();

    loader._decodedData = {
      indices: results.indexArray,
      vertexAttributes: results.attributeData,
    };
    loader._state = ResourceLoaderState.READY;
    return loader._baseResource;
  } catch (error) {
    if (loader.isDestroyed()) {
      return;
    }

    // Capture this error so it can be thrown on the next `process` call
    loader._dracoError = error;
  }
}

const SemanticToDracoAttributeType = {};
SemanticToDracoAttributeType[VertexAttributeSemantic.POSITION] = "POSITION";
SemanticToDracoAttributeType[VertexAttributeSemantic.NORMAL] = "NORMAL";
SemanticToDracoAttributeType[VertexAttributeSemantic.COLOR] = "COLOR";
SemanticToDracoAttributeType[VertexAttributeSemantic.TEXCOORD] = "TEX_COORD";

function getDracoAttributeType(attribute) {
  for (const semantic in SemanticToDracoAttributeType) {
    if (SemanticToDracoAttributeType.hasOwnProperty(semantic)) {
      if (attribute.startsWith(semantic)) {
        return SemanticToDracoAttributeType[semantic];
      }
    }
  }

  return undefined;
}

export default GltfDracoLoader;