@loaders.gl/textures 4.4.0-alpha.2 → 4.4.0

package/src/lib/parsers/parse-hdr.ts

@@ -0,0 +1,426 @@
+// loaders.gl
+// SPDX-License-Identifier: MIT
+// Copyright (c) vis.gl contributors
+
+import type {Texture, TextureLevel} from '@loaders.gl/schema';
+import {GL_RGBA32F} from '../gl-extensions';
+
+const HDR_MAGIC_HEADERS = ['#?RADIANCE', '#?RGBE'];
+const HDR_FORMAT = '32-bit_rle_rgbe';
+
+/** Application-facing metadata extracted from Radiance HDR header fields. */
+export type RadianceHDRMetadata = {
+  /** Per-channel color correction factors from the `COLORCORR` header field. */
+  colorCorrection?: [number, number, number];
+  /** Scene exposure multiplier from the `EXPOSURE` header field. */
+  exposure?: number;
+  /** Display gamma hint from the `GAMMA` header field. */
+  gamma?: number;
+  /** Pixel aspect ratio from the `PIXASPECT` header field. */
+  pixelAspectRatio?: number;
+  /** Chromaticity primaries and white point from the `PRIMARIES` header field. */
+  primaries?: [number, number, number, number, number, number, number, number];
+  /** Producer software identifier from the `SOFTWARE` header field. */
+  software?: string;
+  /** View specification string from the `VIEW` header field. */
+  view?: string;
+};
+
+type HeaderState = {
+  data: Uint8Array;
+  offset: number;
+};
+
+type HDRHeader = {
+  width: number;
+  height: number;
+  majorAxis: 'X' | 'Y';
+  majorSign: 1 | -1;
+  minorAxis: 'X' | 'Y';
+  minorSign: 1 | -1;
+  metadata?: RadianceHDRMetadata;
+};
+
+export function isHDR(arrayBuffer: ArrayBuffer): boolean {
+  const state: HeaderState = {
+    data: new Uint8Array(arrayBuffer),
+    offset: 0
+  };
+
+  const firstLine = readLine(state);
+  return firstLine ? HDR_MAGIC_HEADERS.includes(firstLine) : false;
+}
+
+export function parseHDR(arrayBuffer: ArrayBuffer): Texture<RadianceHDRMetadata> {
+  const state: HeaderState = {
+    data: new Uint8Array(arrayBuffer),
+    offset: 0
+  };
+  const header = readHeader(state);
+  const {width, height} = header;
+  const rgbeData = readPixels(state, header);
+  const data = convertRGBEToFloat(rgbeData);
+  const level: TextureLevel = {
+    shape: 'texture-level',
+    compressed: false,
+    width,
+    height,
+    data,
+    levelSize: data.byteLength,
+    format: GL_RGBA32F,
+    textureFormat: 'rgba32float'
+  };
+
+  return {
+    shape: 'texture',
+    type: '2d',
+    format: 'rgba32float',
+    ...(header.metadata ? {metadata: header.metadata} : {}),
+    data: [level]
+  };
+}
+
+function readHeader(state: HeaderState): HDRHeader {
+  const magicHeader = readLine(state);
+  if (!magicHeader || !HDR_MAGIC_HEADERS.includes(magicHeader)) {
+    throw new Error('RadianceHDRLoader: bad initial token');
+  }
+
+  let hasFormat = false;
+  const metadata: RadianceHDRMetadata = {};
+
+  while (state.offset < state.data.length) {
+    const line = readLine(state);
+
+    if (line === null) {
+      break;
+    }
+
+    if (!line || line.startsWith('#')) {
+      continue;
+    }
+
+    if (line.startsWith('FORMAT=')) {
+      hasFormat = line.slice('FORMAT='.length) === HDR_FORMAT;
+      if (!hasFormat) {
+        throw new Error('RadianceHDRLoader: unsupported format specifier');
+      }
+      continue;
+    }
+
+    parseMetadataLine(metadata, line);
+
+    const dimensions = parseDimensions(line);
+    if (dimensions) {
+      if (!hasFormat) {
+        throw new Error('RadianceHDRLoader: missing format specifier');
+      }
+      return {
+        ...dimensions,
+        ...(hasMetadata(metadata) ? {metadata} : {})
+      };
+    }
+  }
+
+  if (!hasFormat) {
+    throw new Error('RadianceHDRLoader: missing format specifier');
+  }
+
+  throw new Error('RadianceHDRLoader: missing image size specifier');
+}
+
+function parseDimensions(line: string): HDRHeader | null {
+  const match = line.match(/^([+-])([YX])\s+(\d+)\s+([+-])([YX])\s+(\d+)$/);
+  if (!match) {
+    return null;
+  }
+
+  const majorSign = match[1] === '+' ? 1 : -1;
+  const majorAxis = match[2] as 'X' | 'Y';
+  const majorLength = Number(match[3]);
+  const minorSign = match[4] === '+' ? 1 : -1;
+  const minorAxis = match[5] as 'X' | 'Y';
+  const minorLength = Number(match[6]);
+
+  if (majorAxis === minorAxis) {
+    throw new Error('RadianceHDRLoader: invalid image dimensions');
+  }
+
+  const width = majorAxis === 'X' ? majorLength : minorLength;
+  const height = majorAxis === 'Y' ? majorLength : minorLength;
+  if (!Number.isFinite(width) || !Number.isFinite(height) || width <= 0 || height <= 0) {
+    throw new Error('RadianceHDRLoader: invalid image dimensions');
+  }
+
+  return {width, height, majorAxis, majorSign, minorAxis, minorSign};
+}
+
+function readPixels(state: HeaderState, header: HDRHeader): Uint8Array {
+  const {width, height} = header;
+  const pixelCount = width * height;
+  const flatByteLength = pixelCount * 4;
+  const scanlineLength = header.minorAxis === 'X' ? width : height;
+  const scanlineCount = header.majorAxis === 'Y' ? height : width;
+
+  if (scanlineLength < 8 || scanlineLength > 0x7fff) {
+    return reorderPixels(readFlatPixels(state, flatByteLength), header);
+  }
+
+  if (state.offset + 4 > state.data.length) {
+    throw new Error('RadianceHDRLoader: unexpected end of file');
+  }
+
+  const data = state.data;
+  const isRunLengthEncoded =
+    data[state.offset] === 2 && data[state.offset + 1] === 2 && !(data[state.offset + 2] & 0x80);
+
+  if (!isRunLengthEncoded) {
+    return reorderPixels(readFlatPixels(state, flatByteLength), header);
+  }
+
+  const scanlineWidth = (data[state.offset + 2] << 8) | data[state.offset + 3];
+  if (scanlineWidth !== scanlineLength) {
+    return reorderPixels(readFlatPixels(state, flatByteLength), header);
+  }
+
+  const pixels = new Uint8Array(flatByteLength);
+  const scanlineBuffer = new Uint8Array(scanlineLength * 4);
+
+  for (let scanlineIndex = 0; scanlineIndex < scanlineCount; scanlineIndex++) {
+    if (state.offset + 4 > data.length) {
+      throw new Error('RadianceHDRLoader: unexpected end of file');
+    }
+
+    const red = data[state.offset++];
+    const green = data[state.offset++];
+    const blue = data[state.offset++];
+    const exponent = data[state.offset++];
+
+    if (red !== 2 || green !== 2 || ((blue << 8) | exponent) !== scanlineLength) {
+      throw new Error('RadianceHDRLoader: bad rgbe scanline format');
+    }
+
+    for (let channelIndex = 0; channelIndex < 4; channelIndex++) {
+      const channelOffset = channelIndex * scanlineLength;
+      const channelEnd = channelOffset + scanlineLength;
+      let pixelOffset = channelOffset;
+
+      while (pixelOffset < channelEnd) {
+        if (state.offset >= data.length) {
+          throw new Error('RadianceHDRLoader: unexpected end of file');
+        }
+
+        let count = data[state.offset++];
+
+        if (count > 128) {
+          count -= 128;
+          if (count === 0 || pixelOffset + count > channelEnd || state.offset >= data.length) {
+            throw new Error('RadianceHDRLoader: bad scanline data');
+          }
+
+          const value = data[state.offset++];
+          scanlineBuffer.fill(value, pixelOffset, pixelOffset + count);
+          pixelOffset += count;
+          continue;
+        }
+
+        if (count === 0 || pixelOffset + count > channelEnd || state.offset + count > data.length) {
+          throw new Error('RadianceHDRLoader: bad scanline data');
+        }
+
+        scanlineBuffer.set(data.subarray(state.offset, state.offset + count), pixelOffset);
+        pixelOffset += count;
+        state.offset += count;
+      }
+    }
+
+    for (let pixelIndex = 0; pixelIndex < scanlineLength; pixelIndex++) {
+      const outputOffset = getOutputOffset(header, scanlineIndex, pixelIndex);
+      pixels[outputOffset] = scanlineBuffer[pixelIndex];
+      pixels[outputOffset + 1] = scanlineBuffer[pixelIndex + scanlineLength];
+      pixels[outputOffset + 2] = scanlineBuffer[pixelIndex + scanlineLength * 2];
+      pixels[outputOffset + 3] = scanlineBuffer[pixelIndex + scanlineLength * 3];
+    }
+  }
+
+  return pixels;
+}
+
+function reorderPixels(data: Uint8Array, header: HDRHeader): Uint8Array {
+  const pixels = new Uint8Array(data.length);
+  const scanlineLength = header.minorAxis === 'X' ? header.width : header.height;
+  const scanlineCount = header.majorAxis === 'Y' ? header.height : header.width;
+
+  for (let scanlineIndex = 0; scanlineIndex < scanlineCount; scanlineIndex++) {
+    for (let pixelIndex = 0; pixelIndex < scanlineLength; pixelIndex++) {
+      const sourceOffset = (scanlineIndex * scanlineLength + pixelIndex) * 4;
+      const outputOffset = getOutputOffset(header, scanlineIndex, pixelIndex);
+      pixels[outputOffset] = data[sourceOffset];
+      pixels[outputOffset + 1] = data[sourceOffset + 1];
+      pixels[outputOffset + 2] = data[sourceOffset + 2];
+      pixels[outputOffset + 3] = data[sourceOffset + 3];
+    }
+  }
+
+  return pixels;
+}
+
+function getOutputOffset(header: HDRHeader, scanlineIndex: number, pixelIndex: number): number {
+  const majorCoordinate = getCoordinate(
+    header.majorAxis === 'X' ? header.width : header.height,
+    header.majorSign,
+    scanlineIndex
+  );
+  const minorCoordinate = getCoordinate(
+    header.minorAxis === 'X' ? header.width : header.height,
+    header.minorSign,
+    pixelIndex
+  );
+  const x = header.majorAxis === 'X' ? majorCoordinate : minorCoordinate;
+  const y = header.majorAxis === 'Y' ? majorCoordinate : minorCoordinate;
+
+  return ((header.height - 1 - y) * header.width + x) * 4;
+}
+
+function getCoordinate(length: number, sign: 1 | -1, index: number): number {
+  return sign === 1 ? index : length - 1 - index;
+}
+
+function readFlatPixels(state: HeaderState, byteLength: number): Uint8Array {
+  if (state.offset + byteLength > state.data.length) {
+    throw new Error('RadianceHDRLoader: unexpected end of file');
+  }
+
+  const pixels = state.data.slice(state.offset, state.offset + byteLength);
+  state.offset += byteLength;
+  return pixels;
+}
+
+function convertRGBEToFloat(data: Uint8Array): Float32Array {
+  const floatData = new Float32Array(data.length);
+
+  for (let sourceOffset = 0; sourceOffset < data.length; sourceOffset += 4) {
+    const exponent = data[sourceOffset + 3];
+    const destinationOffset = sourceOffset;
+
+    if (exponent > 0) {
+      const scale = Math.pow(2, exponent - 128) / 255;
+      floatData[destinationOffset] = data[sourceOffset] * scale;
+      floatData[destinationOffset + 1] = data[sourceOffset + 1] * scale;
+      floatData[destinationOffset + 2] = data[sourceOffset + 2] * scale;
+    }
+
+    floatData[destinationOffset + 3] = 1;
+  }
+
+  return floatData;
+}
+
+function readLine(state: HeaderState): string | null {
+  if (state.offset >= state.data.length) {
+    return null;
+  }
+
+  const lineStart = state.offset;
+
+  while (state.offset < state.data.length) {
+    const byte = state.data[state.offset++];
+    if (byte === 0x0a) {
+      const line = decodeASCII(state.data.subarray(lineStart, state.offset - 1));
+      return line.endsWith('\r') ? line.slice(0, -1) : line;
+    }
+  }
+
+  const line = decodeASCII(state.data.subarray(lineStart, state.offset));
+  return line.endsWith('\r') ? line.slice(0, -1) : line;
+}
+
+function decodeASCII(data: Uint8Array): string {
+  let line = '';
+  for (const byte of data) {
+    line += String.fromCharCode(byte);
+  }
+  return line;
+}
+
+function parseMetadataLine(metadata: RadianceHDRMetadata, line: string): void {
+  if (line.startsWith('COLORCORR=')) {
+    const values = parseNumberList(line.slice('COLORCORR='.length), 3);
+    if (values) {
+      metadata.colorCorrection = values as [number, number, number];
+    }
+    return;
+  }
+
+  if (line.startsWith('EXPOSURE=')) {
+    const value = parseNumber(line.slice('EXPOSURE='.length));
+    if (value !== null) {
+      metadata.exposure = value;
+    }
+    return;
+  }
+
+  if (line.startsWith('GAMMA=')) {
+    const value = parseNumber(line.slice('GAMMA='.length));
+    if (value !== null) {
+      metadata.gamma = value;
+    }
+    return;
+  }
+
+  if (line.startsWith('PIXASPECT=')) {
+    const value = parseNumber(line.slice('PIXASPECT='.length));
+    if (value !== null) {
+      metadata.pixelAspectRatio = value;
+    }
+    return;
+  }
+
+  if (line.startsWith('PRIMARIES=')) {
+    const values = parseNumberList(line.slice('PRIMARIES='.length), 8);
+    if (values) {
+      metadata.primaries = values as [
+        number,
+        number,
+        number,
+        number,
+        number,
+        number,
+        number,
+        number
+      ];
+    }
+    return;
+  }
+
+  if (line.startsWith('SOFTWARE=')) {
+    metadata.software = line.slice('SOFTWARE='.length).trim();
+    return;
+  }
+
+  if (line.startsWith('VIEW=')) {
+    metadata.view = line.slice('VIEW='.length).trim();
+  }
+}
+
+function parseNumber(text: string): number | null {
+  const value = Number(text.trim());
+  return Number.isFinite(value) ? value : null;
+}
+
+function parseNumberList(text: string, count: number): number[] | null {
+  const values = text
+    .trim()
+    .split(/\s+/)
+    .map((value) => Number(value));
+
+  if (values.length !== count || values.some((value) => !Number.isFinite(value))) {
+    return null;
+  }
+
+  return values;
+}
+
+function hasMetadata(metadata: RadianceHDRMetadata): boolean {
+  return Object.keys(metadata).length > 0;
+}

