@loaders.gl/textures 3.1.0-alpha.5 → 3.1.0-beta.5

package/dist/lib/parsers/parse-basis.js

@@ -0,0 +1,245 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.selectSupportedBasisFormat = void 0;
+const basis_module_loader_1 = require("./basis-module-loader");
+const gl_extensions_1 = require("../gl-extensions");
+const texture_formats_1 = require("../utils/texture-formats");
+const parse_ktx_1 = require("./parse-ktx");
+const OutputFormat = {
+    etc1: {
+        basisFormat: 0,
+        compressed: true,
+        format: gl_extensions_1.GL_EXTENSIONS_CONSTANTS.COMPRESSED_RGB_ETC1_WEBGL
+    },
+    etc2: { basisFormat: 1, compressed: true },
+    bc1: {
+        basisFormat: 2,
+        compressed: true,
+        format: gl_extensions_1.GL_EXTENSIONS_CONSTANTS.COMPRESSED_RGB_S3TC_DXT1_EXT
+    },
+    bc3: {
+        basisFormat: 3,
+        compressed: true,
+        format: gl_extensions_1.GL_EXTENSIONS_CONSTANTS.COMPRESSED_RGBA_S3TC_DXT5_EXT
+    },
+    bc4: { basisFormat: 4, compressed: true },
+    bc5: { basisFormat: 5, compressed: true },
+    'bc7-m6-opaque-only': { basisFormat: 6, compressed: true },
+    'bc7-m5': { basisFormat: 7, compressed: true },
+    'pvrtc1-4-rgb': {
+        basisFormat: 8,
+        compressed: true,
+        format: gl_extensions_1.GL_EXTENSIONS_CONSTANTS.COMPRESSED_RGB_PVRTC_4BPPV1_IMG
+    },
+    'pvrtc1-4-rgba': {
+        basisFormat: 9,
+        compressed: true,
+        format: gl_extensions_1.GL_EXTENSIONS_CONSTANTS.COMPRESSED_RGBA_PVRTC_4BPPV1_IMG
+    },
+    'astc-4x4': {
+        basisFormat: 10,
+        compressed: true,
+        format: gl_extensions_1.GL_EXTENSIONS_CONSTANTS.COMPRESSED_RGBA_ASTC_4X4_KHR
+    },
+    'atc-rgb': { basisFormat: 11, compressed: true },
+    'atc-rgba-interpolated-alpha': { basisFormat: 12, compressed: true },
+    rgba32: { basisFormat: 13, compressed: false },
+    rgb565: { basisFormat: 14, compressed: false },
+    bgr565: { basisFormat: 15, compressed: false },
+    rgba4444: { basisFormat: 16, compressed: false }
+};
+/**
+ * parse data with a Binomial Basis_Universal module
+ * @param {ArrayBuffer} data
+ * @param {*} options
+ * @returns compressed texture data
+ */
+async function parseBasis(data, options) {
+    if (options.basis.containerFormat === 'auto') {
+        if ((0, parse_ktx_1.isKTX)(data)) {
+            const fileConstructors = await (0, basis_module_loader_1.loadBasisEncoderModule)(options);
+            return parseKTX2File(fileConstructors.KTX2File, data, options);
+        }
+        const { BasisFile } = await (0, basis_module_loader_1.loadBasisTrascoderModule)(options);
+        return parseBasisFile(BasisFile, data, options);
+    }
+    switch (options.basis.module) {
+        case 'encoder':
+            const fileConstructors = await (0, basis_module_loader_1.loadBasisEncoderModule)(options);
+            switch (options.basis.containerFormat) {
+                case 'ktx2':
+                    return parseKTX2File(fileConstructors.KTX2File, data, options);
+                case 'basis':
+                default:
+                    return parseBasisFile(fileConstructors.BasisFile, data, options);
+            }
+        case 'transcoder':
+        default:
+            const { BasisFile } = await (0, basis_module_loader_1.loadBasisTrascoderModule)(options);
+            return parseBasisFile(BasisFile, data, options);
+    }
+}
+exports.default = parseBasis;
+/**
+ * Parse *.basis file data
+ * @param {*} BasisFile - initialized transcoder module
+ * @param {*} data
+ * @param {*} options
+ * @returns compressed texture data
+ */
+function parseBasisFile(BasisFile, data, options) {
+    const basisFile = new BasisFile(new Uint8Array(data));
+    try {
+        if (!basisFile.startTranscoding()) {
+            return null;
+        }
+        const imageCount = basisFile.getNumImages();
+        const images = [];
+        for (let imageIndex = 0; imageIndex < imageCount; imageIndex++) {
+            const levelsCount = basisFile.getNumLevels(imageIndex);
+            const levels = [];
+            for (let levelIndex = 0; levelIndex < levelsCount; levelIndex++) {
+                levels.push(transcodeImage(basisFile, imageIndex, levelIndex, options));
+            }
+            images.push(levels);
+        }
+        return images;
+    }
+    finally {
+        basisFile.close();
+        basisFile.delete();
+    }
+}
+/**
+ * Parse the particular level image of a basis file
+ * @param {*} basisFile
+ * @param {*} imageIndex
+ * @param {*} levelIndex
+ * @param {*} options
+ * @returns compressed texture data
+ */
+function transcodeImage(basisFile, imageIndex, levelIndex, options) {
+    const width = basisFile.getImageWidth(imageIndex, levelIndex);
+    const height = basisFile.getImageHeight(imageIndex, levelIndex);
+    // See https://github.com/BinomialLLC/basis_universal/pull/83
+    const hasAlpha = basisFile.getHasAlpha( /* imageIndex, levelIndex */);
+    // Check options for output format etc
+    const { compressed, format, basisFormat } = getBasisOptions(options, hasAlpha);
+    const decodedSize = basisFile.getImageTranscodedSizeInBytes(imageIndex, levelIndex, basisFormat);
+    const decodedData = new Uint8Array(decodedSize);
+    if (!basisFile.transcodeImage(decodedData, imageIndex, levelIndex, basisFormat, 0, 0)) {
+        return null;
+    }
+    return {
+        // standard loaders.gl image category payload
+        width,
+        height,
+        data: decodedData,
+        compressed,
+        // Additional fields
+        // Add levelSize field.
+        hasAlpha,
+        format
+    };
+}
+/**
+ * Parse *.ktx2 file data
+ * @param {*} KTX2File
+ * @param {*} data
+ * @param {*} options
+ * @returns compressed texture data
+ */
+function parseKTX2File(KTX2File, data, options) {
+    const ktx2File = new KTX2File(new Uint8Array(data));
+    try {
+        if (!ktx2File.startTranscoding()) {
+            return null;
+        }
+        const levelsCount = ktx2File.getLevels();
+        const levels = [];
+        for (let levelIndex = 0; levelIndex < levelsCount; levelIndex++) {
+            levels.push(transcodeKTX2Image(ktx2File, levelIndex, options));
+            break; // texture app can only show one level for some reason
+        }
+        return levels;
+    }
+    finally {
+        ktx2File.close();
+        ktx2File.delete();
+    }
+}
+/**
+ * Parse the particular level image of a ktx2 file
+ * @param {*} ktx2File
+ * @param {*} levelIndex
+ * @param {*} options
+ * @returns
+ */
+function transcodeKTX2Image(ktx2File, levelIndex, options) {
+    const { alphaFlag, height, width } = ktx2File.getImageLevelInfo(levelIndex, 0, 0);
+    // Check options for output format etc
+    const { compressed, format, basisFormat } = getBasisOptions(options, alphaFlag);
+    const decodedSize = ktx2File.getImageTranscodedSizeInBytes(levelIndex, 0 /* layerIndex */, 0 /* faceIndex */, basisFormat);
+    const decodedData = new Uint8Array(decodedSize);
+    if (!ktx2File.transcodeImage(decodedData, levelIndex, 0 /* layerIndex */, 0 /* faceIndex */, basisFormat, 0, -1 /* channel0 */, -1 /* channel1 */)) {
+        return null;
+    }
+    return {
+        // standard loaders.gl image category payload
+        width,
+        height,
+        data: decodedData,
+        compressed,
+        // Additional fields
+        // Add levelSize field.
+        alphaFlag,
+        format
+    };
+}
+/**
+ * Get BasisFormat by loader format option
+ * @param {*} options
+ * @param {*} hasAlpha
+ * @returns BasisFormat data
+ */
+function getBasisOptions(options, hasAlpha) {
+    let format = options && options.basis && options.basis.format;
+    if (format === 'auto') {
+        format = selectSupportedBasisFormat();
+    }
+    if (typeof format === 'object') {
+        format = hasAlpha ? format.alpha : format.noAlpha;
+    }
+    format = format.toLowerCase();
+    return OutputFormat[format];
+}
+/**
+ * Select transcode format from the list of supported formats
+ * @returns key for OutputFormat map
+ */
+function selectSupportedBasisFormat() {
+    const supportedFormats = (0, texture_formats_1.getSupportedGPUTextureFormats)();
+    if (supportedFormats.has('astc')) {
+        return 'astc-4x4';
+    }
+    else if (supportedFormats.has('dxt')) {
+        return {
+            alpha: 'bc3',
+            noAlpha: 'bc1'
+        };
+    }
+    else if (supportedFormats.has('pvrtc')) {
+        return {
+            alpha: 'pvrtc1-4-rgba',
+            noAlpha: 'pvrtc1-4-rgb'
+        };
+    }
+    else if (supportedFormats.has('etc1')) {
+        return 'etc1';
+    }
+    else if (supportedFormats.has('etc2')) {
+        return 'etc2';
+    }
+    return 'rgb565';
+}
+exports.selectSupportedBasisFormat = selectSupportedBasisFormat;

