@loaders.gl/textures 4.2.0-alpha.4 → 4.2.0-alpha.6

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

@@ -1,75 +1,104 @@
+// loaders.gl
+// SPDX-License-Identifier: MIT
+// Copyright (c) vis.gl contributors
 import { assert } from '@loaders.gl/loader-utils';
 import { GL_EXTENSIONS_CONSTANTS } from "../gl-extensions.js";
 import { extractMipmapImages } from "../utils/extract-mipmap-images.js";
 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
+    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_CONSTANTS.COMPRESSED_RGB_S3TC_DXT1_EXT,
-  DXT3: GL_EXTENSIONS_CONSTANTS.COMPRESSED_RGBA_S3TC_DXT3_EXT,
-  DXT5: GL_EXTENSIONS_CONSTANTS.COMPRESSED_RGBA_S3TC_DXT5_EXT,
-  'ATC ': GL_EXTENSIONS_CONSTANTS.COMPRESSED_RGB_ATC_WEBGL,
-  ATCA: GL_EXTENSIONS_CONSTANTS.COMPRESSED_RGBA_ATC_EXPLICIT_ALPHA_WEBGL,
-  ATCI: GL_EXTENSIONS_CONSTANTS.COMPRESSED_RGBA_ATC_INTERPOLATED_ALPHA_WEBGL
+    DXT1: GL_EXTENSIONS_CONSTANTS.COMPRESSED_RGB_S3TC_DXT1_EXT,
+    DXT3: GL_EXTENSIONS_CONSTANTS.COMPRESSED_RGBA_S3TC_DXT3_EXT,
+    DXT5: GL_EXTENSIONS_CONSTANTS.COMPRESSED_RGBA_S3TC_DXT5_EXT,
+    'ATC ': GL_EXTENSIONS_CONSTANTS.COMPRESSED_RGB_ATC_WEBGL,
+    ATCA: GL_EXTENSIONS_CONSTANTS.COMPRESSED_RGBA_ATC_EXPLICIT_ALPHA_WEBGL,
+    ATCI: 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
+    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
+ */
 export 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;
+    const header = new Uint32Array(data, 0, DDS_CONSTANTS.HEADER_LENGTH);
+    const magic = header[DDS_CONSTANTS.MAGIC_NUMBER_INDEX];
+    return magic === DDS_CONSTANTS.MAGIC_NUMBER;
 }
+/**
+ * Parse texture data as "DDS" format
+ * @param data - binary data of compressed texture
+ * @returns Array of the texture levels
+ */
 export function parseDDS(data) {
-  const header = new Int32Array(data, 0, DDS_CONSTANTS.HEADER_LENGTH);
-  const pixelFormatNumber = header[DDS_CONSTANTS.HEADER_PF_FOURCC_INDEX];
-  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];
-  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 extractMipmapImages(image, {
-    mipMapLevels,
-    width,
-    height,
-    sizeFunction,
-    internalFormat
-  });
+    const header = new Int32Array(data, 0, DDS_CONSTANTS.HEADER_LENGTH);
+    const pixelFormatNumber = header[DDS_CONSTANTS.HEADER_PF_FOURCC_INDEX];
+    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];
+    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 extractMipmapImages(image, {
+        mipMapLevels,
+        width,
+        height,
+        sizeFunction,
+        internalFormat
+    });
 }
+/**
+ * DXT1 applicable function to calculate level size
+ * @param width - level width
+ * @param height - level height
+ * @returns level size in bytes
+ */
 export function getDxt1LevelSize(width, height) {
-  return (width + 3 >> 2) * (height + 3 >> 2) * 8;
+    return ((width + 3) >> 2) * ((height + 3) >> 2) * 8;
 }
+/**
+ * DXT3 & DXT5 applicable function to calculate level size
+ * @param width - level width
+ * @param height - level height
+ * @returns level size in bytes
+ */
 export function getDxtXLevelSize(width, height) {
-  return (width + 3 >> 2) * (height + 3 >> 2) * 16;
+    return ((width + 3) >> 2) * ((height + 3) >> 2) * 16;
 }
