@predy-js/render-interface 0.3.0-beta.195 → 0.3.0-beta.197

package/dist/index.mjs

@@ -2,7 +2,7 @@
  * Name: @predy-js/render-interface
  * Description: undefined
  * Author: undefined
- * Version: v0.3.0-beta.195
+ * Version: v0.3.0-beta.197
  */
 
 /******************************************************************************
@@ -151,7 +151,7 @@ var TextureSourceType;
 
 var GPUBufferOptionsMemoryShared = 1 << 1;
 
-var _a$7, _b$3;
+var _a$6, _b$3;
 // @ts-expect-error safe to assign
 var constants = {};
 if (typeof WebGL2RenderingContext === 'function') {
@@ -204,15 +204,15 @@ function copy(target) {
         }
     }
 }
-var map = (_a$7 = {},
-    _a$7[constants.INT] = Int32Array,
-    _a$7[constants.FLOAT] = Float32Array,
-    _a$7[constants.SHORT] = Int16Array,
-    _a$7[constants.BYTE] = Int8Array,
-    _a$7[constants.UNSIGNED_BYTE] = Uint8Array,
-    _a$7[constants.UNSIGNED_INT] = Uint32Array,
-    _a$7[constants.UNSIGNED_SHORT] = Uint16Array,
-    _a$7);
+var map = (_a$6 = {},
+    _a$6[constants.INT] = Int32Array,
+    _a$6[constants.FLOAT] = Float32Array,
+    _a$6[constants.SHORT] = Int16Array,
+    _a$6[constants.BYTE] = Int8Array,
+    _a$6[constants.UNSIGNED_BYTE] = Uint8Array,
+    _a$6[constants.UNSIGNED_INT] = Uint32Array,
+    _a$6[constants.UNSIGNED_SHORT] = Uint16Array,
+    _a$6);
 function getBytesPerElementByGLType(type) {
     var _a;
     return ((_a = map[type]) === null || _a === void 0 ? void 0 : _a.BYTES_PER_ELEMENT) || 0;
@@ -1267,9 +1267,9 @@ function requestAnimationFrame(cb) {
     return window.requestAnimationFrame(cb);
 }
 
-var _a$6;
-var DATA_DICT = (_a$6 = {},
-    _a$6[constants.FLOAT] = {
+var _a$5;
+var DATA_DICT = (_a$5 = {},
+    _a$5[constants.FLOAT] = {
         name: constants.FLOAT,
         uniform: function (gl, info, value) {
             if (value.length != undefined) {
@@ -1280,79 +1280,79 @@ var DATA_DICT = (_a$6 = {},
             }
         },
     },
-    _a$6[constants.FLOAT_VEC2] = {
+    _a$5[constants.FLOAT_VEC2] = {
         name: constants.FLOAT_VEC2,
         uniform: function (gl, info, value) {
             gl.uniform2fv(info.loc, value);
         },
     },
-    _a$6[constants.FLOAT_VEC3] = {
+    _a$5[constants.FLOAT_VEC3] = {
         name: constants.FLOAT_VEC3,
         uniform: function (gl, info, value) {
             gl.uniform3fv(info.loc, value);
         },
     },
-    _a$6[constants.FLOAT_VEC4] = {
+    _a$5[constants.FLOAT_VEC4] = {
         name: constants.FLOAT_VEC4,
         uniform: function (gl, info, value) {
             gl.uniform4fv(info.loc, value);
         },
     },
-    _a$6[constants.FLOAT_MAT2] = {
+    _a$5[constants.FLOAT_MAT2] = {
         name: constants.FLOAT_MAT2,
         uniform: function (gl, info, value) {
             gl.uniformMatrix2fv(info.loc, false, value);
         },
     },
-    _a$6[constants.FLOAT_MAT2x3] = {
+    _a$5[constants.FLOAT_MAT2x3] = {
         name: constants.FLOAT_MAT2x3,
         uniform: function (gl, info, value) {
             gl.uniformMatrix2x3fv(info.loc, false, value);
         },
     },
-    _a$6[constants.FLOAT_MAT2x4] = {
+    _a$5[constants.FLOAT_MAT2x4] = {
         name: constants.FLOAT_MAT2x4,
         uniform: function (gl, info, value) {
             gl.uniformMatrix2x3fv(info.loc, false, value);
         },
     },
-    _a$6[constants.FLOAT_MAT3] = {
+    _a$5[constants.FLOAT_MAT3] = {
         name: constants.FLOAT_MAT3,
         uniform: function (gl, info, value) {
             gl.uniformMatrix3fv(info.loc, false, value);
         },
     },
-    _a$6[constants.FLOAT_MAT3x2] = {
+    _a$5[constants.FLOAT_MAT3x2] = {
         name: constants.FLOAT_MAT3x2,
         uniform: function (gl, info, value) {
             gl.uniformMatrix3x2fv(info.loc, false, value);
         },
     },
-    _a$6[constants.FLOAT_MAT3x4] = {
+    _a$5[constants.FLOAT_MAT3x4] = {
         name: constants.FLOAT_MAT3x4,
         uniform: function (gl, info, value) {
             gl.uniformMatrix3x4fv(info.loc, false, value);
         },
     },
-    _a$6[constants.FLOAT_MAT4] = {
+    _a$5[constants.FLOAT_MAT4] = {
         name: constants.FLOAT_MAT4,
         uniform: function (gl, info, value) {
             gl.uniformMatrix4fv(info.loc, false, value);
         },
     },
-    _a$6[constants.FLOAT_MAT4x3] = {
+    _a$5[constants.FLOAT_MAT4x3] = {
         name: constants.FLOAT_MAT4x3,
         uniform: function (gl, info, value) {
             gl.uniformMatrix4x3fv(info.loc, false, value);
         },
     },
-    _a$6[constants.FLOAT_MAT4x2] = {
+    _a$5[constants.FLOAT_MAT4x2] = {
         name: constants.FLOAT_MAT4x2,
         uniform: function (gl, info, value) {
             gl.uniformMatrix4x2fv(info.loc, false, value);
         },
     },
-    _a$6[constants.INT] = {
+    _a$5[constants.INT] = {
         name: constants.INT,
         uniform: function (gl, info, value) {
             if (value.length != undefined) {
@@ -1363,49 +1363,49 @@ var DATA_DICT = (_a$6 = {},
             }
         },
     },
-    _a$6[constants.INT_VEC2] = {
+    _a$5[constants.INT_VEC2] = {
         name: constants.INT_VEC2,
         uniform: function (gl, info, value) {
             gl.uniform2iv(info.loc, value);
         },
     },
-    _a$6[constants.INT_VEC3] = {
+    _a$5[constants.INT_VEC3] = {
         name: constants.INT_VEC3,
         uniform: function (gl, info, value) {
             gl.uniform3iv(info.loc, value);
         },
     },
-    _a$6[constants.INT_VEC4] = {
+    _a$5[constants.INT_VEC4] = {
         name: constants.INT_VEC4,
         uniform: function (gl, info, value) {
             gl.uniform4iv(info.loc, value);
         },
     },
-    _a$6[constants.UNSIGNED_INT] = {
+    _a$5[constants.UNSIGNED_INT] = {
         name: constants.UNSIGNED_INT,
         uniform: function (gl, info, value) {
             gl.uniform1uiv(info.loc, value);
         },
     },
-    _a$6[constants.UNSIGNED_INT_VEC2] = {
+    _a$5[constants.UNSIGNED_INT_VEC2] = {
         name: constants.UNSIGNED_INT_VEC2,
         uniform: function (gl, info, value) {
             gl.uniform2uiv(info.loc, value);
         },
     },
-    _a$6[constants.UNSIGNED_INT_VEC3] = {
+    _a$5[constants.UNSIGNED_INT_VEC3] = {
         name: constants.UNSIGNED_INT_VEC3,
         uniform: function (gl, info, value) {
             gl.uniform3uiv(info.loc, value);
         },
     },
-    _a$6[constants.UNSIGNED_INT_VEC4] = {
+    _a$5[constants.UNSIGNED_INT_VEC4] = {
         name: constants.UNSIGNED_INT_VEC4,
         uniform: function (gl, info, value) {
             gl.uniform4uiv(info.loc, value);
         },
     },
-    _a$6[constants.BOOL] = {
+    _a$5[constants.BOOL] = {
         name: constants.BOOL,
         uniform: function (gl, info, value) {
             if (value.length != undefined) {
@@ -1416,33 +1416,33 @@ var DATA_DICT = (_a$6 = {},
             }
         },
     },
-    _a$6[constants.BOOL_VEC2] = {
+    _a$5[constants.BOOL_VEC2] = {
         name: constants.BOOL_VEC2,
         uniform: function (gl, info, value) {
             gl.uniform2iv(info.loc, value);
         },
     },
-    _a$6[constants.BOOL_VEC4] = {
+    _a$5[constants.BOOL_VEC4] = {
         name: constants.BOOL_VEC4,
         uniform: function (gl, info, value) {
             gl.uniform4iv(info.loc, value);
         },
     },
-    _a$6[constants.BOOL_VEC3] = {
+    _a$5[constants.BOOL_VEC3] = {
         name: constants.BOOL_VEC3,
         uniform: function (gl, info, value) {
             gl.uniform3iv(info.loc, value);
         },
     },
-    _a$6[constants.SAMPLER_2D] = {
+    _a$5[constants.SAMPLER_2D] = {
         name: constants.SAMPLER_2D,
         uniform: assignTexUniform,
     },
-    _a$6[constants.SAMPLER_CUBE] = {
+    _a$5[constants.SAMPLER_CUBE] = {
         name: constants.SAMPLER_CUBE,
         uniform: assignTexUniform,
     },
-    _a$6);
+    _a$5);
 function assignTexUniform(gl, info, value, renderer) {
     if (value) {
         if (info.size > 1) {
@@ -1476,7 +1476,7 @@ function assignTextureLoc(gl, info, value, renderer, index) {
     }
 }
 
-var _a$5, _b$2;
+var _a$4, _b$2;
 var BlockUniformInfoOffset = 1;
 var BlockUniformInfoByteLength = 8;
 var BlockUniformInfoType = 0;
@@ -1589,35 +1589,35 @@ var arrSetter = function (type) { return function setArray(value, info, name, ra
 var setFloat32Array = arrSetter(Float32Array);
 var setInt32Array = arrSetter(Int32Array);
 var setUInt8Array = arrSetter(Uint8Array);
-var MemorySetter = (_a$5 = {},
-    _a$5[constants.FLOAT] = numberSetter(Float32Array),
-    _a$5[constants.INT] = numberSetter(Int32Array),
-    _a$5[constants.UNSIGNED_INT] = numberSetter(Uint32Array),
-    _a$5[constants.SHORT] = numberSetter(Int16Array),
-    _a$5[constants.BOOL] = numberSetter(Uint8Array),
-    _a$5[constants.UNSIGNED_SHORT] = numberSetter(Uint16Array),
-    _a$5[constants.FLOAT_VEC2] = setFloat32Array,
-    _a$5[constants.FLOAT_VEC3] = setFloat32Array,
-    _a$5[constants.FLOAT_VEC4] = setFloat32Array,
-    _a$5[constants.FLOAT_MAT2] = setFloat32Array,
-    _a$5[constants.FLOAT_MAT3] = setFloat32Array,
-    _a$5[constants.FLOAT_MAT4] = setFloat32Array,
-    _a$5[constants.FLOAT_MAT2x3] = setFloat32Array,
-    _a$5[constants.FLOAT_MAT2x4] = setFloat32Array,
-    _a$5[constants.FLOAT_MAT4x3] = setFloat32Array,
-    _a$5[constants.FLOAT_MAT4x2] = setFloat32Array,
-    _a$5[constants.FLOAT_MAT3x4] = setFloat32Array,
-    _a$5[constants.FLOAT_MAT3x2] = setFloat32Array,
-    _a$5[constants.INT_VEC2] = setInt32Array,
-    _a$5[constants.INT_VEC3] = setInt32Array,
-    _a$5[constants.INT_VEC4] = setInt32Array,
-    _a$5[constants.UNSIGNED_INT_VEC2] = setInt32Array,
-    _a$5[constants.UNSIGNED_INT_VEC3] = setInt32Array,
-    _a$5[constants.UNSIGNED_INT_VEC4] = setInt32Array,
-    _a$5[constants.BOOL_VEC2] = setUInt8Array,
-    _a$5[constants.BOOL_VEC3] = setUInt8Array,
-    _a$5[constants.BOOL_VEC4] = setUInt8Array,
-    _a$5);
+var MemorySetter = (_a$4 = {},
+    _a$4[constants.FLOAT] = numberSetter(Float32Array),
+    _a$4[constants.INT] = numberSetter(Int32Array),
+    _a$4[constants.UNSIGNED_INT] = numberSetter(Uint32Array),
+    _a$4[constants.SHORT] = numberSetter(Int16Array),
+    _a$4[constants.BOOL] = numberSetter(Uint8Array),
+    _a$4[constants.UNSIGNED_SHORT] = numberSetter(Uint16Array),
+    _a$4[constants.FLOAT_VEC2] = setFloat32Array,
+    _a$4[constants.FLOAT_VEC3] = setFloat32Array,
+    _a$4[constants.FLOAT_VEC4] = setFloat32Array,
+    _a$4[constants.FLOAT_MAT2] = setFloat32Array,
+    _a$4[constants.FLOAT_MAT3] = setFloat32Array,
+    _a$4[constants.FLOAT_MAT4] = setFloat32Array,
+    _a$4[constants.FLOAT_MAT2x3] = setFloat32Array,
+    _a$4[constants.FLOAT_MAT2x4] = setFloat32Array,
+    _a$4[constants.FLOAT_MAT4x3] = setFloat32Array,
+    _a$4[constants.FLOAT_MAT4x2] = setFloat32Array,
+    _a$4[constants.FLOAT_MAT3x4] = setFloat32Array,
+    _a$4[constants.FLOAT_MAT3x2] = setFloat32Array,
+    _a$4[constants.INT_VEC2] = setInt32Array,
+    _a$4[constants.INT_VEC3] = setInt32Array,
+    _a$4[constants.INT_VEC4] = setInt32Array,
+    _a$4[constants.UNSIGNED_INT_VEC2] = setInt32Array,
+    _a$4[constants.UNSIGNED_INT_VEC3] = setInt32Array,
+    _a$4[constants.UNSIGNED_INT_VEC4] = setInt32Array,
+    _a$4[constants.BOOL_VEC2] = setUInt8Array,
+    _a$4[constants.BOOL_VEC3] = setUInt8Array,
+    _a$4[constants.BOOL_VEC4] = setUInt8Array,
+    _a$4);
 var ItemPerValueMap = (_b$2 = {},
     _b$2[constants.FLOAT] = 1,
     _b$2[constants.INT] = 1,
@@ -1970,21 +1970,21 @@ var GLProgram = /** @class */ (function () {
     return GLProgram;
 }());
 
