hpg-r3f-model-scene/lib/loaders/KTXLoader/BasisTextureLoader.js

Pretty Footer react component used in ant.design

"use strict";

var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
Object.defineProperty(exports, "__esModule", {
  value: true
});
exports.BasisTextureLoader = void 0;
var _slicedToArray2 = _interopRequireDefault(require("@babel/runtime/helpers/slicedToArray"));
var _objectSpread2 = _interopRequireDefault(require("@babel/runtime/helpers/objectSpread2"));
var _classCallCheck2 = _interopRequireDefault(require("@babel/runtime/helpers/classCallCheck"));
var _createClass2 = _interopRequireDefault(require("@babel/runtime/helpers/createClass"));
var _inherits2 = _interopRequireDefault(require("@babel/runtime/helpers/inherits"));
var _createSuper2 = _interopRequireDefault(require("@babel/runtime/helpers/createSuper"));
var _three = require("three");
/**
 * Loader for Basis Universal GPU Texture Codec.
 *
 * Basis Universal is a "supercompressed" GPU texture and texture video
 * compression system that outputs a highly compressed intermediate file format
 * (.basis) that can be quickly transcoded to a wide variety of GPU texture
 * compression formats.
 *
 * This loader parallelizes the transcoding process across a configurable number
 * of web workers, before transferring the transcoded compressed texture back
 * to the main thread.
 */