package/dist/lib/parsers/parse-compressed-texture.d.ts

@@ -5,3 +5,4 @@ import type { TextureLevel } from '../../types';
  * @returns Array of the texture levels
  */
 export declare function parseCompressedTexture(data: ArrayBuffer): TextureLevel[];
+//# sourceMappingURL=parse-compressed-texture.d.ts.map

package/dist/lib/parsers/parse-compressed-texture.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"parse-compressed-texture.d.ts","sourceRoot":"","sources":["../../../src/lib/parsers/parse-compressed-texture.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAC,YAAY,EAAC,MAAM,aAAa,CAAC;AAK9C;;;;GAIG;AACH,wBAAgB,sBAAsB,CAAC,IAAI,EAAE,WAAW,GAAG,YAAY,EAAE,CAaxE"}

package/dist/lib/parsers/parse-compressed-texture.js

@@ -0,0 +1,26 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseCompressedTexture = void 0;
+const parse_ktx_1 = require("./parse-ktx");
+const parse_dds_1 = require("./parse-dds");
+const parse_pvr_1 = require("./parse-pvr");
+/**
+ * Deduces format and parses compressed texture loaded in ArrayBuffer
+ * @param data - binary data of compressed texture
+ * @returns Array of the texture levels
+ */
+function parseCompressedTexture(data) {
+    if ((0, parse_ktx_1.isKTX)(data)) {
+        // TODO: remove @ts-ignore when `parseKTX` output is normalized to loaders.gl texture format
+        // @ts-ignore
+        return (0, parse_ktx_1.parseKTX)(data);
+    }
+    if ((0, parse_dds_1.isDDS)(data)) {
+        return (0, parse_dds_1.parseDDS)(data);
+    }
+    if ((0, parse_pvr_1.isPVR)(data)) {
+        return (0, parse_pvr_1.parsePVR)(data);
+    }
+    throw new Error('Texture container format not recognized');
+}
+exports.parseCompressedTexture = parseCompressedTexture;

