three-stdlib 2.15.0 → 2.15.2

package/loaders/KTX2Loader.mjs

@@ -0,0 +1,427 @@
+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.js

@@ -1,17 +1,10 @@
-import { CompressedTextureLoader } from 'three';
-
-/**
- * for description see https://www.khronos.org/opengles/sdk/tools/KTX/
- * for file layout see https://www.khronos.org/opengles/sdk/tools/KTX/file_format_spec/
- *
- * ported from https://github.com/BabylonJS/Babylon.js/blob/master/src/Tools/babylon.khronosTextureContainer.ts
- */
-
-class KTXLoader extends CompressedTextureLoader {
+"use strict";
+Object.defineProperties(exports, { __esModule: { value: true }, [Symbol.toStringTag]: { value: "Module" } });
+const THREE = require("three");
+class KTXLoader extends THREE.CompressedTextureLoader {
   constructor(manager) {
     super(manager);
   }
-
   parse(buffer, loadMipmaps) {
     const ktx = new KhronosTextureContainer(buffer, 1);
     return {
@@ -23,127 +16,72 @@ class KTXLoader extends CompressedTextureLoader {
       mipmapCount: ktx.numberOfMipmapLevels
     };
   }
-
 }
-
-const HEADER_LEN = 12 + 13 * 4; // identifier + header elements (not including key value meta-data pairs)
-// load types
-
-const COMPRESSED_2D = 0; // uses a gl.compressedTexImage2D()
-//const COMPRESSED_3D = 1; // uses a gl.compressedTexImage3D()
-//const TEX_2D = 2; // uses a gl.texImage2D()
-//const TEX_3D = 3; // uses a gl.texImage3D()
-
+const HEADER_LEN = 12 + 13 * 4;
+const COMPRESSED_2D = 0;
 class KhronosTextureContainer {
-  /**
-   * @param {ArrayBuffer} arrayBuffer- contents of the KTX container file
-   * @param {number} facesExpected- should be either 1 or 6, based whether a cube texture or or
-   * @param {boolean} threeDExpected- provision for indicating that data should be a 3D texture, not implemented
-   * @param {boolean} textureArrayExpected- provision for indicating that data should be a texture array, not implemented
-   */
-  constructor(arrayBuffer, facesExpected
-  /*, threeDExpected, textureArrayExpected */
-  ) {
-    this.arrayBuffer = arrayBuffer; // Test that it is a ktx formatted file, based on the first 12 bytes, character representation is:
-    // '´', 'K', 'T', 'X', ' ', '1', '1', 'ª', '\r', '\n', '\x1A', '\n'
-    // 0xAB, 0x4B, 0x54, 0x58, 0x20, 0x31, 0x31, 0xBB, 0x0D, 0x0A, 0x1A, 0x0A
-
+  constructor(arrayBuffer, facesExpected) {
+    this.arrayBuffer = arrayBuffer;
     const identifier = new Uint8Array(this.arrayBuffer, 0, 12);
-
-    if (identifier[0] !== 0xab || identifier[1] !== 0x4b || identifier[2] !== 0x54 || identifier[3] !== 0x58 || identifier[4] !== 0x20 || identifier[5] !== 0x31 || identifier[6] !== 0x31 || identifier[7] !== 0xbb || identifier[8] !== 0x0d || identifier[9] !== 0x0a || identifier[10] !== 0x1a || identifier[11] !== 0x0a) {
-      console.error('texture missing KTX identifier');
+    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;
-    } // load the reset of the header in native 32 bit uint
-
-
+    }
     const dataSize = Uint32Array.BYTES_PER_ELEMENT;
     const headerDataView = new DataView(this.arrayBuffer, 12, 13 * dataSize);
     const endianness = headerDataView.getUint32(0, true);
-    const littleEndian = endianness === 0x04030201;
-    this.glType = headerDataView.getUint32(1 * dataSize, littleEndian); // must be 0 for compressed textures
-
-    this.glTypeSize = headerDataView.getUint32(2 * dataSize, littleEndian); // must be 1 for compressed textures
-
-    this.glFormat = headerDataView.getUint32(3 * dataSize, littleEndian); // must be 0 for compressed textures
-
-    this.glInternalFormat = headerDataView.getUint32(4 * dataSize, littleEndian); // the value of arg passed to gl.compressedTexImage2D(,,x,,,,)
-
-    this.glBaseInternalFormat = headerDataView.getUint32(5 * dataSize, littleEndian); // specify GL_RGB, GL_RGBA, GL_ALPHA, etc (un-compressed only)
-
-    this.pixelWidth = headerDataView.getUint32(6 * dataSize, littleEndian); // level 0 value of arg passed to gl.compressedTexImage2D(,,,x,,,)
-
-    this.pixelHeight = headerDataView.getUint32(7 * dataSize, littleEndian); // level 0 value of arg passed to gl.compressedTexImage2D(,,,,x,,)
-
-    this.pixelDepth = headerDataView.getUint32(8 * dataSize, littleEndian); // level 0 value of arg passed to gl.compressedTexImage3D(,,,,,x,,)
-
-    this.numberOfArrayElements = headerDataView.getUint32(9 * dataSize, littleEndian); // used for texture arrays
-
-    this.numberOfFaces = headerDataView.getUint32(10 * dataSize, littleEndian); // used for cubemap textures, should either be 1 or 6
-
-    this.numberOfMipmapLevels = headerDataView.getUint32(11 * dataSize, littleEndian); // number of levels; disregard possibility of 0 for compressed textures
-
-    this.bytesOfKeyValueData = headerDataView.getUint32(12 * dataSize, littleEndian); // the amount of space after the header for meta-data
-    // Make sure we have a compressed type.  Not only reduces work, but probably better to let dev know they are not compressing.
-
+    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');
+      console.warn("only compressed formats currently supported");
       return;
     } else {
-      // value of zero is an indication to generate mipmaps @ runtime.  Not usually allowed for compressed, so disregard.
       this.numberOfMipmapLevels = Math.max(1, this.numberOfMipmapLevels);
     }
-
     if (this.pixelHeight === 0 || this.pixelDepth !== 0) {
-      console.warn('only 2D textures currently supported');
+      console.warn("only 2D textures currently supported");
       return;
     }
-
     if (this.numberOfArrayElements !== 0) {
-      console.warn('texture arrays not currently supported');
+      console.warn("texture arrays not currently supported");
       return;
     }
-
     if (this.numberOfFaces !== facesExpected) {
-      console.warn('number of faces expected' + facesExpected + ', but found ' + this.numberOfFaces);
+      console.warn("number of faces expected" + facesExpected + ", but found " + this.numberOfFaces);
       return;
-    } // we now have a completely validated file, so could use existence of loadType as success
-    // would need to make this more elaborate & adjust checks above to support more than one load type
-
-
+    }
     this.loadType = COMPRESSED_2D;
   }
-
   mipmaps(loadMipmaps) {
-    const mipmaps = []; // initialize width & height for level 1
-
+    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]; // size per face, since not supporting array cubemaps
-
-      dataOffset += 4; // size of the image + 4 for the imageSize field
-
+      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: width,
-          height: height
-        });
+        mipmaps.push({ data: byteArray, width, height });
         dataOffset += imageSize;
-        dataOffset += 3 - (imageSize + 3) % 4; // add padding for odd sized image
+        dataOffset += 3 - (imageSize + 3) % 4;
       }
-
-      width = Math.max(1.0, width * 0.5);
-      height = Math.max(1.0, height * 0.5);
+      width = Math.max(1, width * 0.5);
+      height = Math.max(1, height * 0.5);
     }
-
     return mipmaps;
   }
-
 }
-
-export { KTXLoader };
+exports.KTXLoader = KTXLoader;