itowns 2.45.1-next.0 → 2.45.1-next.1

package/lib/ThreeExtended/loaders/KTX2Loader.js

@@ -0,0 +1,709 @@
+/**
+ * Loader for KTX 2.0 GPU Texture containers.
+ *
+ * KTX 2.0 is a container format for various GPU texture formats. The loader
+ * supports Basis Universal GPU textures, which can be quickly transcoded to
+ * a wide variety of GPU texture compression formats, as well as some
+ * uncompressed DataTexture and Data3DTexture formats.
+ *
+ * References:
+ * - KTX: http://github.khronos.org/KTX-Specification/
+ * - DFD: https://www.khronos.org/registry/DataFormat/specs/1.3/dataformat.1.3.html#basicdescriptor
+ * - BasisU HDR: https://github.com/BinomialLLC/basis_universal/wiki/UASTC-HDR-Texture-Specification-v1.0
+ */
+
+import { CompressedTexture, CompressedArrayTexture, CompressedCubeTexture, Data3DTexture, DataTexture, FileLoader, FloatType, HalfFloatType, NoColorSpace, LinearFilter, LinearMipmapLinearFilter, LinearSRGBColorSpace, Loader, RedFormat, RGB_BPTC_UNSIGNED_Format, RGB_ETC1_Format, RGB_ETC2_Format, RGB_PVRTC_4BPPV1_Format, RGBA_ASTC_4x4_Format, RGBA_ASTC_6x6_Format, RGBA_BPTC_Format, RGBA_ETC2_EAC_Format, RGBA_PVRTC_4BPPV1_Format, RGBA_S3TC_DXT5_Format, RGBA_S3TC_DXT1_Format, RGBAFormat, RGFormat, SRGBColorSpace, UnsignedByteType } from 'three';
+import { WorkerPool } from "../utils/WorkerPool.js";
+import { read, KHR_DF_FLAG_ALPHA_PREMULTIPLIED, KHR_DF_TRANSFER_SRGB, KHR_SUPERCOMPRESSION_NONE, KHR_SUPERCOMPRESSION_ZSTD, VK_FORMAT_UNDEFINED, VK_FORMAT_R16_SFLOAT, VK_FORMAT_R16G16_SFLOAT, VK_FORMAT_R16G16B16A16_SFLOAT, VK_FORMAT_R32_SFLOAT, VK_FORMAT_R32G32_SFLOAT, VK_FORMAT_R32G32B32A32_SFLOAT, VK_FORMAT_R8_SRGB, VK_FORMAT_R8_UNORM, VK_FORMAT_R8G8_SRGB, VK_FORMAT_R8G8_UNORM, VK_FORMAT_R8G8B8A8_SRGB, VK_FORMAT_R8G8B8A8_UNORM, VK_FORMAT_ASTC_4x4_SFLOAT_BLOCK_EXT, VK_FORMAT_ASTC_6x6_SRGB_BLOCK, VK_FORMAT_ASTC_6x6_UNORM_BLOCK, KHR_DF_PRIMARIES_UNSPECIFIED, KHR_DF_PRIMARIES_BT709, KHR_DF_PRIMARIES_DISPLAYP3 } from "../libs/ktx-parse.module.js";
+import { ZSTDDecoder } from "../libs/zstddec.module.js";
+import { DisplayP3ColorSpace, LinearDisplayP3ColorSpace } from "../math/ColorSpaces.js";
+const _taskCache = new WeakMap();
+let _activeLoaders = 0;
+let _zstd;
+class KTX2Loader extends Loader {
+  constructor(manager) {
+    super(manager);
+    this.transcoderPath = '';
+    this.transcoderBinary = null;
+    this.transcoderPending = null;
+    this.workerPool = new WorkerPool();
+    this.workerSourceURL = '';
+    this.workerConfig = null;
+    if (typeof MSC_TRANSCODER !== 'undefined') {
+      console.warn('THREE.KTX2Loader: Please update to latest "basis_transcoder".' + ' "msc_basis_transcoder" is no longer supported in three.js r125+.');
+    }
+  }
+  setTranscoderPath(path) {
+    this.transcoderPath = path;
+    return this;
+  }
+  setWorkerLimit(num) {
+    this.workerPool.setWorkerLimit(num);
+    return this;
+  }
+  async detectSupportAsync(renderer) {
+    this.workerConfig = {
+      astcSupported: await renderer.hasFeatureAsync('texture-compression-astc'),
+      astcHDRSupported: false,
+      // https://github.com/gpuweb/gpuweb/issues/3856
+      etc1Supported: await renderer.hasFeatureAsync('texture-compression-etc1'),
+      etc2Supported: await renderer.hasFeatureAsync('texture-compression-etc2'),
+      dxtSupported: await renderer.hasFeatureAsync('texture-compression-bc'),
+      bptcSupported: await renderer.hasFeatureAsync('texture-compression-bptc'),
+      pvrtcSupported: await renderer.hasFeatureAsync('texture-compression-pvrtc')
+    };
+    return this;
+  }
+  detectSupport(renderer) {
+    if (renderer.isWebGPURenderer === true) {
+      this.workerConfig = {
+        astcSupported: renderer.hasFeature('texture-compression-astc'),
+        astcHDRSupported: false,
+        // https://github.com/gpuweb/gpuweb/issues/3856
+        etc1Supported: renderer.hasFeature('texture-compression-etc1'),
+        etc2Supported: renderer.hasFeature('texture-compression-etc2'),
+        dxtSupported: renderer.hasFeature('texture-compression-bc'),
+        bptcSupported: renderer.hasFeature('texture-compression-bptc'),
+        pvrtcSupported: renderer.hasFeature('texture-compression-pvrtc')
+      };
+    } else {
+      this.workerConfig = {
+        astcSupported: renderer.extensions.has('WEBGL_compressed_texture_astc'),
+        astcHDRSupported: renderer.extensions.has('WEBGL_compressed_texture_astc') && renderer.extensions.get('WEBGL_compressed_texture_astc').getSupportedProfiles().includes('hdr'),
+        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;
+  }
+  init() {
+    if (!this.transcoderPending) {
+      // Load transcoder wrapper.
+      const jsLoader = new FileLoader(this.manager);
+      jsLoader.setPath(this.transcoderPath);
+      jsLoader.setWithCredentials(this.withCredentials);
+      const jsContent = jsLoader.loadAsync('basis_transcoder.js');
+
+      // Load transcoder WASM binary.
+      const binaryLoader = new FileLoader(this.manager);
+      binaryLoader.setPath(this.transcoderPath);
+      binaryLoader.setResponseType('arraybuffer');
+      binaryLoader.setWithCredentials(this.withCredentials);
+      const binaryContent = binaryLoader.loadAsync('basis_transcoder.wasm');
+      this.transcoderPending = Promise.all([jsContent, binaryContent]).then(_ref => {
+        let [jsContent, binaryContent] = _ref;
+        const fn = KTX2Loader.BasisWorker.toString();
+        const body = ['/* constants */', 'let _EngineFormat = ' + JSON.stringify(KTX2Loader.EngineFormat), 'let _EngineType = ' + JSON.stringify(KTX2Loader.EngineType), 'let _TranscoderFormat = ' + JSON.stringify(KTX2Loader.TranscoderFormat), 'let _BasisFormat = ' + JSON.stringify(KTX2Loader.BasisFormat), '/* basis_transcoder.js */', jsContent, '/* worker */', fn.substring(fn.indexOf('{') + 1, fn.lastIndexOf('}'))].join('\n');
+        this.workerSourceURL = URL.createObjectURL(new Blob([body]));
+        this.transcoderBinary = binaryContent;
+        this.workerPool.setWorkerCreator(() => {
+          const worker = new Worker(this.workerSourceURL);
+          const transcoderBinary = this.transcoderBinary.slice(0);
+          worker.postMessage({
+            type: 'init',
+            config: this.workerConfig,
+            transcoderBinary
+          }, [transcoderBinary]);
+          return worker;
+        });
+      });
+      if (_activeLoaders > 0) {
+        // Each instance loads a transcoder and allocates workers, increasing network and memory cost.
+
+        console.warn('THREE.KTX2Loader: Multiple active KTX2 loaders may cause performance issues.' + ' Use a single KTX2Loader instance, or call .dispose() on old instances.');
+      }
+      _activeLoaders++;
+    }
+    return this.transcoderPending;
+  }
+  load(url, onLoad, onProgress, onError) {
+    if (this.workerConfig === null) {
+      throw new Error('THREE.KTX2Loader: Missing initialization with `.detectSupport( renderer )`.');
+    }
+    const loader = new FileLoader(this.manager);
+    loader.setResponseType('arraybuffer');
+    loader.setWithCredentials(this.withCredentials);
+    loader.load(url, buffer => {
+      this.parse(buffer, onLoad, onError);
+    }, onProgress, onError);
+  }
+  parse(buffer, onLoad, onError) {
+    if (this.workerConfig === null) {
+      throw new Error('THREE.KTX2Loader: Missing initialization with `.detectSupport( renderer )`.');
+    }
+
+    // Check for an existing task using this buffer. A transferred buffer cannot be transferred
+    // again from this thread.
+    if (_taskCache.has(buffer)) {
+      const cachedTask = _taskCache.get(buffer);
+      return cachedTask.promise.then(onLoad).catch(onError);
+    }
+    this._createTexture(buffer).then(texture => onLoad ? onLoad(texture) : null).catch(onError);
+  }
+  _createTextureFrom(transcodeResult, container) {
+    const {
+      type: messageType,
+      error,
+      data: {
+        faces,
+        width,
+        height,
+        format,
+        type,
+        dfdFlags
+      }
+    } = transcodeResult;
+    if (messageType === 'error') return Promise.reject(error);
+    let texture;
+    if (container.faceCount === 6) {
+      texture = new CompressedCubeTexture(faces, format, type);
+    } else {
+      const mipmaps = faces[0].mipmaps;
+      texture = container.layerCount > 1 ? new CompressedArrayTexture(mipmaps, width, height, container.layerCount, format, type) : new CompressedTexture(mipmaps, width, height, format, type);
+    }
+    texture.minFilter = faces[0].mipmaps.length === 1 ? LinearFilter : LinearMipmapLinearFilter;
+    texture.magFilter = LinearFilter;
+    texture.generateMipmaps = false;
+    texture.needsUpdate = true;
+    texture.colorSpace = parseColorSpace(container);
+    texture.premultiplyAlpha = !!(dfdFlags & KHR_DF_FLAG_ALPHA_PREMULTIPLIED);
+    return texture;
+  }
+
+  /**
+   * @param {ArrayBuffer} buffer
+   * @param {object?} config
+   * @return {Promise<CompressedTexture|CompressedArrayTexture|DataTexture|Data3DTexture>}
+   */
+  async _createTexture(buffer) {
+    let config = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
+    const container = read(new Uint8Array(buffer));
+
+    // Basis UASTC HDR is a subset of ASTC, which can be transcoded efficiently
+    // to BC6H. To detect whether a KTX2 file uses Basis UASTC HDR, or default
+    // ASTC, inspect the DFD color model.
+    //
+    // Source: https://github.com/BinomialLLC/basis_universal/issues/381
+    const isBasisHDR = container.vkFormat === VK_FORMAT_ASTC_4x4_SFLOAT_BLOCK_EXT && container.dataFormatDescriptor[0].colorModel === 0xA7;
+
+    // If the device supports ASTC, Basis UASTC HDR requires no transcoder.
+    const needsTranscoder = container.vkFormat === VK_FORMAT_UNDEFINED || isBasisHDR && !this.workerConfig.astcHDRSupported;
+    if (!needsTranscoder) {
+      return createRawTexture(container);
+    }
+
+    //
+
+    const texturePending = this.init().then(() => {
+      return this.workerPool.postMessage({
+        type: 'transcode',
+        buffer,
+        taskConfig: config
+      }, [buffer]);
+    }).then(e => this._createTextureFrom(e.data, container));
+
+    // Cache the task result.
+    _taskCache.set(buffer, {
+      promise: texturePending
+    });
+    return texturePending;
+  }
+  dispose() {
+    this.workerPool.dispose();
+    if (this.workerSourceURL) URL.revokeObjectURL(this.workerSourceURL);
+    _activeLoaders--;
+    return this;
+  }
+}
+
+/* CONSTANTS */
+
+KTX2Loader.BasisFormat = {
+  ETC1S: 0,
+  UASTC: 1,
+  UASTC_HDR: 2
+};
+
+// Source: https://github.com/BinomialLLC/basis_universal/blob/master/webgl/texture_test/index.html
+KTX2Loader.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,
+  BC6H: 22,
+  RGB_HALF: 24,
+  RGBA_HALF: 25
+};
+KTX2Loader.EngineFormat = {
+  RGBAFormat: RGBAFormat,
+  RGBA_ASTC_4x4_Format: RGBA_ASTC_4x4_Format,
+  RGB_BPTC_UNSIGNED_Format: RGB_BPTC_UNSIGNED_Format,
+  RGBA_BPTC_Format: RGBA_BPTC_Format,
+  RGBA_ETC2_EAC_Format: RGBA_ETC2_EAC_Format,
+  RGBA_PVRTC_4BPPV1_Format: RGBA_PVRTC_4BPPV1_Format,
+  RGBA_S3TC_DXT5_Format: RGBA_S3TC_DXT5_Format,
+  RGB_ETC1_Format: RGB_ETC1_Format,
+  RGB_ETC2_Format: RGB_ETC2_Format,
+  RGB_PVRTC_4BPPV1_Format: RGB_PVRTC_4BPPV1_Format,
+  RGBA_S3TC_DXT1_Format: RGBA_S3TC_DXT1_Format
+};
+KTX2Loader.EngineType = {
+  UnsignedByteType: UnsignedByteType,
+  HalfFloatType: HalfFloatType,
+  FloatType: FloatType
+};
+
+/* WEB WORKER */
+
+KTX2Loader.BasisWorker = function () {
+  let config;
+  let transcoderPending;
+  let BasisModule;
+  const EngineFormat = _EngineFormat; // eslint-disable-line no-undef
+  const EngineType = _EngineType; // eslint-disable-line no-undef
+  const TranscoderFormat = _TranscoderFormat; // eslint-disable-line no-undef
+  const BasisFormat = _BasisFormat; // eslint-disable-line no-undef
+
+  self.addEventListener('message', function (e) {
+    const message = e.data;
+    switch (message.type) {
+      case 'init':
+        config = message.config;
+        init(message.transcoderBinary);
+        break;
+      case 'transcode':
+        transcoderPending.then(() => {
+          try {
+            const {
+              faces,
+              buffers,
+              width,
+              height,
+              hasAlpha,
+              format,
+              type,
+              dfdFlags
+            } = transcode(message.buffer);
+            self.postMessage({
+              type: 'transcode',
+              id: message.id,
+              data: {
+                faces,
+                width,
+                height,
+                hasAlpha,
+                format,
+                type,
+                dfdFlags
+              }
+            }, buffers);
+          } catch (error) {
+            console.error(error);
+            self.postMessage({
+              type: 'error',
+              id: message.id,
+              error: error.message
+            });
+          }
+        });
+        break;
+    }
+  });
+  function init(wasmBinary) {
+    transcoderPending = new Promise(resolve => {
+      BasisModule = {
+        wasmBinary,
+        onRuntimeInitialized: resolve
+      };
+      BASIS(BasisModule); // eslint-disable-line no-undef
+    }).then(() => {
+      BasisModule.initializeBasis();
+      if (BasisModule.KTX2File === undefined) {
+        console.warn('THREE.KTX2Loader: Please update Basis Universal transcoder.');
+      }
+    });
+  }
+  function transcode(buffer) {
+    const ktx2File = new BasisModule.KTX2File(new Uint8Array(buffer));
+    function cleanup() {
+      ktx2File.close();
+      ktx2File.delete();
+    }
+    if (!ktx2File.isValid()) {
+      cleanup();
+      throw new Error('THREE.KTX2Loader:	Invalid or unsupported .ktx2 file');
+    }
+    let basisFormat;
+    if (ktx2File.isUASTC()) {
+      basisFormat = BasisFormat.UASTC;
+    } else if (ktx2File.isETC1S()) {
+      basisFormat = BasisFormat.ETC1S;
+    } else if (ktx2File.isHDR()) {
+      basisFormat = BasisFormat.UASTC_HDR;
+    } else {
+      throw new Error('THREE.KTX2Loader: Unknown Basis encoding');
+    }
+    const width = ktx2File.getWidth();
+    const height = ktx2File.getHeight();
+    const layerCount = ktx2File.getLayers() || 1;
+    const levelCount = ktx2File.getLevels();
+    const faceCount = ktx2File.getFaces();
+    const hasAlpha = ktx2File.getHasAlpha();
+    const dfdFlags = ktx2File.getDFDFlags();
+    const {
+      transcoderFormat,
+      engineFormat,
+      engineType
+    } = getTranscoderFormat(basisFormat, width, height, hasAlpha);
+    if (!width || !height || !levelCount) {
+      cleanup();
+      throw new Error('THREE.KTX2Loader:	Invalid texture');
+    }
+    if (!ktx2File.startTranscoding()) {
+      cleanup();
+      throw new Error('THREE.KTX2Loader: .startTranscoding failed');
+    }
+    const faces = [];
+    const buffers = [];
+    for (let face = 0; face < faceCount; face++) {
+      const mipmaps = [];
+      for (let mip = 0; mip < levelCount; mip++) {
+        const layerMips = [];
+        let mipWidth, mipHeight;
+        for (let layer = 0; layer < layerCount; layer++) {
+          const levelInfo = ktx2File.getImageLevelInfo(mip, layer, face);
+          if (face === 0 && mip === 0 && layer === 0 && (levelInfo.origWidth % 4 !== 0 || levelInfo.origHeight % 4 !== 0)) {
+            console.warn('THREE.KTX2Loader: ETC1S and UASTC textures should use multiple-of-four dimensions.');
+          }
+          if (levelCount > 1) {
+            mipWidth = levelInfo.origWidth;
+            mipHeight = levelInfo.origHeight;
+          } else {
+            // Handles non-multiple-of-four dimensions in textures without mipmaps. Textures with
+            // mipmaps must use multiple-of-four dimensions, for some texture formats and APIs.
+            // See mrdoob/three.js#25908.
+            mipWidth = levelInfo.width;
+            mipHeight = levelInfo.height;
+          }
+          let dst = new Uint8Array(ktx2File.getImageTranscodedSizeInBytes(mip, layer, 0, transcoderFormat));
+          const status = ktx2File.transcodeImage(dst, mip, layer, face, transcoderFormat, 0, -1, -1);
+          if (engineType === EngineType.HalfFloatType) {
+            dst = new Uint16Array(dst.buffer, dst.byteOffset, dst.byteLength / Uint16Array.BYTES_PER_ELEMENT);
+          }
+          if (!status) {
+            cleanup();
+            throw new Error('THREE.KTX2Loader: .transcodeImage failed.');
+          }
+          layerMips.push(dst);
+        }
+        const mipData = concat(layerMips);
+        mipmaps.push({
+          data: mipData,
+          width: mipWidth,
+          height: mipHeight
+        });
+        buffers.push(mipData.buffer);
+      }
+      faces.push({
+        mipmaps,
+        width,
+        height,
+        format: engineFormat,
+        type: engineType
+      });
+    }
+    cleanup();
+    return {
+      faces,
+      buffers,
+      width,
+      height,
+      hasAlpha,
+      dfdFlags,
+      format: engineFormat,
+      type: engineType
+    };
+  }
+
+  //
+
+  // Optimal choice of a transcoder target format depends on the Basis format (ETC1S, UASTC, or
+  // UASTC HDR), device capabilities, and texture dimensions. The list below ranks the formats
+  // separately for each format. Currently, priority is assigned based on:
+  //
+  //   high quality > low quality > uncompressed
+  //
+  // Prioritization may be revisited, or exposed for configuration, in the future.
+  //
+  // Reference: https://github.com/KhronosGroup/3D-Formats-Guidelines/blob/main/KTXDeveloperGuide.md
+  const FORMAT_OPTIONS = [{
+    if: 'astcSupported',
+    basisFormat: [BasisFormat.UASTC],
+    transcoderFormat: [TranscoderFormat.ASTC_4x4, TranscoderFormat.ASTC_4x4],
+    engineFormat: [EngineFormat.RGBA_ASTC_4x4_Format, EngineFormat.RGBA_ASTC_4x4_Format],
+    engineType: [EngineType.UnsignedByteType],
+    priorityETC1S: Infinity,
+    priorityUASTC: 1,
+    needsPowerOfTwo: false
+  }, {
+    if: 'bptcSupported',
+    basisFormat: [BasisFormat.ETC1S, BasisFormat.UASTC],
+    transcoderFormat: [TranscoderFormat.BC7_M5, TranscoderFormat.BC7_M5],
+    engineFormat: [EngineFormat.RGBA_BPTC_Format, EngineFormat.RGBA_BPTC_Format],
+    engineType: [EngineType.UnsignedByteType],
+    priorityETC1S: 3,
+    priorityUASTC: 2,
+    needsPowerOfTwo: false
+  }, {
+    if: 'dxtSupported',
+    basisFormat: [BasisFormat.ETC1S, BasisFormat.UASTC],
+    transcoderFormat: [TranscoderFormat.BC1, TranscoderFormat.BC3],
+    engineFormat: [EngineFormat.RGBA_S3TC_DXT1_Format, EngineFormat.RGBA_S3TC_DXT5_Format],
+    engineType: [EngineType.UnsignedByteType],
+    priorityETC1S: 4,
+    priorityUASTC: 5,
+    needsPowerOfTwo: false
+  }, {
+    if: 'etc2Supported',
+    basisFormat: [BasisFormat.ETC1S, BasisFormat.UASTC],
+    transcoderFormat: [TranscoderFormat.ETC1, TranscoderFormat.ETC2],
+    engineFormat: [EngineFormat.RGB_ETC2_Format, EngineFormat.RGBA_ETC2_EAC_Format],
+    engineType: [EngineType.UnsignedByteType],
+    priorityETC1S: 1,
+    priorityUASTC: 3,
+    needsPowerOfTwo: false
+  }, {
+    if: 'etc1Supported',
+    basisFormat: [BasisFormat.ETC1S, BasisFormat.UASTC],
+    transcoderFormat: [TranscoderFormat.ETC1],
+    engineFormat: [EngineFormat.RGB_ETC1_Format],
+    engineType: [EngineType.UnsignedByteType],
+    priorityETC1S: 2,
+    priorityUASTC: 4,
+    needsPowerOfTwo: false
+  }, {
+    if: 'pvrtcSupported',
+    basisFormat: [BasisFormat.ETC1S, BasisFormat.UASTC],
+    transcoderFormat: [TranscoderFormat.PVRTC1_4_RGB, TranscoderFormat.PVRTC1_4_RGBA],
+    engineFormat: [EngineFormat.RGB_PVRTC_4BPPV1_Format, EngineFormat.RGBA_PVRTC_4BPPV1_Format],
+    engineType: [EngineType.UnsignedByteType],
+    priorityETC1S: 5,
+    priorityUASTC: 6,
+    needsPowerOfTwo: true
+  }, {
+    if: 'bptcSupported',
+    basisFormat: [BasisFormat.UASTC_HDR],
+    transcoderFormat: [TranscoderFormat.BC6H],
+    engineFormat: [EngineFormat.RGB_BPTC_UNSIGNED_Format],
+    engineType: [EngineType.HalfFloatType],
+    priorityHDR: 1,
+    needsPowerOfTwo: false
+  },
+  // Uncompressed fallbacks.
+
+  {
+    basisFormat: [BasisFormat.ETC1S, BasisFormat.UASTC],
+    transcoderFormat: [TranscoderFormat.RGBA32, TranscoderFormat.RGBA32],
+    engineFormat: [EngineFormat.RGBAFormat, EngineFormat.RGBAFormat],
+    engineType: [EngineType.UnsignedByteType, EngineType.UnsignedByteType],
+    priorityETC1S: 100,
+    priorityUASTC: 100,
+    needsPowerOfTwo: false
+  }, {
+    basisFormat: [BasisFormat.UASTC_HDR],
+    transcoderFormat: [TranscoderFormat.RGBA_HALF],
+    engineFormat: [EngineFormat.RGBAFormat],
+    engineType: [EngineType.HalfFloatType],
+    priorityHDR: 100,
+    needsPowerOfTwo: false
+  }];
+  const OPTIONS = {
+    // TODO: For ETC1S we intentionally sort by _UASTC_ priority, preserving
+    // a historical accident shown to avoid performance pitfalls for Linux with
+    // Firefox & AMD GPU (RadeonSI). Further work needed.
+    // See https://github.com/mrdoob/three.js/pull/29730.
+    [BasisFormat.ETC1S]: FORMAT_OPTIONS.filter(opt => opt.basisFormat.includes(BasisFormat.ETC1S)).sort((a, b) => a.priorityUASTC - b.priorityUASTC),
+    [BasisFormat.UASTC]: FORMAT_OPTIONS.filter(opt => opt.basisFormat.includes(BasisFormat.UASTC)).sort((a, b) => a.priorityUASTC - b.priorityUASTC),
+    [BasisFormat.UASTC_HDR]: FORMAT_OPTIONS.filter(opt => opt.basisFormat.includes(BasisFormat.UASTC_HDR)).sort((a, b) => a.priorityHDR - b.priorityHDR)
+  };
+  function getTranscoderFormat(basisFormat, width, height, hasAlpha) {
+    const options = OPTIONS[basisFormat];
+    for (let i = 0; i < options.length; i++) {
+      const opt = options[i];
+      if (opt.if && !config[opt.if]) continue;
+      if (!opt.basisFormat.includes(basisFormat)) continue;
+      if (hasAlpha && opt.transcoderFormat.length < 2) continue;
+      if (opt.needsPowerOfTwo && !(isPowerOfTwo(width) && isPowerOfTwo(height))) continue;
+      const transcoderFormat = opt.transcoderFormat[hasAlpha ? 1 : 0];
+      const engineFormat = opt.engineFormat[hasAlpha ? 1 : 0];
+      const engineType = opt.engineType[0];
+      return {
+        transcoderFormat,
+        engineFormat,
+        engineType
+      };
+    }
+    throw new Error('THREE.KTX2Loader: Failed to identify transcoding target.');
+  }
+  function isPowerOfTwo(value) {
+    if (value <= 2) return true;
+    return (value & value - 1) === 0 && value !== 0;
+  }
+
+  /** Concatenates N byte arrays. */
+  function concat(arrays) {
+    if (arrays.length === 1) return arrays[0];
+    let totalByteLength = 0;
+    for (let i = 0; i < arrays.length; i++) {
+      const array = arrays[i];
+      totalByteLength += array.byteLength;
+    }
+    const result = new Uint8Array(totalByteLength);
+    let byteOffset = 0;
+    for (let i = 0; i < arrays.length; i++) {
+      const array = arrays[i];
+      result.set(array, byteOffset);
+      byteOffset += array.byteLength;
+    }
+    return result;
+  }
+};
+
+// Parsing for non-Basis textures. These textures may have supercompression
+// like Zstd, but they do not require transcoding.
+
+const UNCOMPRESSED_FORMATS = new Set([RGBAFormat, RGFormat, RedFormat]);
+const FORMAT_MAP = {
+  [VK_FORMAT_R32G32B32A32_SFLOAT]: RGBAFormat,
+  [VK_FORMAT_R16G16B16A16_SFLOAT]: RGBAFormat,
+  [VK_FORMAT_R8G8B8A8_UNORM]: RGBAFormat,
+  [VK_FORMAT_R8G8B8A8_SRGB]: RGBAFormat,
+  [VK_FORMAT_R32G32_SFLOAT]: RGFormat,
+  [VK_FORMAT_R16G16_SFLOAT]: RGFormat,
+  [VK_FORMAT_R8G8_UNORM]: RGFormat,
+  [VK_FORMAT_R8G8_SRGB]: RGFormat,
+  [VK_FORMAT_R32_SFLOAT]: RedFormat,
+  [VK_FORMAT_R16_SFLOAT]: RedFormat,
+  [VK_FORMAT_R8_SRGB]: RedFormat,
+  [VK_FORMAT_R8_UNORM]: RedFormat,
+  [VK_FORMAT_ASTC_4x4_SFLOAT_BLOCK_EXT]: RGBA_ASTC_4x4_Format,
+  [VK_FORMAT_ASTC_6x6_SRGB_BLOCK]: RGBA_ASTC_6x6_Format,
+  [VK_FORMAT_ASTC_6x6_UNORM_BLOCK]: RGBA_ASTC_6x6_Format
+};
+const TYPE_MAP = {
+  [VK_FORMAT_R32G32B32A32_SFLOAT]: FloatType,
+  [VK_FORMAT_R16G16B16A16_SFLOAT]: HalfFloatType,
+  [VK_FORMAT_R8G8B8A8_UNORM]: UnsignedByteType,
+  [VK_FORMAT_R8G8B8A8_SRGB]: UnsignedByteType,
+  [VK_FORMAT_R32G32_SFLOAT]: FloatType,
+  [VK_FORMAT_R16G16_SFLOAT]: HalfFloatType,
+  [VK_FORMAT_R8G8_UNORM]: UnsignedByteType,
+  [VK_FORMAT_R8G8_SRGB]: UnsignedByteType,
+  [VK_FORMAT_R32_SFLOAT]: FloatType,
+  [VK_FORMAT_R16_SFLOAT]: HalfFloatType,
+  [VK_FORMAT_R8_SRGB]: UnsignedByteType,
+  [VK_FORMAT_R8_UNORM]: UnsignedByteType,
+  [VK_FORMAT_ASTC_4x4_SFLOAT_BLOCK_EXT]: HalfFloatType,
+  [VK_FORMAT_ASTC_6x6_SRGB_BLOCK]: UnsignedByteType,
+  [VK_FORMAT_ASTC_6x6_UNORM_BLOCK]: UnsignedByteType
+};
+async function createRawTexture(container) {
+  const {
+    vkFormat
+  } = container;
+  if (FORMAT_MAP[vkFormat] === undefined) {
+    throw new Error('THREE.KTX2Loader: Unsupported vkFormat.');
+  }
+
+  //
+
+  let zstd;
+  if (container.supercompressionScheme === KHR_SUPERCOMPRESSION_ZSTD) {
+    if (!_zstd) {
+      _zstd = new Promise(async resolve => {
+        const zstd = new ZSTDDecoder();
+        await zstd.init();
+        resolve(zstd);
+      });
+    }
+    zstd = await _zstd;
+  }
+
+  //
+
+  const mipmaps = [];
+  for (let levelIndex = 0; levelIndex < container.levels.length; levelIndex++) {
+    const levelWidth = Math.max(1, container.pixelWidth >> levelIndex);
+    const levelHeight = Math.max(1, container.pixelHeight >> levelIndex);
+    const levelDepth = container.pixelDepth ? Math.max(1, container.pixelDepth >> levelIndex) : 0;
+    const level = container.levels[levelIndex];
+    let levelData;
+    if (container.supercompressionScheme === KHR_SUPERCOMPRESSION_NONE) {
+      levelData = level.levelData;
+    } else if (container.supercompressionScheme === KHR_SUPERCOMPRESSION_ZSTD) {
+      levelData = zstd.decode(level.levelData, level.uncompressedByteLength);
+    } else {
+      throw new Error('THREE.KTX2Loader: Unsupported supercompressionScheme.');
+    }
+    let data;
+    if (TYPE_MAP[vkFormat] === FloatType) {
+      data = new Float32Array(levelData.buffer, levelData.byteOffset, levelData.byteLength / Float32Array.BYTES_PER_ELEMENT);
+    } else if (TYPE_MAP[vkFormat] === HalfFloatType) {
+      data = new Uint16Array(levelData.buffer, levelData.byteOffset, levelData.byteLength / Uint16Array.BYTES_PER_ELEMENT);
+    } else {
+      data = levelData;
+    }
+    mipmaps.push({
+      data: data,
+      width: levelWidth,
+      height: levelHeight,
+      depth: levelDepth
+    });
+  }
+  let texture;
+  if (UNCOMPRESSED_FORMATS.has(FORMAT_MAP[vkFormat])) {
+    texture = container.pixelDepth === 0 ? new DataTexture(mipmaps[0].data, container.pixelWidth, container.pixelHeight) : new Data3DTexture(mipmaps[0].data, container.pixelWidth, container.pixelHeight, container.pixelDepth);
+  } else {
+    if (container.pixelDepth > 0) throw new Error('THREE.KTX2Loader: Unsupported pixelDepth.');
+    texture = new CompressedTexture(mipmaps, container.pixelWidth, container.pixelHeight);
+  }
+  texture.mipmaps = mipmaps;
+  texture.type = TYPE_MAP[vkFormat];
+  texture.format = FORMAT_MAP[vkFormat];
+  texture.colorSpace = parseColorSpace(container);
+  texture.needsUpdate = true;
+
+  //
+
+  return Promise.resolve(texture);
+}
+function parseColorSpace(container) {
+  const dfd = container.dataFormatDescriptor[0];
+  if (dfd.colorPrimaries === KHR_DF_PRIMARIES_BT709) {
+    return dfd.transferFunction === KHR_DF_TRANSFER_SRGB ? SRGBColorSpace : LinearSRGBColorSpace;
+  } else if (dfd.colorPrimaries === KHR_DF_PRIMARIES_DISPLAYP3) {
+    return dfd.transferFunction === KHR_DF_TRANSFER_SRGB ? DisplayP3ColorSpace : LinearDisplayP3ColorSpace;
+  } else if (dfd.colorPrimaries === KHR_DF_PRIMARIES_UNSPECIFIED) {
+    return NoColorSpace;
+  } else {
+    console.warn(`THREE.KTX2Loader: Unsupported color primaries, "${dfd.colorPrimaries}"`);
+    return NoColorSpace;
+  }
+}
+export { KTX2Loader };