package/dist/lib/parsers/parse-crunch.d.ts

@@ -6,3 +6,4 @@ import type { TextureLevel } from '../../types';
  * @returns Promise of Array of the texture levels
  */
 export declare function parseCrunch(data: any, options: any): Promise<TextureLevel[]>;
+//# sourceMappingURL=parse-crunch.d.ts.map

package/dist/lib/parsers/parse-crunch.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"parse-crunch.d.ts","sourceRoot":"","sources":["../../../src/lib/parsers/parse-crunch.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAC,YAAY,EAAC,MAAM,aAAa,CAAC;AAqC9C;;;;;GAKG;AACH,wBAAsB,WAAW,CAAC,IAAI,KAAA,EAAE,OAAO,EAAE,GAAG,GAAG,OAAO,CAAC,YAAY,EAAE,CAAC,CAmD7E"}

package/dist/lib/parsers/parse-crunch.js

@@ -0,0 +1,105 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseCrunch = void 0;
+const crunch_module_loader_1 = require("./crunch-module-loader");
+const gl_extensions_1 = require("../gl-extensions");
+const loader_utils_1 = require("@loaders.gl/loader-utils");
+const parse_dds_1 = require("./parse-dds");
+const extract_mipmap_images_1 = require("../utils/extract-mipmap-images");
+// Taken from crnlib.h
+const CRN_FORMAT = {
+    cCRNFmtInvalid: -1,
+    cCRNFmtDXT1: 0,
+    // cCRNFmtDXT3 is not currently supported when writing to CRN - only DDS.
+    cCRNFmtDXT3: 1,
+    cCRNFmtDXT5: 2
+    // Crunch supports more formats than this.
+};
+// Mapping of Crunch formats to DXT formats.
+const DXT_FORMAT_MAP = {};
+DXT_FORMAT_MAP[CRN_FORMAT.cCRNFmtDXT1] = {
+    pixelFormat: gl_extensions_1.GL_EXTENSIONS_CONSTANTS.COMPRESSED_RGB_S3TC_DXT1_EXT,
+    sizeFunction: parse_dds_1.getDxt1LevelSize
+};
+DXT_FORMAT_MAP[CRN_FORMAT.cCRNFmtDXT3] = {
+    pixelFormat: gl_extensions_1.GL_EXTENSIONS_CONSTANTS.COMPRESSED_RGBA_S3TC_DXT3_EXT,
+    sizeFunction: parse_dds_1.getDxtXLevelSize
+};
+DXT_FORMAT_MAP[CRN_FORMAT.cCRNFmtDXT5] = {
+    pixelFormat: gl_extensions_1.GL_EXTENSIONS_CONSTANTS.COMPRESSED_RGBA_S3TC_DXT5_EXT,
+    sizeFunction: parse_dds_1.getDxtXLevelSize
+};
+let cachedDstSize = 0;
+let dst;
+/**
+ * Parse texture data as "CRN" format.
+ * Function is "async" as emscriptified decoder module is loaded asyncronously
+ * @param data - binary data of compressed texture
+ * @returns Promise of Array of the texture levels
+ */
+async function parseCrunch(data, options) {
+    const crunchModule = await (0, crunch_module_loader_1.loadCrunchModule)(options);
+    // Copy the contents of the arrayBuffer into emscriptens heap.
+    const srcSize = data.byteLength;
+    const bytes = new Uint8Array(data);
+    const src = crunchModule._malloc(srcSize);
+    arrayBufferCopy(bytes, crunchModule.HEAPU8, src, srcSize);
+    // Determine what type of compressed data the file contains.
+    const format = crunchModule._crn_get_dxt_format(src, srcSize);
+    (0, loader_utils_1.assert)(Boolean(DXT_FORMAT_MAP[format]), 'Unsupported format');
+    // Gather basic metrics about the DXT data.
+    const mipMapLevels = crunchModule._crn_get_levels(src, srcSize);
+    const width = crunchModule._crn_get_width(src, srcSize);
+    const height = crunchModule._crn_get_height(src, srcSize);
+    // const bytesPerBlock = crunchModule._crn_get_bytes_per_block(src, srcSize);
+    // Determine the size of the decoded DXT data.
+    const sizeFunction = DXT_FORMAT_MAP[format].sizeFunction;
+    let dstSize = 0;
+    for (let i = 0; i < mipMapLevels; ++i) {
+        dstSize += sizeFunction(width >> i, height >> i);
+    }
+    // Allocate enough space on the emscripten heap to hold the decoded DXT data
+    // or reuse the existing allocation if a previous call to this function has
+    // already acquired a large enough buffer.
+    if (cachedDstSize < dstSize) {
+        if (dst) {
+            crunchModule._free(dst);
+        }
+        dst = crunchModule._malloc(dstSize);
+        cachedDstSize = dstSize;
+    }
+    // Decompress the DXT data from the Crunch file into the allocated space.
+    crunchModule._crn_decompress(src, srcSize, dst, dstSize, 0, mipMapLevels);
+    // Release the crunch file data from the emscripten heap.
+    crunchModule._free(src);
+    const image = new Uint8Array(crunchModule.HEAPU8.buffer, dst, dstSize).slice();
+    return (0, extract_mipmap_images_1.extractMipmapImages)(image, {
+        mipMapLevels,
+        width,
+        height,
+        sizeFunction,
+        internalFormat: DXT_FORMAT_MAP[format].pixelFormat
+    });
+}
+exports.parseCrunch = parseCrunch;
+/**
+ * Copy an array of bytes into or out of the emscripten heap
+ * @param {Uint8Array} srcData - Source data array
+ * @param {Uint8Array} dstData - Destination data array
+ * @param {number} dstByteOffset - Destination data offset
+ * @param {number} numBytes - number of bytes to copy
+ * @returns {void}
+ */
+function arrayBufferCopy(srcData, dstData, dstByteOffset, numBytes) {
+    let i;
+    const dst32Offset = dstByteOffset / 4;
+    const tail = numBytes % 4;
+    const src32 = new Uint32Array(srcData.buffer, 0, (numBytes - tail) / 4);
+    const dst32 = new Uint32Array(dstData.buffer);
+    for (i = 0; i < src32.length; i++) {
+        dst32[dst32Offset + i] = src32[i];
+    }
+    for (i = numBytes - tail; i < numBytes; i++) {
+        dstData[dstByteOffset + i] = srcData[i];
+    }
+}

