three-stdlib 2.16.0 → 2.16.2

package/loaders/HDRCubeTextureLoader.mjs

@@ -1,77 +0,0 @@
-import { Loader, HalfFloatType, CubeTexture, LinearEncoding, LinearFilter, FloatType, FileLoader, DataTexture } from "three";
-import { RGBELoader } from "./RGBELoader.mjs";
-class HDRCubeTextureLoader extends Loader {
-  constructor(manager) {
-    super(manager);
-    this.hdrLoader = new RGBELoader();
-    this.type = HalfFloatType;
-  }
-  load(urls, onLoad, onProgress, onError) {
-    if (!Array.isArray(urls)) {
-      console.warn("THREE.HDRCubeTextureLoader signature has changed. Use .setDataType() instead.");
-      this.setDataType(urls);
-      urls = onLoad;
-      onLoad = onProgress;
-      onProgress = onError;
-      onError = arguments[4];
-    }
-    const texture = new CubeTexture();
-    texture.type = this.type;
-    switch (texture.type) {
-      case FloatType:
-        texture.encoding = LinearEncoding;
-        texture.minFilter = LinearFilter;
-        texture.magFilter = LinearFilter;
-        texture.generateMipmaps = false;
-        break;
-      case HalfFloatType:
-        texture.encoding = LinearEncoding;
-        texture.minFilter = LinearFilter;
-        texture.magFilter = LinearFilter;
-        texture.generateMipmaps = false;
-        break;
-    }
-    const scope = this;
-    let loaded = 0;
-    function loadHDRData(i, onLoad2, onProgress2, onError2) {
-      new FileLoader(scope.manager).setPath(scope.path).setResponseType("arraybuffer").setWithCredentials(scope.withCredentials).load(
-        urls[i],
-        function(buffer) {
-          loaded++;
-          const texData = scope.hdrLoader.parse(buffer);
-          if (!texData)
-            return;
-          if (texData.data !== void 0) {
-            const dataTexture = new DataTexture(texData.data, texData.width, texData.height);
-            dataTexture.type = texture.type;
-            dataTexture.encoding = texture.encoding;
-            dataTexture.format = texture.format;
-            dataTexture.minFilter = texture.minFilter;
-            dataTexture.magFilter = texture.magFilter;
-            dataTexture.generateMipmaps = texture.generateMipmaps;
-            texture.images[i] = dataTexture;
-          }
-          if (loaded === 6) {
-            texture.needsUpdate = true;
-            if (onLoad2)
-              onLoad2(texture);
-          }
-        },
-        onProgress2,
-        onError2
-      );
-    }
-    for (let i = 0; i < urls.length; i++) {
-      loadHDRData(i, onLoad, onProgress, onError);
-    }
-    return texture;
-  }
-  setDataType(value) {
-    this.type = value;
-    this.hdrLoader.setDataType(value);
-    return this;
-  }
-}
-export {
-  HDRCubeTextureLoader
-};

package/loaders/KMZLoader.mjs

@@ -1,75 +0,0 @@
-import { Loader, FileLoader, LoadingManager, Group } from "three";
-import { ColladaLoader } from "./ColladaLoader.mjs";
-import { unzipSync } from "fflate";
-class KMZLoader extends Loader {
-  constructor(manager) {
-    super(manager);
-  }
-  load(url, onLoad, onProgress, onError) {
-    const scope = this;
-    const loader = new FileLoader(scope.manager);
-    loader.setPath(scope.path);
-    loader.setResponseType("arraybuffer");
-    loader.setRequestHeader(scope.requestHeader);
-    loader.setWithCredentials(scope.withCredentials);
-    loader.load(
-      url,
-      function(text) {
-        try {
-          onLoad(scope.parse(text));
-        } catch (e) {
-          if (onError) {
-            onError(e);
-          } else {
-            console.error(e);
-          }
-          scope.manager.itemError(url);
-        }
-      },
-      onProgress,
-      onError
-    );
-  }
-  parse(data) {
-    function findFile(url) {
-      for (const path in zip) {
-        if (path.substr(-url.length) === url) {
-          return zip[path];
-        }
-      }
-    }
-    const manager = new LoadingManager();
-    manager.setURLModifier(function(url) {
-      const image = findFile(url);
-      if (image) {
-        console.log("Loading", url);
-        const blob = new Blob([image.buffer], { type: "application/octet-stream" });
-        return URL.createObjectURL(blob);
-      }
-      return url;
-    });
-    const zip = unzipSync(new Uint8Array(data));
-    if (zip["doc.kml"]) {
-      const xml = new DOMParser().parseFromString(fflate.strFromU8(zip["doc.kml"]), "application/xml");
-      const model = xml.querySelector("Placemark Model Link href");
-      if (model) {
-        const loader = new ColladaLoader(manager);
-        return loader.parse(fflate.strFromU8(zip[model.textContent]));
-      }
-    } else {
-      console.warn("KMZLoader: Missing doc.kml file.");
-      for (const path in zip) {
-        const extension = path.split(".").pop().toLowerCase();
-        if (extension === "dae") {
-          const loader = new ColladaLoader(manager);
-          return loader.parse(fflate.strFromU8(zip[path]));
-        }
-      }
-    }
-    console.error("KMZLoader: Couldn't find .dae file.");
-    return { scene: new Group() };
-  }
-}
-export {
-  KMZLoader
-};

