@openhps/core/dist/cjs/three/loaders/DataTextureLoader.js

Open Hybrid Positioning System - Core component

"use strict";

Object.defineProperty(exports, "__esModule", {
  value: true
});
exports.DataTextureLoader = void 0;
var _constants = require("../constants.js");
var _FileLoader = require("./FileLoader.js");
var _DataTexture = require("../textures/DataTexture.js");
var _Loader = require("./Loader.js");
/**
 * Abstract base class for loading binary texture formats RGBE, EXR or TGA.
 * Textures are internally loaded via {@link FileLoader}.
 *
 * Derived classes have to implement the `parse()` method which holds the parsing
 * for the respective format.
 *
 * @abstract
 * @augments Loader
 */
class DataTextureLoader extends _Loader.Loader {
  /**
   * Constructs a new data texture loader.
   *
   * @param {LoadingManager} [manager] - The loading manager.
   */
  constructor(manager) {
    super(manager);
  }

  /**
   * Starts loading from the given URL and passes the loaded data texture
   * to the `onLoad()` callback. The method also returns a new texture object which can
   * directly be used for material creation. If you do it this way, the texture
   * may pop up in your scene once the respective loading process is finished.
   *
   * @param {string} url - The path/URL of the file to be loaded. This can also be a data URI.
   * @param {function(DataTexture)} onLoad - Executed when the loading process has been finished.
   * @param {onProgressCallback} onProgress - Executed while the loading is in progress.
   * @param {onErrorCallback} onError - Executed when errors occur.
   * @return {DataTexture} The data texture.
   */
  load(url, onLoad, onProgress, onError) {
    const scope = this;
    const texture = new _DataTexture.DataTexture();
    const loader = new _FileLoader.FileLoader(this.manager);
    loader.setResponseType('arraybuffer');
    loader.setRequestHeader(this.requestHeader);
    loader.setPath(this.path);
    loader.setWithCredentials(scope.withCredentials);
    loader.load(url, function (buffer) {
      let texData;
      try {
        texData = scope.parse(buffer);
      } catch (error) {
        if (onError !== undefined) {
          onError(error);
        } else {
          console.error(error);
          return;
        }
      }
      if (texData.image !== undefined) {
        texture.image = texData.image;
      } else if (texData.data !== undefined) {
        texture.image.width = texData.width;
        texture.image.height = texData.height;
        texture.image.data = texData.data;
      }
      texture.wrapS = texData.wrapS !== undefined ? texData.wrapS : _constants.ClampToEdgeWrapping;
      texture.wrapT = texData.wrapT !== undefined ? texData.wrapT : _constants.ClampToEdgeWrapping;
      texture.magFilter = texData.magFilter !== undefined ? texData.magFilter : _constants.LinearFilter;
      texture.minFilter = texData.minFilter !== undefined ? texData.minFilter : _constants.LinearFilter;
      texture.anisotropy = texData.anisotropy !== undefined ? texData.anisotropy : 1;
      if (texData.colorSpace !== undefined) {
        texture.colorSpace = texData.colorSpace;
      }
      if (texData.flipY !== undefined) {
        texture.flipY = texData.flipY;
      }
      if (texData.format !== undefined) {
        texture.format = texData.format;
      }
      if (texData.type !== undefined) {
        texture.type = texData.type;
      }
      if (texData.mipmaps !== undefined) {
        texture.mipmaps = texData.mipmaps;
        texture.minFilter = _constants.LinearMipmapLinearFilter; // presumably...
      }
      if (texData.mipmapCount === 1) {
        texture.minFilter = _constants.LinearFilter;
      }
      if (texData.generateMipmaps !== undefined) {
        texture.generateMipmaps = texData.generateMipmaps;
      }
      texture.needsUpdate = true;
      if (onLoad) onLoad(texture, texData);
    }, onProgress, onError);
    return texture;
  }
}

/**
 * Represents the result object type of the `parse()` method.
 *
 * @typedef {Object} DataTextureLoader~TexData
 * @property {Object} [image] - An object holding width, height and the texture data.
 * @property {number} [width] - The width of the base mip.
 * @property {number} [height] - The width of the base mip.
 * @property {TypedArray} [data] - The texture data.
 * @property {number} [format] - The texture format.
 * @property {number} [type] - The texture type.
 * @property {boolean} [flipY] - If set to `true`, the texture is flipped along the vertical axis when uploaded to the GPU.
 * @property {number} [wrapS=ClampToEdgeWrapping] - The wrapS value.
 * @property {number} [wrapT=ClampToEdgeWrapping] - The wrapT value.
 * @property {number} [anisotropy=1] - The anisotropy value.
 * @property {boolean} [generateMipmaps] - Whether to generate mipmaps or not.
 * @property {string} [colorSpace] - The color space.
 * @property {number} [magFilter] - The mag filter.
 * @property {number} [minFilter] - The min filter.
 * @property {Array<Object>} [mipmaps] - The mipmaps.
 **/
exports.DataTextureLoader = DataTextureLoader;