-var _a$4;
+var _a$3;
 var ShaderType;
 (function (ShaderType) {
     ShaderType[ShaderType["vertex"] = 0] = "vertex";
     ShaderType[ShaderType["fragment"] = 1] = "fragment";
 })(ShaderType || (ShaderType = {}));
-var downgradeKeywords = (_a$4 = {},
-    _a$4[ShaderType.vertex] = {
+var downgradeKeywords = (_a$3 = {},
+    _a$3[ShaderType.vertex] = {
         in: 'attribute',
         out: 'varying',
     },
-    _a$4[ShaderType.fragment] = {
+    _a$3[ShaderType.fragment] = {
         in: 'varying',
     },
-    _a$4);
+    _a$3);
 var shaderSeed = 1;
 var GLShaderLibrary = /** @class */ (function () {
     function GLShaderLibrary(renderer) {
@@ -2462,7 +2462,7 @@ function registerCompressedTexture(gl) {
     return 0;
 }
 
-var _a$3, _b$1;
+var _a$2, _b$1;
 var flipCanvas;
 var imageBitMapAvailable$1 = typeof ImageBitmap === 'function' && typeof createImageBitmap == 'function';
 var GLTexture = /** @class */ (function () {
@@ -2799,14 +2799,14 @@ function nearestPowerOfTwo(value) {
 function isPowerOfTwo(value) {
     return (value & (value - 1)) === 0 && value !== 0;
 }
-var FORMAT_HALF_FLOAT = (_a$3 = {},
-    _a$3[constants.RGBA] = 34842,
-    _a$3[constants.RGB] = 34843,
-    _a$3[constants.ALPHA] = 33325,
-    _a$3[constants.RED] = 33325,
-    _a$3[constants.LUMINANCE_ALPHA] = 33327,
-    _a$3[constants.LUMINANCE] = 33325,
-    _a$3);
+var FORMAT_HALF_FLOAT = (_a$2 = {},
+    _a$2[constants.RGBA] = 34842,
+    _a$2[constants.RGB] = 34843,
+    _a$2[constants.ALPHA] = 33325,
+    _a$2[constants.RED] = 33325,
+    _a$2[constants.LUMINANCE_ALPHA] = 33327,
+    _a$2[constants.LUMINANCE] = 33325,
+    _a$2);
 var FORMAT_FLOAT = (_b$1 = {},
     _b$1[constants.RGBA] = 34836,
     _b$1[constants.RGB] = 34837,
@@ -3601,394 +3601,110 @@ function loadImageAsync(imgOrURL, options) {
     });
 }
 
-///////////////////////////////////////////////////
-// KTX2 Header.
-///////////////////////////////////////////////////
-const KHR_SUPERCOMPRESSION_NONE = 0;
-///////////////////////////////////////////////////
-// Data Format Descriptor (DFD).
-///////////////////////////////////////////////////
-const KHR_DF_KHR_DESCRIPTORTYPE_BASICFORMAT = 0;
-const KHR_DF_VENDORID_KHRONOS = 0;
-const KHR_DF_VERSION = 2;
-const KHR_DF_MODEL_UNSPECIFIED = 0;
-const KHR_DF_FLAG_ALPHA_STRAIGHT = 0;
-const KHR_DF_TRANSFER_SRGB = 2;
-const KHR_DF_PRIMARIES_BT709 = 1;
-const KHR_DF_SAMPLE_DATATYPE_SIGNED = 0x40;
-///////////////////////////////////////////////////
-// VK FORMAT.
-///////////////////////////////////////////////////
-const VK_FORMAT_UNDEFINED = 0;
-const VK_FORMAT_ASTC_4x4_UNORM_BLOCK = 157;
-const VK_FORMAT_ASTC_4x4_SRGB_BLOCK = 158;
-const VK_FORMAT_ASTC_5x4_UNORM_BLOCK = 159;
-const VK_FORMAT_ASTC_5x4_SRGB_BLOCK = 160;
-const VK_FORMAT_ASTC_5x5_UNORM_BLOCK = 161;
-const VK_FORMAT_ASTC_5x5_SRGB_BLOCK = 162;
-const VK_FORMAT_ASTC_6x5_UNORM_BLOCK = 163;
-const VK_FORMAT_ASTC_6x5_SRGB_BLOCK = 164;
-const VK_FORMAT_ASTC_6x6_UNORM_BLOCK = 165;
-const VK_FORMAT_ASTC_6x6_SRGB_BLOCK = 166;
-const VK_FORMAT_ASTC_8x5_UNORM_BLOCK = 167;
-const VK_FORMAT_ASTC_8x5_SRGB_BLOCK = 168;
-const VK_FORMAT_ASTC_8x6_UNORM_BLOCK = 169;
-const VK_FORMAT_ASTC_8x6_SRGB_BLOCK = 170;
-const VK_FORMAT_ASTC_8x8_UNORM_BLOCK = 171;
-const VK_FORMAT_ASTC_8x8_SRGB_BLOCK = 172;
-const VK_FORMAT_ASTC_10x5_UNORM_BLOCK = 173;
-const VK_FORMAT_ASTC_10x5_SRGB_BLOCK = 174;
-const VK_FORMAT_ASTC_10x6_UNORM_BLOCK = 175;
-const VK_FORMAT_ASTC_10x6_SRGB_BLOCK = 176;
-const VK_FORMAT_ASTC_10x8_UNORM_BLOCK = 177;
-const VK_FORMAT_ASTC_10x8_SRGB_BLOCK = 178;
-const VK_FORMAT_ASTC_10x10_UNORM_BLOCK = 179;
-const VK_FORMAT_ASTC_10x10_SRGB_BLOCK = 180;
-const VK_FORMAT_ASTC_12x10_UNORM_BLOCK = 181;
-const VK_FORMAT_ASTC_12x10_SRGB_BLOCK = 182;
-const VK_FORMAT_ASTC_12x12_UNORM_BLOCK = 183;
-const VK_FORMAT_ASTC_12x12_SRGB_BLOCK = 184;
-
-/**
- * Represents an unpacked KTX 2.0 texture container. Data for individual mip levels are stored in
- * the `.levels` array, typically compressed in Basis Universal formats. Additional properties
- * provide metadata required to process, transcode, and upload these textures.
- */
-class KTX2Container {
-  constructor() {
-    /**
-     * Specifies the image format using Vulkan VkFormat enum values. When using Basis Universal
-     * texture formats, `vkFormat` must be VK_FORMAT_UNDEFINED.
-     */
-    this.vkFormat = VK_FORMAT_UNDEFINED;
-    /**
-     * Size of the data type in bytes used to upload the data to a graphics API. When `vkFormat` is
-     * VK_FORMAT_UNDEFINED, `typeSize` must be 1.
-     */
-    this.typeSize = 1;
-    /** Width of the texture image for level 0, in pixels. */
-    this.pixelWidth = 0;
-    /** Height of the texture image for level 0, in pixels. */
-    this.pixelHeight = 0;
-    /** Depth of the texture image for level 0, in pixels (3D textures only). */
-    this.pixelDepth = 0;
-    /** Number of array elements (array textures only). */
-    this.layerCount = 0;
-    /**
-     * Number of cubemap faces. For cubemaps and cubemap arrays, `faceCount` must be 6. For all
-     * other textures, `faceCount` must be 1. Cubemap faces are stored in +X, -X, +Y, -Y, +Z, -Z
-     * order.
-     */
-    this.faceCount = 1;
-    /** Indicates which supercompression scheme has been applied to mip level images, if any. */
-    this.supercompressionScheme = KHR_SUPERCOMPRESSION_NONE;
-    /** Mip levels, ordered largest (original) to smallest (~1px). */
-    this.levels = [];
-    /** Data Format Descriptor. */
-    this.dataFormatDescriptor = [{
-      vendorId: KHR_DF_VENDORID_KHRONOS,
-      descriptorType: KHR_DF_KHR_DESCRIPTORTYPE_BASICFORMAT,
-      descriptorBlockSize: 0,
-      versionNumber: KHR_DF_VERSION,
-      colorModel: KHR_DF_MODEL_UNSPECIFIED,
-      colorPrimaries: KHR_DF_PRIMARIES_BT709,
-      transferFunction: KHR_DF_TRANSFER_SRGB,
-      flags: KHR_DF_FLAG_ALPHA_STRAIGHT,
-      texelBlockDimension: [0, 0, 0, 0],
-      bytesPlane: [0, 0, 0, 0, 0, 0, 0, 0],
-      samples: []
-    }];
-    /** Key/Value Data. */
-    this.keyValue = {};
-    /** Supercompression Global Data. */
-    this.globalData = null;
-  }
-}
-
-class BufferReader {
-  constructor(data, byteOffset, byteLength, littleEndian) {
-    this._dataView = void 0;
-    this._littleEndian = void 0;
-    this._offset = void 0;
-    this._dataView = new DataView(data.buffer, data.byteOffset + byteOffset, byteLength);
-    this._littleEndian = littleEndian;
-    this._offset = 0;
-  }
-  _nextUint8() {
-    const value = this._dataView.getUint8(this._offset);
-    this._offset += 1;
-    return value;
-  }
-  _nextUint16() {
-    const value = this._dataView.getUint16(this._offset, this._littleEndian);
-    this._offset += 2;
-    return value;
-  }
-  _nextUint32() {
-    const value = this._dataView.getUint32(this._offset, this._littleEndian);
-    this._offset += 4;
-    return value;
-  }
-  _nextUint64() {
-    const left = this._dataView.getUint32(this._offset, this._littleEndian);
-    const right = this._dataView.getUint32(this._offset + 4, this._littleEndian);
-    // TODO(cleanup): Just test this...
-    // const value = this._littleEndian ? left + (2 ** 32 * right) : (2 ** 32 * left) + right;
-    const value = left + 2 ** 32 * right;
-    this._offset += 8;
-    return value;
-  }
-  _nextInt32() {
-    const value = this._dataView.getInt32(this._offset, this._littleEndian);
-    this._offset += 4;
-    return value;
-  }
-  _nextUint8Array(len) {
-    const value = new Uint8Array(this._dataView.buffer, this._dataView.byteOffset + this._offset, len);
-    this._offset += len;
-    return value;
-  }
-  _skip(bytes) {
-    this._offset += bytes;
-    return this;
-  }
-  _scan(maxByteLength, term = 0x00) {
-    const byteOffset = this._offset;
-    let byteLength = 0;
-    while (this._dataView.getUint8(this._offset) !== term && byteLength < maxByteLength) {
-      byteLength++;
-      this._offset++;
-    }
-    if (byteLength < maxByteLength) this._offset++;
-    return new Uint8Array(this._dataView.buffer, this._dataView.byteOffset + byteOffset, byteLength);
-  }
-}
-///////////////////////////////////////////////////
-// KTX2 Header.
-///////////////////////////////////////////////////
-const KTX2_ID = [
-// '´', 'K', 'T', 'X', '2', '0', 'ª', '\r', '\n', '\x1A', '\n'
-0xab, 0x4b, 0x54, 0x58, 0x20, 0x32, 0x30, 0xbb, 0x0d, 0x0a, 0x1a, 0x0a];
-/** Decodes an ArrayBuffer to text. */
-function decodeText(buffer) {
-  return new TextDecoder().decode(buffer);
-}
-
-/**
- * Parses a KTX 2.0 file, returning an unpacked {@link KTX2Container} instance with all associated
- * data. The container's mip levels and other binary data are pointers into the original file, not
- * copies, so the original file should not be overwritten after reading.
- *
- * @param data Bytes of KTX 2.0 file, as Uint8Array or Buffer.
- */
-function read(data) {
-  ///////////////////////////////////////////////////
-  // KTX 2.0 Identifier.
-  ///////////////////////////////////////////////////
-  const id = new Uint8Array(data.buffer, data.byteOffset, KTX2_ID.length);
-  if (id[0] !== KTX2_ID[0] ||
-  // '´'
-  id[1] !== KTX2_ID[1] ||
-  // 'K'
-  id[2] !== KTX2_ID[2] ||
-  // 'T'
-  id[3] !== KTX2_ID[3] ||
-  // 'X'
-  id[4] !== KTX2_ID[4] ||
-  // ' '
-  id[5] !== KTX2_ID[5] ||
-  // '2'
-  id[6] !== KTX2_ID[6] ||
-  // '0'
-  id[7] !== KTX2_ID[7] ||
-  // 'ª'
-  id[8] !== KTX2_ID[8] ||
-  // '\r'
-  id[9] !== KTX2_ID[9] ||
-  // '\n'
-  id[10] !== KTX2_ID[10] ||
-  // '\x1A'
-  id[11] !== KTX2_ID[11] // '\n'
-  ) {
-    throw new Error('Missing KTX 2.0 identifier.');
-  }
-  const container = new KTX2Container();
-  ///////////////////////////////////////////////////
-  // Header.
-  ///////////////////////////////////////////////////
-  const headerByteLength = 17 * Uint32Array.BYTES_PER_ELEMENT;
-  const headerReader = new BufferReader(data, KTX2_ID.length, headerByteLength, true);
-  container.vkFormat = headerReader._nextUint32();
-  container.typeSize = headerReader._nextUint32();
-  container.pixelWidth = headerReader._nextUint32();
-  container.pixelHeight = headerReader._nextUint32();
-  container.pixelDepth = headerReader._nextUint32();
-  container.layerCount = headerReader._nextUint32();
-  container.faceCount = headerReader._nextUint32();
-  const levelCount = headerReader._nextUint32();
-  container.supercompressionScheme = headerReader._nextUint32();
-  const dfdByteOffset = headerReader._nextUint32();
-  const dfdByteLength = headerReader._nextUint32();
-  const kvdByteOffset = headerReader._nextUint32();
-  const kvdByteLength = headerReader._nextUint32();
-  const sgdByteOffset = headerReader._nextUint64();
-  const sgdByteLength = headerReader._nextUint64();
-  ///////////////////////////////////////////////////
-  // Level Index.
-  ///////////////////////////////////////////////////
-  const levelByteLength = levelCount * 3 * 8;
-  const levelReader = new BufferReader(data, KTX2_ID.length + headerByteLength, levelByteLength, true);
-  for (let i = 0; i < levelCount; i++) {
-    container.levels.push({
-      levelData: new Uint8Array(data.buffer, data.byteOffset + levelReader._nextUint64(), levelReader._nextUint64()),
-      uncompressedByteLength: levelReader._nextUint64()
-    });
-  }
-  ///////////////////////////////////////////////////
-  // Data Format Descriptor (DFD).
-  ///////////////////////////////////////////////////
-  const dfdReader = new BufferReader(data, dfdByteOffset, dfdByteLength, true);
-  const dfd = {
-    vendorId: dfdReader._skip(4 /* totalSize */)._nextUint16(),
-    descriptorType: dfdReader._nextUint16(),
-    versionNumber: dfdReader._nextUint16(),
-    descriptorBlockSize: dfdReader._nextUint16(),
-    colorModel: dfdReader._nextUint8(),
-    colorPrimaries: dfdReader._nextUint8(),
-    transferFunction: dfdReader._nextUint8(),
-    flags: dfdReader._nextUint8(),
-    texelBlockDimension: [dfdReader._nextUint8(), dfdReader._nextUint8(), dfdReader._nextUint8(), dfdReader._nextUint8()],
-    bytesPlane: [dfdReader._nextUint8(), dfdReader._nextUint8(), dfdReader._nextUint8(), dfdReader._nextUint8(), dfdReader._nextUint8(), dfdReader._nextUint8(), dfdReader._nextUint8(), dfdReader._nextUint8()],
-    samples: []
-  };
-  const sampleStart = 6;
-  const sampleWords = 4;
-  const numSamples = (dfd.descriptorBlockSize / 4 - sampleStart) / sampleWords;
-  for (let i = 0; i < numSamples; i++) {
-    const sample = {
-      bitOffset: dfdReader._nextUint16(),
-      bitLength: dfdReader._nextUint8(),
-      channelType: dfdReader._nextUint8(),
-      samplePosition: [dfdReader._nextUint8(), dfdReader._nextUint8(), dfdReader._nextUint8(), dfdReader._nextUint8()],
-      sampleLower: -Infinity,
-      sampleUpper: Infinity
-    };
-    if (sample.channelType & KHR_DF_SAMPLE_DATATYPE_SIGNED) {
-      sample.sampleLower = dfdReader._nextInt32();
-      sample.sampleUpper = dfdReader._nextInt32();
-    } else {
-      sample.sampleLower = dfdReader._nextUint32();
-      sample.sampleUpper = dfdReader._nextUint32();
-    }
-    dfd.samples[i] = sample;
-  }
-  container.dataFormatDescriptor.length = 0;
-  container.dataFormatDescriptor.push(dfd);
-  ///////////////////////////////////////////////////
-  // Key/Value Data (KVD).
-  ///////////////////////////////////////////////////
-  const kvdReader = new BufferReader(data, kvdByteOffset, kvdByteLength, true);
-  while (kvdReader._offset < kvdByteLength) {
-    const keyValueByteLength = kvdReader._nextUint32();
-    const keyData = kvdReader._scan(keyValueByteLength);
-    const key = decodeText(keyData);
-    container.keyValue[key] = kvdReader._nextUint8Array(keyValueByteLength - keyData.byteLength - 1);
-    if (key.match(/^ktx/i)) {
-      const text = decodeText(container.keyValue[key]);
-      container.keyValue[key] = text.substring(0, text.lastIndexOf('\x00'));
+var HEADER_LEN = 12 + 13 * 4; // identifier + header elements (not including key value meta-data pairs)
+var COMPRESSED_2D = 0; // uses a gl.compressedTexImage2D()
+//const COMPRESSED_3D = 1; // uses a gl.compressedTexImage3D()
+var TEX_2D = 2; // uses a gl.texImage2D()
+//const TEX_3D = 3; // uses a gl.texImage3D()
+var KhronosTextureContainer = /** @class */ (function () {
+    function KhronosTextureContainer(arrayBuffer, facesExpected, baseOffset) {
+        if (baseOffset === void 0) { baseOffset = 0; }
+        this.arrayBuffer = arrayBuffer;
+        this.baseOffset = baseOffset;
+        // 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
+        var identifier = new Uint8Array(this.arrayBuffer, this.baseOffset, 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) {
+            throw Error('texture missing KTX identifier');
+        }
+        // load the reset of the header in native 32 bit uint
+        var dataSize = Uint32Array.BYTES_PER_ELEMENT;
+        var headerDataView = new DataView(this.arrayBuffer, this.baseOffset + 12, 13 * dataSize);
+        var endianness = headerDataView.getUint32(0, true);
+        var 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
+        // 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) {
+            //consoleWarn('only 2D textures currently supported');
+            return;
+        }
+        if (this.numberOfArrayElements !== 0) {
+            //consoleWarn('texture arrays not currently supported');
+            return;
+        }
+        if (this.numberOfFaces !== facesExpected) {
+            //consoleWarn('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
+        if (this.glType === 0) {
+            this.loadType = COMPRESSED_2D;
+        }
+        else {
+            this.loadType = TEX_2D;
+        }
     }
-    const kvPadding = keyValueByteLength % 4 ? 4 - keyValueByteLength % 4 : 0; // align(4)
-    // 4-byte alignment.
-    kvdReader._skip(kvPadding);
-  }
-  ///////////////////////////////////////////////////
-  // Supercompression Global Data (SGD).
-  ///////////////////////////////////////////////////
-  if (sgdByteLength <= 0) return container;
-  const sgdReader = new BufferReader(data, sgdByteOffset, sgdByteLength, true);
-  const endpointCount = sgdReader._nextUint16();
-  const selectorCount = sgdReader._nextUint16();
-  const endpointsByteLength = sgdReader._nextUint32();
-  const selectorsByteLength = sgdReader._nextUint32();
-  const tablesByteLength = sgdReader._nextUint32();
-  const extendedByteLength = sgdReader._nextUint32();
-  const imageDescs = [];
-  for (let i = 0; i < levelCount; i++) {
-    imageDescs.push({
-      imageFlags: sgdReader._nextUint32(),
-      rgbSliceByteOffset: sgdReader._nextUint32(),
-      rgbSliceByteLength: sgdReader._nextUint32(),
-      alphaSliceByteOffset: sgdReader._nextUint32(),
-      alphaSliceByteLength: sgdReader._nextUint32()
-    });
-  }
-  const endpointsByteOffset = sgdByteOffset + sgdReader._offset;
-  const selectorsByteOffset = endpointsByteOffset + endpointsByteLength;
-  const tablesByteOffset = selectorsByteOffset + selectorsByteLength;
-  const extendedByteOffset = tablesByteOffset + tablesByteLength;
-  const endpointsData = new Uint8Array(data.buffer, data.byteOffset + endpointsByteOffset, endpointsByteLength);
-  const selectorsData = new Uint8Array(data.buffer, data.byteOffset + selectorsByteOffset, selectorsByteLength);
-  const tablesData = new Uint8Array(data.buffer, data.byteOffset + tablesByteOffset, tablesByteLength);
-  const extendedData = new Uint8Array(data.buffer, data.byteOffset + extendedByteOffset, extendedByteLength);
-  container.globalData = {
-    endpointCount,
-    selectorCount,
-    imageDescs,
-    endpointsData,
-    selectorsData,
-    tablesData,
-    extendedData
-  };
-  return container;
-}
-
-var _a$2;
-var formatMap = (_a$2 = {},
-    _a$2[VK_FORMAT_ASTC_4x4_SRGB_BLOCK] = [constants.UNSIGNED_BYTE, constants.COMPRESSED_SRGB8_ALPHA8_ASTC_4x4_KHR],
-    _a$2[VK_FORMAT_ASTC_4x4_UNORM_BLOCK] = [constants.UNSIGNED_BYTE, constants.COMPRESSED_RGBA_ASTC_4x4_KHR],
-    _a$2[VK_FORMAT_ASTC_6x6_SRGB_BLOCK] = [constants.UNSIGNED_BYTE, constants.COMPRESSED_SRGB8_ALPHA8_ASTC_6x6_KHR],
-    _a$2[VK_FORMAT_ASTC_6x6_UNORM_BLOCK] = [constants.UNSIGNED_BYTE, constants.COMPRESSED_RGBA_ASTC_6x6_KHR],
-    _a$2[VK_FORMAT_ASTC_8x8_SRGB_BLOCK] = [constants.UNSIGNED_BYTE, constants.COMPRESSED_SRGB8_ALPHA8_ASTC_8x8_KHR],
-    _a$2[VK_FORMAT_ASTC_8x8_UNORM_BLOCK] = [constants.UNSIGNED_BYTE, constants.COMPRESSED_RGBA_ASTC_8x8_KHR],
-    _a$2[VK_FORMAT_ASTC_10x10_SRGB_BLOCK] = [constants.UNSIGNED_BYTE, constants.COMPRESSED_SRGB8_ALPHA8_ASTC_10x10_KHR],
-    _a$2[VK_FORMAT_ASTC_10x10_UNORM_BLOCK] = [constants.UNSIGNED_BYTE, constants.COMPRESSED_RGBA_ASTC_10x10_KHR],
-    _a$2[VK_FORMAT_ASTC_12x12_SRGB_BLOCK] = [constants.UNSIGNED_BYTE, constants.COMPRESSED_SRGB8_ALPHA8_ASTC_12x12_KHR],
-    _a$2[VK_FORMAT_ASTC_12x12_UNORM_BLOCK] = [constants.UNSIGNED_BYTE, constants.COMPRESSED_RGBA_ASTC_12x12_KHR],
-    _a$2[VK_FORMAT_ASTC_5x5_SRGB_BLOCK] = [constants.UNSIGNED_BYTE, constants.COMPRESSED_SRGB8_ALPHA8_ASTC_5x5_KHR],
-    _a$2[VK_FORMAT_ASTC_5x5_UNORM_BLOCK] = [constants.UNSIGNED_BYTE, constants.COMPRESSED_RGBA_ASTC_5x5_KHR],
-    _a$2[VK_FORMAT_ASTC_5x4_SRGB_BLOCK] = [constants.UNSIGNED_BYTE, constants.COMPRESSED_SRGB8_ALPHA8_ASTC_5x4_KHR],
-    _a$2[VK_FORMAT_ASTC_5x4_UNORM_BLOCK] = [constants.UNSIGNED_BYTE, constants.COMPRESSED_RGBA_ASTC_5x4_KHR],
-    _a$2[VK_FORMAT_ASTC_6x5_SRGB_BLOCK] = [constants.UNSIGNED_BYTE, constants.COMPRESSED_SRGB8_ALPHA8_ASTC_6x5_KHR],
-    _a$2[VK_FORMAT_ASTC_6x5_UNORM_BLOCK] = [constants.UNSIGNED_BYTE, constants.COMPRESSED_RGBA_ASTC_6x5_KHR],
-    _a$2[VK_FORMAT_ASTC_10x5_SRGB_BLOCK] = [constants.UNSIGNED_BYTE, constants.COMPRESSED_SRGB8_ALPHA8_ASTC_10x5_KHR],
-    _a$2[VK_FORMAT_ASTC_10x5_UNORM_BLOCK] = [constants.UNSIGNED_BYTE, constants.COMPRESSED_RGBA_ASTC_10x5_KHR],
-    _a$2[VK_FORMAT_ASTC_8x6_SRGB_BLOCK] = [constants.UNSIGNED_BYTE, constants.COMPRESSED_SRGB8_ALPHA8_ASTC_8x6_KHR],
-    _a$2[VK_FORMAT_ASTC_8x6_UNORM_BLOCK] = [constants.UNSIGNED_BYTE, constants.COMPRESSED_RGBA_ASTC_8x6_KHR],
-    _a$2[VK_FORMAT_ASTC_10x6_SRGB_BLOCK] = [constants.UNSIGNED_BYTE, constants.COMPRESSED_SRGB8_ALPHA8_ASTC_10x6_KHR],
-    _a$2[VK_FORMAT_ASTC_10x6_UNORM_BLOCK] = [constants.UNSIGNED_BYTE, constants.COMPRESSED_RGBA_ASTC_10x6_KHR],
-    _a$2[VK_FORMAT_ASTC_8x5_SRGB_BLOCK] = [constants.UNSIGNED_BYTE, constants.COMPRESSED_SRGB8_ALPHA8_ASTC_8x5_KHR],
-    _a$2[VK_FORMAT_ASTC_8x5_UNORM_BLOCK] = [constants.UNSIGNED_BYTE, constants.COMPRESSED_RGBA_ASTC_8x5_KHR],
-    _a$2[VK_FORMAT_ASTC_12x10_SRGB_BLOCK] = [constants.UNSIGNED_BYTE, constants.COMPRESSED_SRGB8_ALPHA8_ASTC_12x10_KHR],
-    _a$2[VK_FORMAT_ASTC_12x10_UNORM_BLOCK] = [constants.UNSIGNED_BYTE, constants.COMPRESSED_RGBA_ASTC_12x10_KHR],
-    _a$2[VK_FORMAT_ASTC_10x8_SRGB_BLOCK] = [constants.UNSIGNED_BYTE, constants.COMPRESSED_SRGB8_ALPHA8_ASTC_10x8_KHR],
-    _a$2[VK_FORMAT_ASTC_10x8_UNORM_BLOCK] = [constants.UNSIGNED_BYTE, constants.COMPRESSED_RGBA_ASTC_10x8_KHR],
-    _a$2);
+    KhronosTextureContainer.prototype.mipmaps = function (loadMipmaps) {
+        var mipmaps = [];
+        // initialize width & height for level 1
+        var dataOffset = HEADER_LEN + this.bytesOfKeyValueData;
+        var width = this.pixelWidth;
+        var height = this.pixelHeight;
+        var mipmapCount = loadMipmaps ? this.numberOfMipmapLevels : 1;
+        for (var level = 0; level < mipmapCount; level++) {
+            var imageSize = new Int32Array(this.arrayBuffer, this.baseOffset + dataOffset, 1)[0]; // size per face, since not supporting array cubemaps
+            for (var face = 0; face < this.numberOfFaces; face++) {
+                var byteArray = new Uint8Array(this.arrayBuffer, this.baseOffset + dataOffset + 4, imageSize);
+                mipmaps.push({
+                    data: byteArray,
+                    width: width,
+                    height: height,
+                });
+                dataOffset += imageSize + 4; // size of the image + 4 for the imageSize field
+                dataOffset += 3 - ((imageSize + 3) % 4); // add padding for odd sized image
+            }
+            width = Math.max(1.0, width * 0.5);
+            height = Math.max(1.0, height * 0.5);
+        }
+        return mipmaps;
+    };
+    return KhronosTextureContainer;
+}());
 function getCompressedTextureOptions(data) {
-    var container = read(data);
-    var width = container.pixelWidth;
-    var height = container.pixelHeight;
-    var pair = formatMap[container.vkFormat];
+    var ktx = new KhronosTextureContainer(data, 1);
+    var useMipmaps = ktx.numberOfMipmapLevels >= Math.floor(Math.log2(Math.max(ktx.pixelWidth, ktx.pixelHeight)) + 1);
     return {
         sourceType: TextureSourceType.compressed,
-        target: container.faceCount === 6 ? constants.TEXTURE_CUBE_MAP : constants.TEXTURE_2D,
-        format: pair[1],
-        internalFormat: pair[1],
-        type: pair[0],
-        mipmaps: container.levels.map(function (level, i) { return ({
-            data: level.levelData,
-            width: width >> i,
-            height: height >> i,
-        }); }),
+        type: constants.UNSIGNED_BYTE,
+        target: ktx.numberOfFaces === 6 ? constants.TEXTURE_CUBE_MAP : constants.TEXTURE_2D,
+        format: ktx.glInternalFormat,
+        internalFormat: ktx.glInternalFormat,
+        mipmaps: ktx.mipmaps(useMipmaps),
     };
 }
 
@@ -4079,7 +3795,7 @@ var MarsTextureFactory = /** @class */ (function () {
         }
         else if (sourceFrom.type === TextureSourceType.compressed) {
             return this.requestBinaryAsync(sourceFrom.url).then(function (arrayBuffer) {
-                return Object.assign(getCompressedTextureOptions(new Uint8Array(arrayBuffer)), config, {
+                return Object.assign(getCompressedTextureOptions(arrayBuffer), config, {
                     sourceFrom: { url: sourceFrom.url, type: TextureSourceType.compressed },
                 });
             }, catchError);
@@ -4178,7 +3894,7 @@ var MarsTextureFactory = /** @class */ (function () {
         return Promise.all(map.map(function (key) { return _this.loadImageAsync(key); }));
     };
     MarsTextureFactory.prototype.loadCompressedTextureFromArrayBuffer = function (arrayBuffer, options) {
-        return Object.assign(getCompressedTextureOptions(new Uint8Array(arrayBuffer)), options);
+        return Object.assign(getCompressedTextureOptions(arrayBuffer), options);
     };
     MarsTextureFactory.prototype.reloadTextureAsync = function (texture) {
         var _this = this;
@@ -6177,7 +5893,7 @@ var MarsSharedGeometry = /** @class */ (function (_super) {
     return MarsSharedGeometry;
 }(MarsGeometry));
 
-consoleLog('version: ' + "0.3.0-beta.195");
+consoleLog('version: ' + "0.3.0-beta.197");
 var ModuleMsg = 'RI Package: @predy-js/render-interface';
 
 var RI = /*#__PURE__*/Object.freeze({