package/dist/lib/parsers/parse-dds.d.ts

@@ -25,3 +25,4 @@ export declare function getDxt1LevelSize(width: number, height: number): number;
  * @returns level size in bytes
  */
 export declare function getDxtXLevelSize(width: number, height: number): number;
+//# sourceMappingURL=parse-dds.d.ts.map

package/dist/lib/parsers/parse-dds.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"parse-dds.d.ts","sourceRoot":"","sources":["../../../src/lib/parsers/parse-dds.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAC,YAAY,EAAC,MAAM,aAAa,CAAC;AA0C9C;;;;GAIG;AACH,wBAAgB,KAAK,CAAC,IAAI,EAAE,WAAW,GAAG,OAAO,CAIhD;AAED;;;;GAIG;AACH,wBAAgB,QAAQ,CAAC,IAAI,EAAE,WAAW,GAAG,YAAY,EAAE,CA4B1D;AAED;;;;;GAKG;AACH,wBAAgB,gBAAgB,CAAC,KAAK,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,GAAG,MAAM,CAEtE;AAED;;;;;GAKG;AACH,wBAAgB,gBAAgB,CAAC,KAAK,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,GAAG,MAAM,CAEtE"}

package/dist/lib/parsers/parse-dds.js

@@ -0,0 +1,108 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getDxtXLevelSize = exports.getDxt1LevelSize = exports.parseDDS = exports.isDDS = void 0;
+const loader_utils_1 = require("@loaders.gl/loader-utils");
+const gl_extensions_1 = require("../gl-extensions");
+const extract_mipmap_images_1 = require("../utils/extract-mipmap-images");
+const DDS_CONSTANTS = {
+    MAGIC_NUMBER: 0x20534444,
+    HEADER_LENGTH: 31,
+    MAGIC_NUMBER_INDEX: 0,
+    HEADER_SIZE_INDEX: 1,
+    HEADER_FLAGS_INDEX: 2,
+    HEADER_HEIGHT_INDEX: 3,
+    HEADER_WIDTH_INDEX: 4,
+    MIPMAPCOUNT_INDEX: 7,
+    HEADER_PF_FLAGS_INDEX: 20,
+    HEADER_PF_FOURCC_INDEX: 21,
+    DDSD_MIPMAPCOUNT: 0x20000,
+    DDPF_FOURCC: 0x4
+};
+const DDS_PIXEL_FORMATS = {
+    DXT1: gl_extensions_1.GL_EXTENSIONS_CONSTANTS.COMPRESSED_RGB_S3TC_DXT1_EXT,
+    DXT3: gl_extensions_1.GL_EXTENSIONS_CONSTANTS.COMPRESSED_RGBA_S3TC_DXT3_EXT,
+    DXT5: gl_extensions_1.GL_EXTENSIONS_CONSTANTS.COMPRESSED_RGBA_S3TC_DXT5_EXT,
+    'ATC ': gl_extensions_1.GL_EXTENSIONS_CONSTANTS.COMPRESSED_RGB_ATC_WEBGL,
+    ATCA: gl_extensions_1.GL_EXTENSIONS_CONSTANTS.COMPRESSED_RGBA_ATC_EXPLICIT_ALPHA_WEBGL,
+    ATCI: gl_extensions_1.GL_EXTENSIONS_CONSTANTS.COMPRESSED_RGBA_ATC_INTERPOLATED_ALPHA_WEBGL
+};
+const getATCLevelSize = getDxt1LevelSize;
+const getATCALevelSize = getDxtXLevelSize;
+const getATCILevelSize = getDxtXLevelSize;
+const DDS_SIZE_FUNCTIONS = {
+    DXT1: getDxt1LevelSize,
+    DXT3: getDxtXLevelSize,
+    DXT5: getDxtXLevelSize,
+    'ATC ': getATCLevelSize,
+    ATCA: getATCALevelSize,
+    ATCI: getATCILevelSize
+};
+/**
+ * Check if data is in "DDS" format by its magic number
+ * @param data - binary data of compressed texture
+ * @returns true - data in "DDS" format, else - false
+ */
+function isDDS(data) {
+    const header = new Uint32Array(data, 0, DDS_CONSTANTS.HEADER_LENGTH);
+    const magic = header[DDS_CONSTANTS.MAGIC_NUMBER_INDEX];
+    return magic === DDS_CONSTANTS.MAGIC_NUMBER;
+}
+exports.isDDS = isDDS;
+/**
+ * Parse texture data as "DDS" format
+ * @param data - binary data of compressed texture
+ * @returns Array of the texture levels
+ */
+function parseDDS(data) {
+    const header = new Int32Array(data, 0, DDS_CONSTANTS.HEADER_LENGTH);
+    const pixelFormatNumber = header[DDS_CONSTANTS.HEADER_PF_FOURCC_INDEX];
+    (0, loader_utils_1.assert)(Boolean(header[DDS_CONSTANTS.HEADER_PF_FLAGS_INDEX] & DDS_CONSTANTS.DDPF_FOURCC), 'DDS: Unsupported format, must contain a FourCC code');
+    const fourCC = int32ToFourCC(pixelFormatNumber);
+    const internalFormat = DDS_PIXEL_FORMATS[fourCC];
+    const sizeFunction = DDS_SIZE_FUNCTIONS[fourCC];
+    (0, loader_utils_1.assert)(internalFormat && sizeFunction, `DDS: Unknown pixel format ${pixelFormatNumber}`);
+    let mipMapLevels = 1;
+    if (header[DDS_CONSTANTS.HEADER_FLAGS_INDEX] & DDS_CONSTANTS.DDSD_MIPMAPCOUNT) {
+        mipMapLevels = Math.max(1, header[DDS_CONSTANTS.MIPMAPCOUNT_INDEX]);
+    }
+    const width = header[DDS_CONSTANTS.HEADER_WIDTH_INDEX];
+    const height = header[DDS_CONSTANTS.HEADER_HEIGHT_INDEX];
+    const dataOffset = header[DDS_CONSTANTS.HEADER_SIZE_INDEX] + 4;
+    const image = new Uint8Array(data, dataOffset);
+    return (0, extract_mipmap_images_1.extractMipmapImages)(image, {
+        mipMapLevels,
+        width,
+        height,
+        sizeFunction,
+        internalFormat
+    });
+}
+exports.parseDDS = parseDDS;
+/**
+ * DXT1 applicable function to calculate level size
+ * @param width - level width
+ * @param height - level height
+ * @returns level size in bytes
+ */
+function getDxt1LevelSize(width, height) {
+    return ((width + 3) >> 2) * ((height + 3) >> 2) * 8;
+}
+exports.getDxt1LevelSize = getDxt1LevelSize;
+/**
+ * DXT3 & DXT5 applicable function to calculate level size
+ * @param width - level width
+ * @param height - level height
+ * @returns level size in bytes
+ */
+function getDxtXLevelSize(width, height) {
+    return ((width + 3) >> 2) * ((height + 3) >> 2) * 16;
+}
+exports.getDxtXLevelSize = getDxtXLevelSize;
+/**
+ * Convert every byte of Int32 value to char
+ * @param value - Int32 number
+ * @returns string of 4 characters
+ */
+function int32ToFourCC(value) {
+    return String.fromCharCode(value & 0xff, (value >> 8) & 0xff, (value >> 16) & 0xff, (value >> 24) & 0xff);
+}