package/loaders/KTX2Loader.mjs

@@ -1,427 +0,0 @@
-import { Loader, FileLoader, CompressedTexture, UnsignedByteType, LinearFilter, LinearMipmapLinearFilter, sRGBEncoding, LinearEncoding, RGBAFormat, RGBA_ASTC_4x4_Format, RGBA_BPTC_Format, RGBA_ETC2_EAC_Format, RGBA_PVRTC_4BPPV1_Format, RGBA_S3TC_DXT5_Format, RGB_ETC1_Format, RGB_ETC2_Format, RGB_PVRTC_4BPPV1_Format, RGB_S3TC_DXT1_Format, RGFormat, RedFormat, FloatType, HalfFloatType, DataTexture, Data3DTexture } from "three";
-import { WorkerPool } from "../utils/WorkerPool.mjs";
-import { KHR_DF_TRANSFER_SRGB, KHR_DF_FLAG_ALPHA_PREMULTIPLIED, read, VK_FORMAT_UNDEFINED, VK_FORMAT_R32G32B32A32_SFLOAT, VK_FORMAT_R16G16B16A16_SFLOAT, VK_FORMAT_R8G8B8A8_UNORM, VK_FORMAT_R8G8B8A8_SRGB, VK_FORMAT_R32G32_SFLOAT, VK_FORMAT_R16G16_SFLOAT, VK_FORMAT_R8G8_UNORM, VK_FORMAT_R8G8_SRGB, VK_FORMAT_R32_SFLOAT, VK_FORMAT_R16_SFLOAT, VK_FORMAT_R8_SRGB, VK_FORMAT_R8_UNORM, KHR_SUPERCOMPRESSION_NONE, KHR_SUPERCOMPRESSION_ZSTD } from "ktx-parse";
-import { ZSTDDecoder } from "zstddec";
-const _taskCache = /* @__PURE__ */ 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;
-  }
-  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")
-    };
-    if (renderer.capabilities.isWebGL2) {
-      this.workerConfig.etc1Supported = false;
-    }
-    return this;
-  }
-  init() {
-    if (!this.transcoderPending) {
-      const jsLoader = new FileLoader(this.manager);
-      jsLoader.setPath(this.transcoderPath);
-      jsLoader.setWithCredentials(this.withCredentials);
-      const jsContent = jsLoader.loadAsync("basis_transcoder.js");
-      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(([jsContent2, binaryContent2]) => {
-        const fn = KTX2Loader.BasisWorker.toString();
-        const body = [
-          "/* constants */",
-          "let _EngineFormat = " + JSON.stringify(KTX2Loader.EngineFormat),
-          "let _TranscoderFormat = " + JSON.stringify(KTX2Loader.TranscoderFormat),
-          "let _BasisFormat = " + JSON.stringify(KTX2Loader.BasisFormat),
-          "/* basis_transcoder.js */",
-          jsContent2,
-          "/* worker */",
-          fn.substring(fn.indexOf("{") + 1, fn.lastIndexOf("}"))
-        ].join("\n");
-        this.workerSourceURL = URL.createObjectURL(new Blob([body]));
-        this.transcoderBinary = binaryContent2;
-        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) {
-        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) => {
-        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);
-      },
-      onProgress,
-      onError
-    );
-  }
-  _createTextureFrom(transcodeResult) {
-    const { mipmaps, width, height, format, type, error, dfdTransferFn, dfdFlags } = transcodeResult;
-    if (type === "error")
-      return Promise.reject(error);
-    const texture = new CompressedTexture(mipmaps, width, height, format, UnsignedByteType);
-    texture.minFilter = mipmaps.length === 1 ? LinearFilter : LinearMipmapLinearFilter;
-    texture.magFilter = LinearFilter;
-    texture.generateMipmaps = false;
-    texture.needsUpdate = true;
-    texture.encoding = dfdTransferFn === KHR_DF_TRANSFER_SRGB ? sRGBEncoding : LinearEncoding;
-    texture.premultiplyAlpha = !!(dfdFlags & KHR_DF_FLAG_ALPHA_PREMULTIPLIED);
-    return texture;
-  }
-  _createTexture(buffer, config = {}) {
-    const container = read(new Uint8Array(buffer));
-    if (container.vkFormat !== VK_FORMAT_UNDEFINED) {
-      return createDataTexture(container);
-    }
-    const taskConfig = config;
-    const texturePending = this.init().then(() => {
-      return this.workerPool.postMessage({ type: "transcode", buffer, taskConfig }, [buffer]);
-    }).then((e) => this._createTextureFrom(e.data));
-    _taskCache.set(buffer, { promise: texturePending });
-    return texturePending;
-  }
-  dispose() {
-    this.workerPool.dispose();
-    if (this.workerSourceURL)
-      URL.revokeObjectURL(this.workerSourceURL);
-    _activeLoaders--;
-    return this;
-  }
-}
-KTX2Loader.BasisFormat = {
-  ETC1S: 0,
-  UASTC_4x4: 1
-};
-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
-};
-KTX2Loader.EngineFormat = {
-  RGBAFormat,
-  RGBA_ASTC_4x4_Format,
-  RGBA_BPTC_Format,
-  RGBA_ETC2_EAC_Format,
-  RGBA_PVRTC_4BPPV1_Format,
-  RGBA_S3TC_DXT5_Format,
-  RGB_ETC1_Format,
-  RGB_ETC2_Format,
-  RGB_PVRTC_4BPPV1_Format,
-  RGB_S3TC_DXT1_Format
-};
-KTX2Loader.BasisWorker = function() {
-  let config;
-  let transcoderPending;
-  let BasisModule;
-  const EngineFormat = _EngineFormat;
-  const TranscoderFormat = _TranscoderFormat;
-  const BasisFormat = _BasisFormat;
-  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 { width, height, hasAlpha, mipmaps, format, dfdTransferFn, dfdFlags } = transcode(message.buffer);
-            const buffers = [];
-            for (let i = 0; i < mipmaps.length; ++i) {
-              buffers.push(mipmaps[i].data.buffer);
-            }
-            self.postMessage(
-              { type: "transcode", id: message.id, width, height, hasAlpha, mipmaps, format, dfdTransferFn, 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);
-    }).then(() => {
-      BasisModule.initializeBasis();
-      if (BasisModule.KTX2File === void 0) {
-        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");
-    }
-    const basisFormat = ktx2File.isUASTC() ? BasisFormat.UASTC_4x4 : BasisFormat.ETC1S;
-    const width = ktx2File.getWidth();
-    const height = ktx2File.getHeight();
-    const levels = ktx2File.getLevels();
-    const hasAlpha = ktx2File.getHasAlpha();
-    const dfdTransferFn = ktx2File.getDFDTransferFunc();
-    const dfdFlags = ktx2File.getDFDFlags();
-    const { transcoderFormat, engineFormat } = getTranscoderFormat(basisFormat, width, height, hasAlpha);
-    if (!width || !height || !levels) {
-      cleanup();
-      throw new Error("THREE.KTX2Loader:	Invalid texture");
-    }
-    if (!ktx2File.startTranscoding()) {
-      cleanup();
-      throw new Error("THREE.KTX2Loader: .startTranscoding failed");
-    }
-    const mipmaps = [];
-    for (let mip = 0; mip < levels; mip++) {
-      const levelInfo = ktx2File.getImageLevelInfo(mip, 0, 0);
-      const mipWidth = levelInfo.origWidth;
-      const mipHeight = levelInfo.origHeight;
-      const dst = new Uint8Array(ktx2File.getImageTranscodedSizeInBytes(mip, 0, 0, transcoderFormat));
-      const status = ktx2File.transcodeImage(dst, mip, 0, 0, transcoderFormat, 0, -1, -1);
-      if (!status) {
-        cleanup();
-        throw new Error("THREE.KTX2Loader: .transcodeImage failed.");
-      }
-      mipmaps.push({ data: dst, width: mipWidth, height: mipHeight });
-    }
-    cleanup();
-    return { width, height, hasAlpha, mipmaps, format: engineFormat, dfdTransferFn, dfdFlags };
-  }
-  const 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],
-      engineFormat: [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
-    }
-  ];
-  const ETC1S_OPTIONS = FORMAT_OPTIONS.sort(function(a, b) {
-    return a.priorityETC1S - b.priorityETC1S;
-  });
-  const UASTC_OPTIONS = FORMAT_OPTIONS.sort(function(a, b) {
-    return a.priorityUASTC - b.priorityUASTC;
-  });
-  function getTranscoderFormat(basisFormat, width, height, hasAlpha) {
-    let transcoderFormat;
-    let engineFormat;
-    const options = basisFormat === BasisFormat.ETC1S ? ETC1S_OPTIONS : UASTC_OPTIONS;
-    for (let i = 0; i < options.length; i++) {
-      const opt = options[i];
-      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;
-      transcoderFormat = opt.transcoderFormat[hasAlpha ? 1 : 0];
-      engineFormat = opt.engineFormat[hasAlpha ? 1 : 0];
-      return { transcoderFormat, engineFormat };
-    }
-    console.warn("THREE.KTX2Loader: No suitable compressed texture format found. Decoding to RGBA32.");
-    transcoderFormat = TranscoderFormat.RGBA32;
-    engineFormat = EngineFormat.RGBAFormat;
-    return { transcoderFormat, engineFormat };
-  }
-  function isPowerOfTwo(value) {
-    if (value <= 2)
-      return true;
-    return (value & value - 1) === 0 && value !== 0;
-  }
-};
-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
-};
-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
-};
-const ENCODING_MAP = {
-  [VK_FORMAT_R8G8B8A8_SRGB]: sRGBEncoding,
-  [VK_FORMAT_R8G8_SRGB]: sRGBEncoding,
-  [VK_FORMAT_R8_SRGB]: sRGBEncoding
-};
-async function createDataTexture(container) {
-  const { vkFormat, pixelWidth, pixelHeight, pixelDepth } = container;
-  if (FORMAT_MAP[vkFormat] === void 0) {
-    throw new Error("THREE.KTX2Loader: Unsupported vkFormat.");
-  }
-  const level = container.levels[0];
-  let levelData;
-  let view;
-  if (container.supercompressionScheme === KHR_SUPERCOMPRESSION_NONE) {
-    levelData = level.levelData;
-  } else if (container.supercompressionScheme === KHR_SUPERCOMPRESSION_ZSTD) {
-    if (!_zstd) {
-      _zstd = new Promise(async (resolve) => {
-        const zstd = new ZSTDDecoder();
-        await zstd.init();
-        resolve(zstd);
-      });
-    }
-    levelData = (await _zstd).decode(level.levelData, level.uncompressedByteLength);
-  } else {
-    throw new Error("THREE.KTX2Loader: Unsupported supercompressionScheme.");
-  }
-  if (TYPE_MAP[vkFormat] === FloatType) {
-    view = new Float32Array(
-      levelData.buffer,
-      levelData.byteOffset,
-      levelData.byteLength / Float32Array.BYTES_PER_ELEMENT
-    );
-  } else if (TYPE_MAP[vkFormat] === HalfFloatType) {
-    view = new Uint16Array(levelData.buffer, levelData.byteOffset, levelData.byteLength / Uint16Array.BYTES_PER_ELEMENT);
-  } else {
-    view = levelData;
-  }
-  const texture = pixelDepth === 0 ? new DataTexture(view, pixelWidth, pixelHeight) : new Data3DTexture(view, pixelWidth, pixelHeight, pixelDepth);
-  texture.type = TYPE_MAP[vkFormat];
-  texture.format = FORMAT_MAP[vkFormat];
-  texture.encoding = ENCODING_MAP[vkFormat] || LinearEncoding;
-  texture.needsUpdate = true;
-  return Promise.resolve(texture);
-}
-export {
-  KTX2Loader
-};