package/src/lib/parsers/parse-ktx.ts

@@ -3,9 +3,10 @@
 // Copyright (c) vis.gl contributors
 
 import type {TextureLevel} from '@loaders.gl/schema';
+import {log} from '@loaders.gl/loader-utils';
 import {read} from 'ktx-parse';
 import {extractMipmapImages} from '../utils/extract-mipmap-images';
-import {mapVkFormatToWebGL} from '../utils/ktx-format-helper';
+import {mapVkFormatToTextureFormat} from '../utils/ktx-format-helper';
 
 const KTX2_ID = [
   // '´', 'K', 'T', 'X', '2', '0', 'ª', '\r', '\n', '\x1A', '\n'
@@ -40,13 +41,22 @@ export function parseKTX(arrayBuffer: ArrayBuffer): TextureLevel[] {
   const mipMapLevels = Math.max(1, ktx.levels.length);
   const width = ktx.pixelWidth;
   const height = ktx.pixelHeight;
-  const internalFormat = mapVkFormatToWebGL(ktx.vkFormat);
+  const textureFormat = mapVkFormatToTextureFormat(ktx.vkFormat);
+
+  if (textureFormat === undefined) {
+    // TODO: Basis-backed and otherwise unknown-format KTX2 files should preserve the
+    // legacy CompressedTextureLoader behavior for now. Do not fail here or add implicit
+    // transcoding in this parser path; just return levels without `format` metadata.
+    log.warn(
+      `KTX2 container vkFormat ${ktx.vkFormat} does not map to a known texture format; returning texture levels without format metadata.`
+    )();
+  }
 
   return extractMipmapImages(ktx.levels, {
     mipMapLevels,
     width,
     height,
     sizeFunction: (level: any): number => level.uncompressedByteLength,
-    internalFormat
+    textureFormat
   });
 }

package/src/lib/parsers/parse-pvr.ts

@@ -6,8 +6,7 @@
 // Forked from PicoGL: https://github.com/tsherif/picogl.js/blob/master/examples/utils/utils.js
 // Copyright (c) 2017 Tarek Sherif, The MIT License (MIT)
 
-import type {TextureLevel} from '@loaders.gl/schema';
-import {GL_EXTENSIONS_CONSTANTS} from '../gl-extensions';
+import type {TextureFormat, TextureLevel} from '@loaders.gl/schema';
 import {extractMipmapImages} from '../utils/extract-mipmap-images';
 
 const PVR_CONSTANTS: Record<string, number> = {
@@ -24,76 +23,34 @@ const PVR_CONSTANTS: Record<string, number> = {
   METADATA_SIZE_INDEX: 12
 };
 
-const PVR_PIXEL_FORMATS: Record<number, number[]> = {
-  0: [GL_EXTENSIONS_CONSTANTS.COMPRESSED_RGB_PVRTC_2BPPV1_IMG],
-  1: [GL_EXTENSIONS_CONSTANTS.COMPRESSED_RGBA_PVRTC_2BPPV1_IMG],
-  2: [GL_EXTENSIONS_CONSTANTS.COMPRESSED_RGB_PVRTC_4BPPV1_IMG],
-  3: [GL_EXTENSIONS_CONSTANTS.COMPRESSED_RGBA_PVRTC_4BPPV1_IMG],
-  6: [GL_EXTENSIONS_CONSTANTS.COMPRESSED_RGB_ETC1_WEBGL],
-  7: [GL_EXTENSIONS_CONSTANTS.COMPRESSED_RGB_S3TC_DXT1_EXT],
-  9: [GL_EXTENSIONS_CONSTANTS.COMPRESSED_RGBA_S3TC_DXT3_EXT],
-  11: [GL_EXTENSIONS_CONSTANTS.COMPRESSED_RGBA_S3TC_DXT5_EXT],
-  22: [GL_EXTENSIONS_CONSTANTS.COMPRESSED_RGB8_ETC2],
-  23: [GL_EXTENSIONS_CONSTANTS.COMPRESSED_RGBA8_ETC2_EAC],
-  24: [GL_EXTENSIONS_CONSTANTS.COMPRESSED_RGB8_PUNCHTHROUGH_ALPHA1_ETC2],
-  25: [GL_EXTENSIONS_CONSTANTS.COMPRESSED_R11_EAC],
-  26: [GL_EXTENSIONS_CONSTANTS.COMPRESSED_RG11_EAC],
-  27: [
-    GL_EXTENSIONS_CONSTANTS.COMPRESSED_RGBA_ASTC_4X4_KHR,
-    GL_EXTENSIONS_CONSTANTS.COMPRESSED_SRGB8_ALPHA8_ASTC_4X4_KHR
-  ],
-  28: [
-    GL_EXTENSIONS_CONSTANTS.COMPRESSED_RGBA_ASTC_5X4_KHR,
-    GL_EXTENSIONS_CONSTANTS.COMPRESSED_SRGB8_ALPHA8_ASTC_5X4_KHR
-  ],
-  29: [
-    GL_EXTENSIONS_CONSTANTS.COMPRESSED_RGBA_ASTC_5X5_KHR,
-    GL_EXTENSIONS_CONSTANTS.COMPRESSED_SRGB8_ALPHA8_ASTC_5X5_KHR
-  ],
-  30: [
-    GL_EXTENSIONS_CONSTANTS.COMPRESSED_RGBA_ASTC_6X5_KHR,
-    GL_EXTENSIONS_CONSTANTS.COMPRESSED_SRGB8_ALPHA8_ASTC_6X5_KHR
-  ],
-  31: [
-    GL_EXTENSIONS_CONSTANTS.COMPRESSED_RGBA_ASTC_6X6_KHR,
-    GL_EXTENSIONS_CONSTANTS.COMPRESSED_SRGB8_ALPHA8_ASTC_6X6_KHR
-  ],
-  32: [
-    GL_EXTENSIONS_CONSTANTS.COMPRESSED_RGBA_ASTC_8X5_KHR,
-    GL_EXTENSIONS_CONSTANTS.COMPRESSED_SRGB8_ALPHA8_ASTC_8X5_KHR
-  ],
-  33: [
-    GL_EXTENSIONS_CONSTANTS.COMPRESSED_RGBA_ASTC_8X6_KHR,
-    GL_EXTENSIONS_CONSTANTS.COMPRESSED_SRGB8_ALPHA8_ASTC_8X6_KHR
-  ],
-  34: [
-    GL_EXTENSIONS_CONSTANTS.COMPRESSED_RGBA_ASTC_8X8_KHR,
-    GL_EXTENSIONS_CONSTANTS.COMPRESSED_SRGB8_ALPHA8_ASTC_8X8_KHR
-  ],
-  35: [
-    GL_EXTENSIONS_CONSTANTS.COMPRESSED_RGBA_ASTC_10X5_KHR,
-    GL_EXTENSIONS_CONSTANTS.COMPRESSED_SRGB8_ALPHA8_ASTC_10X5_KHR
-  ],
-  36: [
-    GL_EXTENSIONS_CONSTANTS.COMPRESSED_RGBA_ASTC_10X6_KHR,
-    GL_EXTENSIONS_CONSTANTS.COMPRESSED_SRGB8_ALPHA8_ASTC_10X6_KHR
-  ],
-  37: [
-    GL_EXTENSIONS_CONSTANTS.COMPRESSED_RGBA_ASTC_10X8_KHR,
-    GL_EXTENSIONS_CONSTANTS.COMPRESSED_SRGB8_ALPHA8_ASTC_10X8_KHR
-  ],
-  38: [
-    GL_EXTENSIONS_CONSTANTS.COMPRESSED_RGBA_ASTC_10X10_KHR,
-    GL_EXTENSIONS_CONSTANTS.COMPRESSED_SRGB8_ALPHA8_ASTC_10X10_KHR
-  ],
-  39: [
-    GL_EXTENSIONS_CONSTANTS.COMPRESSED_RGBA_ASTC_12X10_KHR,
-    GL_EXTENSIONS_CONSTANTS.COMPRESSED_SRGB8_ALPHA8_ASTC_12X10_KHR
-  ],
-  40: [
-    GL_EXTENSIONS_CONSTANTS.COMPRESSED_RGBA_ASTC_12X12_KHR,
-    GL_EXTENSIONS_CONSTANTS.COMPRESSED_SRGB8_ALPHA8_ASTC_12X12_KHR
-  ]
+const PVR_TEXTURE_FORMATS: Record<number, TextureFormat[]> = {
+  0: ['pvrtc-rgb2unorm-webgl'],
+  1: ['pvrtc-rgba2unorm-webgl'],
+  2: ['pvrtc-rgb4unorm-webgl'],
+  3: ['pvrtc-rgba4unorm-webgl'],
+  6: ['etc1-rgb-unorm-webgl'],
+  7: ['bc1-rgb-unorm-webgl'],
+  9: ['bc2-rgba-unorm'],
+  11: ['bc3-rgba-unorm'],
+  22: ['etc2-rgb8unorm'],
+  23: ['etc2-rgba8unorm'],
+  24: ['etc2-rgb8a1unorm'],
+  25: ['eac-r11unorm'],
+  26: ['eac-rg11unorm'],
+  27: ['astc-4x4-unorm', 'astc-4x4-unorm-srgb'],
+  28: ['astc-5x4-unorm', 'astc-5x4-unorm-srgb'],
+  29: ['astc-5x5-unorm', 'astc-5x5-unorm-srgb'],
+  30: ['astc-6x5-unorm', 'astc-6x5-unorm-srgb'],
+  31: ['astc-6x6-unorm', 'astc-6x6-unorm-srgb'],
+  32: ['astc-8x5-unorm', 'astc-8x5-unorm-srgb'],
+  33: ['astc-8x6-unorm', 'astc-8x6-unorm-srgb'],
+  34: ['astc-8x8-unorm', 'astc-8x8-unorm-srgb'],
+  35: ['astc-10x5-unorm', 'astc-10x5-unorm-srgb'],
+  36: ['astc-10x6-unorm', 'astc-10x6-unorm-srgb'],
+  37: ['astc-10x8-unorm', 'astc-10x8-unorm-srgb'],
+  38: ['astc-10x10-unorm', 'astc-10x10-unorm-srgb'],
+  39: ['astc-12x10-unorm', 'astc-12x10-unorm-srgb'],
+  40: ['astc-12x12-unorm', 'astc-12x12-unorm-srgb']
 };
 
 const PVR_SIZE_FUNCTIONS: Record<number, (width: number, height: number) => number> = {
@@ -149,8 +106,9 @@ export function parsePVR(data: ArrayBuffer): TextureLevel[] {
 
   const pvrFormat = header[PVR_CONSTANTS.PIXEL_FORMAT_INDEX];
   const colourSpace = header[PVR_CONSTANTS.COLOUR_SPACE_INDEX];
-  const pixelFormats = PVR_PIXEL_FORMATS[pvrFormat] || [];
-  const internalFormat = pixelFormats.length > 1 && colourSpace ? pixelFormats[1] : pixelFormats[0];
+  const textureFormats = PVR_TEXTURE_FORMATS[pvrFormat] || [];
+  const textureFormat =
+    textureFormats.length > 1 && colourSpace ? textureFormats[1] : textureFormats[0];
 
   const sizeFunction = PVR_SIZE_FUNCTIONS[pvrFormat];
 
@@ -168,7 +126,7 @@ export function parsePVR(data: ArrayBuffer): TextureLevel[] {
     width,
     height,
     sizeFunction,
-    internalFormat
+    textureFormat
   });
 }
 

package/src/lib/texture-api/generate-url.ts

@@ -2,23 +2,13 @@
 // SPDX-License-Identifier: MIT
 // Copyright (c) vis.gl contributors
 
-import {resolvePath} from '@loaders.gl/loader-utils';
 import type {GetUrl, UrlOptions} from './texture-api-types';
 
-// Generate a url by calling getUrl with mix of options, applying options.baseUrl
+// Generate a member url by calling getUrl with merged options.
 export function generateUrl(
   getUrl: string | GetUrl,
   options: UrlOptions,
   urlOptions: Record<string, any>
 ): string {
-  // Get url
-  let url = typeof getUrl === 'function' ? getUrl({...options, ...urlOptions}) : getUrl;
-
-  // Apply options.baseUrl
-  const baseUrl = options.baseUrl;
-  if (baseUrl) {
-    url = baseUrl[baseUrl.length - 1] === '/' ? `${baseUrl}${url}` : `${baseUrl}/${url}`;
-  }
-
-  return resolvePath(url);
+  return typeof getUrl === 'function' ? getUrl({...options, ...urlOptions}) : getUrl;
 }

package/src/lib/texture-api/load-image-array.ts

@@ -2,21 +2,30 @@
 // SPDX-License-Identifier: MIT
 // Copyright (c) vis.gl contributors
 
-import {ImageLoader} from '@loaders.gl/images';
-import type {GetUrl} from './texture-api-types';
+import {
+  loadCompositeImageUrlTree,
+  normalizeCompositeImageOptions
+} from '../composite-image/parse-composite-image';
+import type {GetUrl, TextureLoaderOptions} from './texture-api-types';
 import {getImageUrls} from './load-image';
-import {deepLoad} from './deep-load';
 
+/**
+ * @deprecated Use `load(url, TextureArrayLoader)` for manifest-driven loading.
+ */
 export async function loadImageTextureArray(
   count: number,
   getUrl: GetUrl,
-  options = {}
+  options: TextureLoaderOptions = {}
 ): Promise<any> {
   const imageUrls = await getImageArrayUrls(count, getUrl, options);
-  return await deepLoad(imageUrls, ImageLoader.parse, options);
+  return await loadCompositeImageUrlTree(imageUrls, normalizeCompositeImageOptions(options));
 }
 
-export async function getImageArrayUrls(count: number, getUrl: GetUrl, options = {}): Promise<any> {
+export async function getImageArrayUrls(
+  count: number,
+  getUrl: GetUrl,
+  options: TextureLoaderOptions = {}
+): Promise<any> {
   const promises: Promise<any>[] = [];
   for (let index = 0; index < count; index++) {
     const promise = getImageUrls(getUrl, options, {index});