package/dist/lib/parsers/parse-ktx.d.ts

@@ -1,2 +1,3 @@
-export function isKTX(data: any): boolean;
-export function parseKTX(arrayBuffer: any): import("../../types").TextureLevel[];
+export declare function isKTX(data: ArrayBuffer): boolean;
+export declare function parseKTX(arrayBuffer: ArrayBuffer): import("../../types").TextureLevel[];
+//# sourceMappingURL=parse-ktx.d.ts.map

package/dist/lib/parsers/parse-ktx.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"parse-ktx.d.ts","sourceRoot":"","sources":["../../../src/lib/parsers/parse-ktx.ts"],"names":[],"mappings":"AAUA,wBAAgB,KAAK,CAAC,IAAI,EAAE,WAAW,WAmBtC;AAED,wBAAgB,QAAQ,CAAC,WAAW,EAAE,WAAW,wCAehD"}

package/dist/lib/parsers/parse-ktx.js

@@ -0,0 +1,46 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseKTX = exports.isKTX = void 0;
+const ktx_parse_1 = require("ktx-parse");
+const extract_mipmap_images_1 = require("../utils/extract-mipmap-images");
+const ktx_format_helper_1 = require("../utils/ktx-format-helper");
+const KTX2_ID = [
+    // '´', 'K', 'T', 'X', '2', '0', 'ª', '\r', '\n', '\x1A', '\n'
+    0xab, 0x4b, 0x54, 0x58, 0x20, 0x32, 0x30, 0xbb, 0x0d, 0x0a, 0x1a, 0x0a
+];
+// eslint-disable-next-line complexity
+function isKTX(data) {
+    // const id = new Uint8Array(data.buffer, data.byteOffset, data.byteLength);
+    const id = new Uint8Array(data);
+    const notKTX = id.byteLength < KTX2_ID.length ||
+        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'
+    return !notKTX;
+}
+exports.isKTX = isKTX;
+function parseKTX(arrayBuffer) {
+    const uint8Array = new Uint8Array(arrayBuffer);
+    const ktx = (0, ktx_parse_1.read)(uint8Array);
+    const mipMapLevels = Math.max(1, ktx.levels.length);
+    const width = ktx.pixelWidth;
+    const height = ktx.pixelHeight;
+    const internalFormat = (0, ktx_format_helper_1.mapVkFormatToWebGL)(ktx.vkFormat);
+    return (0, extract_mipmap_images_1.extractMipmapImages)(ktx.levels, {
+        mipMapLevels,
+        width,
+        height,
+        sizeFunction: (level) => level.uncompressedByteLength,
+        internalFormat
+    });
+}
+exports.parseKTX = parseKTX;