+/**
+ * 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);
+    return String.fromCharCode(value & 0xff, (value >> 8) & 0xff, (value >> 16) & 0xff, (value >> 24) & 0xff);
 }
-//# sourceMappingURL=parse-dds.js.map

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

@@ -1,25 +1,44 @@
+// loaders.gl
+// SPDX-License-Identifier: MIT
+// Copyright (c) vis.gl contributors
 import { read } from 'ktx-parse';
 import { extractMipmapImages } from "../utils/extract-mipmap-images.js";
 import { mapVkFormatToWebGL } from "../utils/ktx-format-helper.js";
-const KTX2_ID = [0xab, 0x4b, 0x54, 0x58, 0x20, 0x32, 0x30, 0xbb, 0x0d, 0x0a, 0x1a, 0x0a];
+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
 export function isKTX(data) {
-  const id = new Uint8Array(data);
-  const notKTX = id.byteLength < KTX2_ID.length || id[0] !== KTX2_ID[0] || id[1] !== KTX2_ID[1] || id[2] !== KTX2_ID[2] || id[3] !== KTX2_ID[3] || id[4] !== KTX2_ID[4] || id[5] !== KTX2_ID[5] || id[6] !== KTX2_ID[6] || id[7] !== KTX2_ID[7] || id[8] !== KTX2_ID[8] || id[9] !== KTX2_ID[9] || id[10] !== KTX2_ID[10] || id[11] !== KTX2_ID[11];
-  return !notKTX;
+    // 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;
 }
 export function parseKTX(arrayBuffer) {
-  const uint8Array = new Uint8Array(arrayBuffer);
-  const ktx = read(uint8Array);
-  const mipMapLevels = Math.max(1, ktx.levels.length);
-  const width = ktx.pixelWidth;
-  const height = ktx.pixelHeight;
-  const internalFormat = mapVkFormatToWebGL(ktx.vkFormat);
-  return extractMipmapImages(ktx.levels, {
-    mipMapLevels,
-    width,
-    height,
-    sizeFunction: level => level.uncompressedByteLength,
-    internalFormat
-  });
+    const uint8Array = new Uint8Array(arrayBuffer);
+    const ktx = read(uint8Array);
+    const mipMapLevels = Math.max(1, ktx.levels.length);
+    const width = ktx.pixelWidth;
+    const height = ktx.pixelHeight;
+    const internalFormat = mapVkFormatToWebGL(ktx.vkFormat);
+    return extractMipmapImages(ktx.levels, {
+        mipMapLevels,
+        width,
+        height,
+        sizeFunction: (level) => level.uncompressedByteLength,
+        internalFormat
+    });
 }
-//# sourceMappingURL=parse-ktx.js.map

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

@@ -1,63 +1,80 @@
+// loaders.gl
+// SPDX-License-Identifier: MIT
+// Copyright (c) vis.gl contributors
 const a = new Uint32Array([0x12345678]);
 const b = new Uint8Array(a.buffer, a.byteOffset, a.byteLength);
 const isLittleEndian = !(b[0] === 0x12);
 const LITTLE_ENDIAN_OS = isLittleEndian;
+/**
+ * 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
+    u1: Uint8Array,
+    i1: Int8Array,
+    u2: Uint16Array,
+    i2: Int16Array,
+    u4: Uint32Array,
+    i4: Int32Array,
+    f4: Float32Array,
+    f8: Float64Array
 };
 export function parseNPY(arrayBuffer, options) {
-  var _header$shape;
-  const view = new DataView(arrayBuffer);
-  const {
-    header,
-    headerEndOffset
-  } = parseHeader(view);
-  const numpyType = header.descr;
-  const ArrayType = DTYPES[numpyType.slice(1, 3)];
-  if (!ArrayType) {
-    throw new Error(`Unimplemented type ${numpyType}`);
-  }
-  const nArrayElements = (_header$shape = header.shape) === null || _header$shape === void 0 ? void 0 : _header$shape.reduce((a, b) => a * b);
-  const arrayByteLength = nArrayElements * ArrayType.BYTES_PER_ELEMENT;
-  if (arrayBuffer.byteLength < headerEndOffset + arrayByteLength) {
-    throw new Error('Buffer overflow');
-  }
-  const data = new ArrayType(arrayBuffer.slice(headerEndOffset, headerEndOffset + arrayByteLength));
-  if (numpyType[0] === '>' && LITTLE_ENDIAN_OS || numpyType[0] === '<' && !LITTLE_ENDIAN_OS) {
-    throw new Error('Incorrect endianness');
-  }
-  return {
-    data,
-    header
-  };
+    const view = new DataView(arrayBuffer);
+    const { header, headerEndOffset } = parseHeader(view);
+    const numpyType = header.descr;
+    const ArrayType = DTYPES[numpyType.slice(1, 3)];
+    if (!ArrayType) {
+        throw new Error(`Unimplemented type ${numpyType}`);
+    }
+    const nArrayElements = header.shape?.reduce((a, b) => a * b);
+    const arrayByteLength = nArrayElements * ArrayType.BYTES_PER_ELEMENT;
+    if (arrayBuffer.byteLength < headerEndOffset + arrayByteLength) {
+        throw new Error('Buffer overflow');
+    }
+    const data = new ArrayType(arrayBuffer.slice(headerEndOffset, headerEndOffset + arrayByteLength));
+    // Swap endianness if needed
+    if ((numpyType[0] === '>' && LITTLE_ENDIAN_OS) || (numpyType[0] === '<' && !LITTLE_ENDIAN_OS)) {
+        throw new Error('Incorrect endianness');
+    }
+    return {
+        data,
+        header
+    };
 }
+/**
+ * Parse NPY header
+ *
+ * @param  view
+ * @return
+ */
 function parseHeader(view) {
-  const majorVersion = view.getUint8(6);
-  let offset = 8;
-  let headerLength;
-  if (majorVersion >= 2) {
-    headerLength = view.getUint32(offset, true);
-    offset += 4;
-  } else {
-    headerLength = view.getUint16(offset, 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
-  };
+    const majorVersion = view.getUint8(6);
+    // const minorVersion = view.getUint8(7);
+    let offset = 8;
+    let headerLength;
+    if (majorVersion >= 2) {
+        headerLength = view.getUint32(offset, true);
+        offset += 4;
+    }
+    else {
+        headerLength = view.getUint16(offset, 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 };
 }
-//# sourceMappingURL=parse-npy.js.map