package/loaders/KTXLoader.mjs

@@ -1,87 +0,0 @@
-import { CompressedTextureLoader } from "three";
-class KTXLoader extends CompressedTextureLoader {
-  constructor(manager) {
-    super(manager);
-  }
-  parse(buffer, loadMipmaps) {
-    const ktx = new KhronosTextureContainer(buffer, 1);
-    return {
-      mipmaps: ktx.mipmaps(loadMipmaps),
-      width: ktx.pixelWidth,
-      height: ktx.pixelHeight,
-      format: ktx.glInternalFormat,
-      isCubemap: ktx.numberOfFaces === 6,
-      mipmapCount: ktx.numberOfMipmapLevels
-    };
-  }
-}
-const HEADER_LEN = 12 + 13 * 4;
-const COMPRESSED_2D = 0;
-class KhronosTextureContainer {
-  constructor(arrayBuffer, facesExpected) {
-    this.arrayBuffer = arrayBuffer;
-    const identifier = new Uint8Array(this.arrayBuffer, 0, 12);
-    if (identifier[0] !== 171 || identifier[1] !== 75 || identifier[2] !== 84 || identifier[3] !== 88 || identifier[4] !== 32 || identifier[5] !== 49 || identifier[6] !== 49 || identifier[7] !== 187 || identifier[8] !== 13 || identifier[9] !== 10 || identifier[10] !== 26 || identifier[11] !== 10) {
-      console.error("texture missing KTX identifier");
-      return;
-    }
-    const dataSize = Uint32Array.BYTES_PER_ELEMENT;
-    const headerDataView = new DataView(this.arrayBuffer, 12, 13 * dataSize);
-    const endianness = headerDataView.getUint32(0, true);
-    const littleEndian = endianness === 67305985;
-    this.glType = headerDataView.getUint32(1 * dataSize, littleEndian);
-    this.glTypeSize = headerDataView.getUint32(2 * dataSize, littleEndian);
-    this.glFormat = headerDataView.getUint32(3 * dataSize, littleEndian);
-    this.glInternalFormat = headerDataView.getUint32(4 * dataSize, littleEndian);
-    this.glBaseInternalFormat = headerDataView.getUint32(5 * dataSize, littleEndian);
-    this.pixelWidth = headerDataView.getUint32(6 * dataSize, littleEndian);
-    this.pixelHeight = headerDataView.getUint32(7 * dataSize, littleEndian);
-    this.pixelDepth = headerDataView.getUint32(8 * dataSize, littleEndian);
-    this.numberOfArrayElements = headerDataView.getUint32(9 * dataSize, littleEndian);
-    this.numberOfFaces = headerDataView.getUint32(10 * dataSize, littleEndian);
-    this.numberOfMipmapLevels = headerDataView.getUint32(11 * dataSize, littleEndian);
-    this.bytesOfKeyValueData = headerDataView.getUint32(12 * dataSize, littleEndian);
-    if (this.glType !== 0) {
-      console.warn("only compressed formats currently supported");
-      return;
-    } else {
-      this.numberOfMipmapLevels = Math.max(1, this.numberOfMipmapLevels);
-    }
-    if (this.pixelHeight === 0 || this.pixelDepth !== 0) {
-      console.warn("only 2D textures currently supported");
-      return;
-    }
-    if (this.numberOfArrayElements !== 0) {
-      console.warn("texture arrays not currently supported");
-      return;
-    }
-    if (this.numberOfFaces !== facesExpected) {
-      console.warn("number of faces expected" + facesExpected + ", but found " + this.numberOfFaces);
-      return;
-    }
-    this.loadType = COMPRESSED_2D;
-  }
-  mipmaps(loadMipmaps) {
-    const mipmaps = [];
-    let dataOffset = HEADER_LEN + this.bytesOfKeyValueData;
-    let width = this.pixelWidth;
-    let height = this.pixelHeight;
-    const mipmapCount = loadMipmaps ? this.numberOfMipmapLevels : 1;
-    for (let level = 0; level < mipmapCount; level++) {
-      const imageSize = new Int32Array(this.arrayBuffer, dataOffset, 1)[0];
-      dataOffset += 4;
-      for (let face = 0; face < this.numberOfFaces; face++) {
-        const byteArray = new Uint8Array(this.arrayBuffer, dataOffset, imageSize);
-        mipmaps.push({ data: byteArray, width, height });
-        dataOffset += imageSize;
-        dataOffset += 3 - (imageSize + 3) % 4;
-      }
-      width = Math.max(1, width * 0.5);
-      height = Math.max(1, height * 0.5);
-    }
-    return mipmaps;
-  }
-}
-export {
-  KTXLoader
-};