package/dist/lib/parsers/parse-npy.d.ts

@@ -1,4 +1,10 @@
-export function parseNPY(arrayBuffer: any, options: any): {
+declare type NumpyHeader = {
+    descr: string;
+    shape: number[];
+};
+export declare function parseNPY(arrayBuffer: ArrayBuffer, options?: unknown): {
     data: any;
-    header: any;
+    header: NumpyHeader;
 } | null;
+export {};
+//# sourceMappingURL=parse-npy.d.ts.map

package/dist/lib/parsers/parse-npy.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"parse-npy.d.ts","sourceRoot":"","sources":["../../../src/lib/parsers/parse-npy.ts"],"names":[],"mappings":"AAAA,aAAK,WAAW,GAAG;IAAC,KAAK,EAAE,MAAM,CAAC;IAAC,KAAK,EAAE,MAAM,EAAE,CAAA;CAAC,CAAC;AA6BpD,wBAAgB,QAAQ,CAAC,WAAW,EAAE,WAAW,EAAE,OAAO,CAAC,EAAE,OAAO;;;SA+BnE"}

package/dist/lib/parsers/parse-npy.js

@@ -0,0 +1,85 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseNPY = void 0;
+function systemIsLittleEndian() {
+    const a = new Uint32Array([0x12345678]);
+    const b = new Uint8Array(a.buffer, a.byteOffset, a.byteLength);
+    return !(b[0] === 0x12);
+}
+const LITTLE_ENDIAN_OS = systemIsLittleEndian();
+// The basic string format consists of 3 characters:
+// 1. a character describing the byteorder of the data (<: little-endian, >: big-endian, |: not-relevant)
+// 2. a character code giving the basic type of the array
+// 3. an integer providing the number of bytes the type uses.
+// https://numpy.org/doc/stable/reference/arrays.interface.html
+//
+// Here I only include the second and third characters, and check endianness
+// separately
+const DTYPES = {
+    u1: Uint8Array,
+    i1: Int8Array,
+    u2: Uint16Array,
+    i2: Int16Array,
+    u4: Uint32Array,
+    i4: Int32Array,
+    f4: Float32Array,
+    f8: Float64Array
+};
+function parseNPY(arrayBuffer, options) {
+    if (!arrayBuffer) {
+        return null;
+    }
+    const view = new DataView(arrayBuffer);
+    const { header, headerEndOffset } = parseHeader(view);
+    const numpyType = header.descr;
+    const ArrayType = DTYPES[numpyType.slice(1, 3)];
+    if (!ArrayType) {
+        // eslint-disable-next-line no-console, no-undef
+        console.warn(`Decoding of npy dtype not implemented: ${numpyType}`);
+        return null;
+    }
+    const nArrayElements = header.shape?.reduce((a, b) => a * b);
+    const arrayByteLength = nArrayElements * ArrayType.BYTES_PER_ELEMENT;
+    const data = new ArrayType(arrayBuffer.slice(headerEndOffset, headerEndOffset + arrayByteLength));
+    // Swap endianness if needed
+    if ((numpyType[0] === '>' && LITTLE_ENDIAN_OS) || (numpyType[0] === '<' && !LITTLE_ENDIAN_OS)) {
+        // eslint-disable-next-line no-console, no-undef
+        console.warn('Data is wrong endianness, byte swapping not yet implemented.');
+    }
+    return {
+        data,
+        header
+    };
+}
+exports.parseNPY = parseNPY;
+/**
+ * Parse NPY header
+ *
+ * @param  view
+ * @return
+ */
+function parseHeader(view) {
+    const majorVersion = view.getUint8(6);
+    // const minorVersion = view.getUint8(7);
+    let offset = 8;
+    let headerLength;
+    if (majorVersion >= 2) {
+        headerLength = view.getUint32(8, true);
+        offset += 4;
+    }
+    else {
+        headerLength = view.getUint16(8, true);
+        offset += 2;
+    }
+    const encoding = majorVersion <= 2 ? 'latin1' : 'utf-8';
+    const decoder = new TextDecoder(encoding);
+    const headerArray = new Uint8Array(view.buffer, offset, headerLength);
+    const headerText = decoder.decode(headerArray);
+    offset += headerLength;
+    const header = JSON.parse(headerText
+        .replace(/'/g, '"')
+        .replace('False', 'false')
+        .replace('(', '[')
+        .replace(/,*\),*/g, ']'));
+    return { header, headerEndOffset: offset };
+}