var _taskCache = new WeakMap();
var BasisTextureLoader = /*#__PURE__*/function (_Loader) {
  (0, _inherits2.default)(BasisTextureLoader, _Loader);
  var _super = (0, _createSuper2.default)(BasisTextureLoader);
  function BasisTextureLoader(manager) {
    var _this;
    (0, _classCallCheck2.default)(this, BasisTextureLoader);
    _this = _super.call(this, manager);
    _this.transcoderPath = '';
    _this.transcoderBinary = null;
    _this.transcoderPending = null;
    _this.workerLimit = 4;
    _this.workerPool = [];
    _this.workerNextTaskID = 1;
    _this.workerSourceURL = '';
    _this.workerConfig = null;
    return _this;
  }
  (0, _createClass2.default)(BasisTextureLoader, [{
    key: "setTranscoderPath",
    value: function setTranscoderPath(path) {
      this.transcoderPath = path;
      return this;
    }
  }, {
    key: "setWorkerLimit",
    value: function setWorkerLimit(workerLimit) {
      this.workerLimit = workerLimit;
      return this;
    }
  }, {
    key: "detectSupport",
    value: function detectSupport(renderer) {
      this.workerConfig = {
        astcSupported: renderer.extensions.has('WEBGL_compressed_texture_astc'),
        etc1Supported: renderer.extensions.has('WEBGL_compressed_texture_etc1'),
        etc2Supported: renderer.extensions.has('WEBGL_compressed_texture_etc'),
        dxtSupported: renderer.extensions.has('WEBGL_compressed_texture_s3tc'),
        bptcSupported: renderer.extensions.has('EXT_texture_compression_bptc'),
        pvrtcSupported: renderer.extensions.has('WEBGL_compressed_texture_pvrtc') || renderer.extensions.has('WEBKIT_WEBGL_compressed_texture_pvrtc')
      };
      return this;
    }
  }, {
    key: "load",
    value: function load(url, onLoad, onProgress, onError) {
      var _this2 = this;
      var loader = new _three.FileLoader(this.manager);
      loader.setResponseType('arraybuffer');
      loader.setWithCredentials(this.withCredentials);
      var texture = new _three.CompressedTexture();
      loader.load(url, function (buffer) {
        // Check for an existing task using this buffer. A transferred buffer cannot be transferred
        // again from this thread.
        if (_taskCache.has(buffer)) {
          var cachedTask = _taskCache.get(buffer);
          return cachedTask.promise.then(onLoad).catch(onError);
        }
        _this2._createTexture([buffer]).then(function (_texture) {
          texture.copy(_texture);
          texture.needsUpdate = true;
          if (onLoad) onLoad(texture);
        }).catch(onError);
      }, onProgress, onError);
      return texture;
    }

    /** Low-level transcoding API, exposed for use by KTX2Loader. */
  }, {
    key: "parseInternalAsync",
    value: function parseInternalAsync(options) {
      var levels = options.levels;
      var buffers = new Set();
      for (var i = 0; i < levels.length; i++) {
        buffers.add(levels[i].data.buffer);
      }
      return this._createTexture(Array.from(buffers), (0, _objectSpread2.default)((0, _objectSpread2.default)({}, options), {}, {
        lowLevel: true
      }));
    }

    /**
     * @param {ArrayBuffer[]} buffers
     * @param {object?} config
     * @return {Promise<CompressedTexture>}
     */
  }, {
    key: "_createTexture",
    value: function _createTexture(buffers) {
      var _this3 = this;
      var config = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
      var worker;
      var taskID;
      var taskConfig = config;
      var taskCost = 0;
      for (var i = 0; i < buffers.length; i++) {
        taskCost += buffers[i].byteLength;
      }
      var texturePending = this._allocateWorker(taskCost).then(function (_worker) {
        worker = _worker;
        taskID = _this3.workerNextTaskID++;
        return new Promise(function (resolve, reject) {
          worker._callbacks[taskID] = {
            resolve: resolve,
            reject: reject
          };
          worker.postMessage({
            type: 'transcode',
            id: taskID,
            buffers: buffers,
            taskConfig: taskConfig
          }, buffers);
        });
      }).then(function (message) {
        var mipmaps = message.mipmaps,
          width = message.width,
          height = message.height,
          format = message.format;
        var texture = new _three.CompressedTexture(mipmaps, width, height, format, _three.UnsignedByteType);
        texture.minFilter = mipmaps.length === 1 ? _three.LinearFilter : _three.LinearMipmapLinearFilter;
        texture.magFilter = _three.LinearFilter;
        texture.generateMipmaps = false;
        texture.needsUpdate = true;
        return texture;
      });

      // Note: replaced '.finally()' with '.catch().then()' block - iOS 11 support (#19416)
      texturePending.catch(function () {
        return true;
      }).then(function () {
        if (worker && taskID) {
          worker._taskLoad -= taskCost;
          delete worker._callbacks[taskID];
        }
      });

      // Cache the task result.
      _taskCache.set(buffers[0], {
        promise: texturePending
      });
      return texturePending;
    }
  }, {
    key: "_initTranscoder",
    value: function _initTranscoder() {
      var _this4 = this;
      if (!this.transcoderPending) {
        // Load transcoder wrapper.
        var jsLoader = new _three.FileLoader(this.manager);
        jsLoader.setPath(this.transcoderPath);
        jsLoader.setWithCredentials(this.withCredentials);
        var jsContent = new Promise(function (resolve, reject) {
          jsLoader.load('basis_transcoder.js', resolve, undefined, reject);
        });

        // Load transcoder WASM binary.
        var binaryLoader = new _three.FileLoader(this.manager);
        binaryLoader.setPath(this.transcoderPath);
        binaryLoader.setResponseType('arraybuffer');
        binaryLoader.setWithCredentials(this.withCredentials);
        var binaryContent = new Promise(function (resolve, reject) {
          binaryLoader.load('basis_transcoder.wasm', resolve, undefined, reject);
        });
        this.transcoderPending = Promise.all([jsContent, binaryContent]).then(function (_ref) {
          var _ref2 = (0, _slicedToArray2.default)(_ref, 2),
            jsContent = _ref2[0],
            binaryContent = _ref2[1];
          var fn = BasisTextureLoader.BasisWorker.toString();
          var body = ['/* constants */', 'let _EngineFormat = ' + JSON.stringify(BasisTextureLoader.EngineFormat), 'let _TranscoderFormat = ' + JSON.stringify(BasisTextureLoader.TranscoderFormat), 'let _BasisFormat = ' + JSON.stringify(BasisTextureLoader.BasisFormat), '/* basis_transcoder.js */', jsContent, '/* worker */', fn.substring(fn.indexOf('{') + 1, fn.lastIndexOf('}'))].join('\n');
          _this4.workerSourceURL = URL.createObjectURL(new Blob([body]));
          _this4.transcoderBinary = binaryContent;
        });
      }
      return this.transcoderPending;
    }
  }, {
    key: "_allocateWorker",
    value: function _allocateWorker(taskCost) {
      var _this5 = this;
      return this._initTranscoder().then(function () {
        if (_this5.workerPool.length < _this5.workerLimit) {
          var _worker2 = new Worker(_this5.workerSourceURL);
          _worker2._callbacks = {};
          _worker2._taskLoad = 0;
          _worker2.postMessage({
            type: 'init',
            config: _this5.workerConfig,
            transcoderBinary: _this5.transcoderBinary
          });
          _worker2.onmessage = function (e) {
            var message = e.data;
            switch (message.type) {
              case 'transcode':
                _worker2._callbacks[message.id].resolve(message);
                break;
              case 'error':
                _worker2._callbacks[message.id].reject(message);
                break;
              default:
                console.error('THREE.BasisTextureLoader: Unexpected message, "' + message.type + '"');
            }
          };
          _this5.workerPool.push(_worker2);
        } else {
          _this5.workerPool.sort(function (a, b) {
            return a._taskLoad > b._taskLoad ? -1 : 1;
          });
        }
        var worker = _this5.workerPool[_this5.workerPool.length - 1];
        worker._taskLoad += taskCost;
        return worker;
      });
    }
  }, {
    key: "dispose",
    value: function dispose() {
      for (var i = 0; i < this.workerPool.length; i++) {
        this.workerPool[i].terminate();
      }
      this.workerPool.length = 0;
      return this;
    }
  }]);
  return BasisTextureLoader;
}(_three.Loader);
/* CONSTANTS */
exports.BasisTextureLoader = BasisTextureLoader;
BasisTextureLoader.BasisFormat = {
  ETC1S: 0,
  UASTC_4x4: 1
};
BasisTextureLoader.TranscoderFormat = {
  ETC1: 0,
  ETC2: 1,
  BC1: 2,
  BC3: 3,
  BC4: 4,
  BC5: 5,
  BC7_M6_OPAQUE_ONLY: 6,
  BC7_M5: 7,
  PVRTC1_4_RGB: 8,
  PVRTC1_4_RGBA: 9,
  ASTC_4x4: 10,
  ATC_RGB: 11,
  ATC_RGBA_INTERPOLATED_ALPHA: 12,
  RGBA32: 13,
  RGB565: 14,
  BGR565: 15,
  RGBA4444: 16
};
BasisTextureLoader.EngineFormat = {
  RGBAFormat: _three.RGBAFormat,
  RGBA_ASTC_4x4_Format: _three.RGBA_ASTC_4x4_Format,
  RGBA_BPTC_Format: _three.RGBA_BPTC_Format,
  RGBA_ETC2_EAC_Format: _three.RGBA_ETC2_EAC_Format,
  RGBA_PVRTC_4BPPV1_Format: _three.RGBA_PVRTC_4BPPV1_Format,
  RGBA_S3TC_DXT5_Format: _three.RGBA_S3TC_DXT5_Format,
  RGB_ETC1_Format: _three.RGB_ETC1_Format,
  RGB_ETC2_Format: _three.RGB_ETC2_Format,
  RGB_PVRTC_4BPPV1_Format: _three.RGB_PVRTC_4BPPV1_Format,
  RGB_S3TC_DXT1_Format: _three.RGB_S3TC_DXT1_Format
};

/* WEB WORKER */

BasisTextureLoader.BasisWorker = function () {
  var config;
  var transcoderPending;
  var BasisModule;
  var EngineFormat = _EngineFormat; // eslint-disable-line no-undef
  var TranscoderFormat = _TranscoderFormat; // eslint-disable-line no-undef
  var BasisFormat = _BasisFormat; // eslint-disable-line no-undef

  onmessage = function onmessage(e) {
    var message = e.data;
    switch (message.type) {
      case 'init':
        config = message.config;
        init(message.transcoderBinary);
        break;
      case 'transcode':
        transcoderPending.then(function () {
          try {
            var _ref3 = message.taskConfig.lowLevel ? transcodeLowLevel(message.taskConfig) : transcode(message.buffers[0]),
              width = _ref3.width,
              height = _ref3.height,
              hasAlpha = _ref3.hasAlpha,
              mipmaps = _ref3.mipmaps,
              format = _ref3.format;
            var buffers = [];
            for (var i = 0; i < mipmaps.length; ++i) {
              buffers.push(mipmaps[i].data.buffer);
            }
            self.postMessage({
              type: 'transcode',
              id: message.id,
              width: width,
              height: height,
              hasAlpha: hasAlpha,
              mipmaps: mipmaps,
              format: format
            }, buffers);
          } catch (error) {
            console.error(error);
            self.postMessage({
              type: 'error',
              id: message.id,
              error: error.message
            });
          }
        });
        break;
    }
  };
  function init(wasmBinary) {
    transcoderPending = new Promise(function (resolve) {
      BasisModule = {
        wasmBinary: wasmBinary,
        onRuntimeInitialized: resolve
      };
      BASIS(BasisModule); // eslint-disable-line no-undef
    }).then(function () {
      BasisModule.initializeBasis();
    });
  }
  function transcodeLowLevel(taskConfig) {
    var basisFormat = taskConfig.basisFormat,
      width = taskConfig.width,
      height = taskConfig.height,
      hasAlpha = taskConfig.hasAlpha;
    var _getTranscoderFormat = getTranscoderFormat(basisFormat, width, height, hasAlpha),
      transcoderFormat = _getTranscoderFormat.transcoderFormat,
      engineFormat = _getTranscoderFormat.engineFormat;
    var blockByteLength = BasisModule.getBytesPerBlockOrPixel(transcoderFormat);
    assert(BasisModule.isFormatSupported(transcoderFormat), 'THREE.BasisTextureLoader: Unsupported format.');
    var mipmaps = [];
    if (basisFormat === BasisFormat.ETC1S) {
      var transcoder = new BasisModule.LowLevelETC1SImageTranscoder();
      var _taskConfig$globalDat = taskConfig.globalData,
        endpointCount = _taskConfig$globalDat.endpointCount,
        endpointsData = _taskConfig$globalDat.endpointsData,
        selectorCount = _taskConfig$globalDat.selectorCount,
        selectorsData = _taskConfig$globalDat.selectorsData,
        tablesData = _taskConfig$globalDat.tablesData;
      try {
        var ok;
        ok = transcoder.decodePalettes(endpointCount, endpointsData, selectorCount, selectorsData);
        assert(ok, 'THREE.BasisTextureLoader: decodePalettes() failed.');
        ok = transcoder.decodeTables(tablesData);
        assert(ok, 'THREE.BasisTextureLoader: decodeTables() failed.');
        for (var i = 0; i < taskConfig.levels.length; i++) {
          var level = taskConfig.levels[i];
          var imageDesc = taskConfig.globalData.imageDescs[i];
          var dstByteLength = getTranscodedImageByteLength(transcoderFormat, level.width, level.height);
          var dst = new Uint8Array(dstByteLength);
          ok = transcoder.transcodeImage(transcoderFormat, dst, dstByteLength / blockByteLength, level.data, getWidthInBlocks(transcoderFormat, level.width), getHeightInBlocks(transcoderFormat, level.height), level.width, level.height, level.index, imageDesc.rgbSliceByteOffset, imageDesc.rgbSliceByteLength, imageDesc.alphaSliceByteOffset, imageDesc.alphaSliceByteLength, imageDesc.imageFlags, hasAlpha, false, 0, 0);
          assert(ok, 'THREE.BasisTextureLoader: transcodeImage() failed for level ' + level.index + '.');
          mipmaps.push({
            data: dst,
            width: level.width,
            height: level.height
          });
        }
      } finally {
        transcoder.delete();
      }
    } else {
      for (var _i = 0; _i < taskConfig.levels.length; _i++) {
        var _level = taskConfig.levels[_i];
        var _dstByteLength = getTranscodedImageByteLength(transcoderFormat, _level.width, _level.height);
        var _dst = new Uint8Array(_dstByteLength);
        var _ok = BasisModule.transcodeUASTCImage(transcoderFormat, _dst, _dstByteLength / blockByteLength, _level.data, getWidthInBlocks(transcoderFormat, _level.width), getHeightInBlocks(transcoderFormat, _level.height), _level.width, _level.height, _level.index, 0, _level.data.byteLength, 0, hasAlpha, false, 0, 0, -1, -1);
        assert(_ok, 'THREE.BasisTextureLoader: transcodeUASTCImage() failed for level ' + _level.index + '.');
        mipmaps.push({
          data: _dst,
          width: _level.width,
          height: _level.height
        });
      }
    }
    return {
      width: width,
      height: height,
      hasAlpha: hasAlpha,
      mipmaps: mipmaps,
      format: engineFormat
    };
  }
  function transcode(buffer) {
    var basisFile = new BasisModule.BasisFile(new Uint8Array(buffer));
    var basisFormat = basisFile.isUASTC() ? BasisFormat.UASTC_4x4 : BasisFormat.ETC1S;
    var width = basisFile.getImageWidth(0, 0);
    var height = basisFile.getImageHeight(0, 0);
    var levels = basisFile.getNumLevels(0);
    var hasAlpha = basisFile.getHasAlpha();
    function cleanup() {
      basisFile.close();
      basisFile.delete();
    }
    var _getTranscoderFormat2 = getTranscoderFormat(basisFormat, width, height, hasAlpha),
      transcoderFormat = _getTranscoderFormat2.transcoderFormat,
      engineFormat = _getTranscoderFormat2.engineFormat;
    if (!width || !height || !levels) {
      cleanup();
      throw new Error('THREE.BasisTextureLoader:	Invalid texture');
    }
    if (!basisFile.startTranscoding()) {
      cleanup();
      throw new Error('THREE.BasisTextureLoader: .startTranscoding failed');
    }
    var mipmaps = [];
    for (var mip = 0; mip < levels; mip++) {
      var mipWidth = basisFile.getImageWidth(0, mip);
      var mipHeight = basisFile.getImageHeight(0, mip);
      var dst = new Uint8Array(basisFile.getImageTranscodedSizeInBytes(0, mip, transcoderFormat));
      var status = basisFile.transcodeImage(dst, 0, mip, transcoderFormat, 0, hasAlpha);
      if (!status) {
        cleanup();
        throw new Error('THREE.BasisTextureLoader: .transcodeImage failed.');
      }
      mipmaps.push({
        data: dst,
        width: mipWidth,
        height: mipHeight
      });
    }
    cleanup();
    return {
      width: width,
      height: height,
      hasAlpha: hasAlpha,
      mipmaps: mipmaps,
      format: engineFormat
    };
  }

  //

  // Optimal choice of a transcoder target format depends on the Basis format (ETC1S or UASTC),
  // device capabilities, and texture dimensions. The list below ranks the formats separately
  // for ETC1S and UASTC.
  //
  // In some cases, transcoding UASTC to RGBA32 might be preferred for higher quality (at
  // significant memory cost) compared to ETC1/2, BC1/3, and PVRTC. The transcoder currently
  // chooses RGBA32 only as a last resort and does not expose that option to the caller.
  var FORMAT_OPTIONS = [{
    if: 'astcSupported',
    basisFormat: [BasisFormat.UASTC_4x4],
    transcoderFormat: [TranscoderFormat.ASTC_4x4, TranscoderFormat.ASTC_4x4],
    engineFormat: [EngineFormat.RGBA_ASTC_4x4_Format, EngineFormat.RGBA_ASTC_4x4_Format],
    priorityETC1S: Infinity,
    priorityUASTC: 1,
    needsPowerOfTwo: false
  }, {
    if: 'bptcSupported',
    basisFormat: [BasisFormat.ETC1S, BasisFormat.UASTC_4x4],
    transcoderFormat: [TranscoderFormat.BC7_M5, TranscoderFormat.BC7_M5],
    engineFormat: [EngineFormat.RGBA_BPTC_Format, EngineFormat.RGBA_BPTC_Format],
    priorityETC1S: 3,
    priorityUASTC: 2,
    needsPowerOfTwo: false
  }, {
    if: 'dxtSupported',
    basisFormat: [BasisFormat.ETC1S, BasisFormat.UASTC_4x4],
    transcoderFormat: [TranscoderFormat.BC1, TranscoderFormat.BC3],
    engineFormat: [EngineFormat.RGB_S3TC_DXT1_Format, EngineFormat.RGBA_S3TC_DXT5_Format],
    priorityETC1S: 4,
    priorityUASTC: 5,
    needsPowerOfTwo: false
  }, {
    if: 'etc2Supported',
    basisFormat: [BasisFormat.ETC1S, BasisFormat.UASTC_4x4],
    transcoderFormat: [TranscoderFormat.ETC1, TranscoderFormat.ETC2],
    engineFormat: [EngineFormat.RGB_ETC2_Format, EngineFormat.RGBA_ETC2_EAC_Format],
    priorityETC1S: 1,
    priorityUASTC: 3,
    needsPowerOfTwo: false
  }, {
    if: 'etc1Supported',
    basisFormat: [BasisFormat.ETC1S, BasisFormat.UASTC_4x4],
    transcoderFormat: [TranscoderFormat.ETC1, TranscoderFormat.ETC1],
    engineFormat: [EngineFormat.RGB_ETC1_Format, EngineFormat.RGB_ETC1_Format],
    priorityETC1S: 2,
    priorityUASTC: 4,
    needsPowerOfTwo: false
  }, {
    if: 'pvrtcSupported',
    basisFormat: [BasisFormat.ETC1S, BasisFormat.UASTC_4x4],
    transcoderFormat: [TranscoderFormat.PVRTC1_4_RGB, TranscoderFormat.PVRTC1_4_RGBA],
    engineFormat: [EngineFormat.RGB_PVRTC_4BPPV1_Format, EngineFormat.RGBA_PVRTC_4BPPV1_Format],
    priorityETC1S: 5,
    priorityUASTC: 6,
    needsPowerOfTwo: true
  }];
  var ETC1S_OPTIONS = FORMAT_OPTIONS.sort(function (a, b) {
    return a.priorityETC1S - b.priorityETC1S;
  });
  var UASTC_OPTIONS = FORMAT_OPTIONS.sort(function (a, b) {
    return a.priorityUASTC - b.priorityUASTC;
  });
  function getTranscoderFormat(basisFormat, width, height, hasAlpha) {
    var transcoderFormat;
    var engineFormat;
    var options = basisFormat === BasisFormat.ETC1S ? ETC1S_OPTIONS : UASTC_OPTIONS;
    for (var i = 0; i < options.length; i++) {
      var opt = options[i];
      if (!config[opt.if]) continue;
      if (!opt.basisFormat.includes(basisFormat)) continue;
      if (opt.needsPowerOfTwo && !(isPowerOfTwo(width) && isPowerOfTwo(height))) continue;
      transcoderFormat = opt.transcoderFormat[hasAlpha ? 1 : 0];
      engineFormat = opt.engineFormat[hasAlpha ? 1 : 0];
      return {
        transcoderFormat: transcoderFormat,
        engineFormat: engineFormat
      };
    }
    console.warn('THREE.BasisTextureLoader: No suitable compressed texture format found. Decoding to RGBA32.');
    transcoderFormat = TranscoderFormat.RGBA32;
    engineFormat = EngineFormat.RGBAFormat;
    return {
      transcoderFormat: transcoderFormat,
      engineFormat: engineFormat
    };
  }
  function assert(ok, message) {
    if (!ok) throw new Error(message);
  }
  function getWidthInBlocks(transcoderFormat, width) {
    return Math.ceil(width / BasisModule.getFormatBlockWidth(transcoderFormat));
  }
  function getHeightInBlocks(transcoderFormat, height) {
    return Math.ceil(height / BasisModule.getFormatBlockHeight(transcoderFormat));
  }
  function getTranscodedImageByteLength(transcoderFormat, width, height) {
    var blockByteLength = BasisModule.getBytesPerBlockOrPixel(transcoderFormat);
    if (BasisModule.formatIsUncompressed(transcoderFormat)) {
      return width * height * blockByteLength;
    }
    if (transcoderFormat === TranscoderFormat.PVRTC1_4_RGB || transcoderFormat === TranscoderFormat.PVRTC1_4_RGBA) {
      // GL requires extra padding for very small textures:
      // https://www.khronos.org/registry/OpenGL/extensions/IMG/IMG_texture_compression_pvrtc.txt
      var paddedWidth = width + 3 & ~3;
      var paddedHeight = height + 3 & ~3;
      return (Math.max(8, paddedWidth) * Math.max(8, paddedHeight) * 4 + 7) / 8;
    }
    return getWidthInBlocks(transcoderFormat, width) * getHeightInBlocks(transcoderFormat, height) * blockByteLength;
  }
  function isPowerOfTwo(value) {
    if (value <= 2) return true;
    return (value & value - 1) === 0 && value !== 0;
  }
};