@loaders.gl/textures 4.4.0-alpha.18 → 4.4.0-alpha.19

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

@@ -2,47 +2,27 @@
 // SPDX-License-Identifier: MIT
 // Copyright (c) vis.gl contributors
 
-import {ImageLoader} from '@loaders.gl/images';
-import type {GetUrl, UrlOptions} from './texture-api-types';
+import {
+  loadCompositeImageUrlTree,
+  normalizeCompositeImageOptions
+} from '../composite-image/parse-composite-image';
+import {
+  IMAGE_TEXTURE_CUBE_FACES,
+  type ImageCubeTexture
+} from '../composite-image/image-texture-cube';
+import type {GetUrl, TextureLoaderOptions} from './texture-api-types';
 import {getImageUrls} from './load-image';
-import {deepLoad} from './deep-load';
-
-// Returned map will be have keys corresponding to GL cubemap constants
-const GL_TEXTURE_CUBE_MAP_POSITIVE_X = 0x8515;
-const GL_TEXTURE_CUBE_MAP_NEGATIVE_X = 0x8516;
-const GL_TEXTURE_CUBE_MAP_POSITIVE_Y = 0x8517;
-const GL_TEXTURE_CUBE_MAP_NEGATIVE_Y = 0x8518;
-const GL_TEXTURE_CUBE_MAP_POSITIVE_Z = 0x8519;
-const GL_TEXTURE_CUBE_MAP_NEGATIVE_Z = 0x851a;
-
-const CUBE_FACES = [
-  {face: GL_TEXTURE_CUBE_MAP_POSITIVE_X, direction: 'right', axis: 'x', sign: 'positive'},
-  {face: GL_TEXTURE_CUBE_MAP_NEGATIVE_X, direction: 'left', axis: 'x', sign: 'negative'},
-  {face: GL_TEXTURE_CUBE_MAP_POSITIVE_Y, direction: 'top', axis: 'y', sign: 'positive'},
-  {face: GL_TEXTURE_CUBE_MAP_NEGATIVE_Y, direction: 'bottom', axis: 'y', sign: 'negative'},
-  {face: GL_TEXTURE_CUBE_MAP_POSITIVE_Z, direction: 'front', axis: 'z', sign: 'positive'},
-  {face: GL_TEXTURE_CUBE_MAP_NEGATIVE_Z, direction: 'back', axis: 'z', sign: 'negative'}
-];
-
-export type ImageCubeTexture = {
-  GL_TEXTURE_CUBE_MAP_POSITIVE_X: any;
-  GL_TEXTURE_CUBE_MAP_NEGATIVE_X: any;
-  GL_TEXTURE_CUBE_MAP_POSITIVE_Y: any;
-  GL_TEXTURE_CUBE_MAP_NEGATIVE_Y: any;
-  GL_TEXTURE_CUBE_MAP_POSITIVE_Z: any;
-  GL_TEXTURE_CUBE_MAP_NEGATIVE_Z: any;
-};
 
 // Returns an object with six key-value pairs containing the urls (or url mip arrays)
 // for each cube face
-export async function getImageCubeUrls(getUrl: GetUrl, options: UrlOptions) {
+export async function getImageCubeUrls(getUrl: GetUrl, options: TextureLoaderOptions) {
   // Calculate URLs
   const urls: Record<number, string | string[]> = {};
   const promises: Promise<any>[] = [];
 
   let index = 0;
-  for (let i = 0; i < CUBE_FACES.length; ++i) {
-    const face = CUBE_FACES[index];
+  for (let i = 0; i < IMAGE_TEXTURE_CUBE_FACES.length; ++i) {
+    const face = IMAGE_TEXTURE_CUBE_FACES[index];
     const promise = getImageUrls(getUrl, options, {...face, index: index++}).then((url) => {
       urls[face.face] = url;
     });
@@ -56,10 +36,16 @@ export async function getImageCubeUrls(getUrl: GetUrl, options: UrlOptions) {
 
 // Returns an object with six key-value pairs containing the images (or image mip arrays)
 // for each cube face
+/**
+ * @deprecated Use `load(url, TextureCubeLoader)` for manifest-driven loading.
+ */
 export async function loadImageTextureCube(
   getUrl: GetUrl,
-  options = {}
+  options: TextureLoaderOptions = {}
 ): Promise<ImageCubeTexture> {
   const urls = await getImageCubeUrls(getUrl, options);
-  return (await deepLoad(urls, ImageLoader.parse, options)) as ImageCubeTexture;
+  return (await loadCompositeImageUrlTree(
+    urls,
+    normalizeCompositeImageOptions(options)
+  )) as ImageCubeTexture;
 }

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

@@ -3,19 +3,29 @@
 // Copyright (c) vis.gl contributors
 
 import {assert} from '@loaders.gl/loader-utils';
-import {ImageLoader, getImageSize} from '@loaders.gl/images';
-import type {GetUrl, UrlOptions} from './texture-api-types';
+import {getImageSize} from '@loaders.gl/images';
+import {
+  loadCompositeImageMember,
+  loadCompositeImageUrlTree,
+  normalizeCompositeImageOptions
+} from '../composite-image/parse-composite-image';
+import type {GetUrl, TextureLoaderOptions, UrlOptions} from './texture-api-types';
 import {generateUrl} from './generate-url';
-import {deepLoad, shallowLoad} from './deep-load';
 
-export async function loadImageTexture(getUrl: string | GetUrl, options = {}): Promise<any> {
+/**
+ * @deprecated Use `load(url, TextureLoader)` for manifest-driven loading.
+ */
+export async function loadImageTexture(
+  getUrl: string | GetUrl,
+  options: TextureLoaderOptions = {}
+): Promise<any> {
   const imageUrls = await getImageUrls(getUrl, options);
-  return await deepLoad(imageUrls, ImageLoader.parse, options);
+  return await loadCompositeImageUrlTree(imageUrls, normalizeCompositeImageOptions(options));
 }
 
 export async function getImageUrls(
   getUrl: string | GetUrl,
-  options: any,
+  options: TextureLoaderOptions,
   urlOptions: UrlOptions = {}
 ): Promise<any> {
   const mipLevels = (options && options.image && options.image.mipLevels) || 0;
@@ -27,15 +37,16 @@ export async function getImageUrls(
 async function getMipmappedImageUrls(
   getUrl: string | GetUrl,
   mipLevels: number | 'auto',
-  options: any,
+  options: TextureLoaderOptions,
   urlOptions: UrlOptions
 ): Promise<string[]> {
   const urls: string[] = [];
+  const normalizedOptions = normalizeCompositeImageOptions(options);
 
   // If no mip levels supplied, we need to load the level 0 image and calculate based on size
   if (mipLevels === 'auto') {
     const url = generateUrl(getUrl, options, {...urlOptions, lod: 0});
-    const image = await shallowLoad(url, ImageLoader.parse, options);
+    const image = await loadCompositeImageMember(url, normalizedOptions);
 
     const {width, height} = getImageSize(image);
     mipLevels = getMipLevels({width, height});

package/src/lib/texture-api/texture-api-types.ts

@@ -2,6 +2,9 @@
 // SPDX-License-Identifier: MIT
 // Copyright (c) vis.gl contributors
 
+import type {LoaderOptions} from '@loaders.gl/loader-utils';
+import type {ImageLoaderOptions} from '@loaders.gl/images';
+
 export type {ImageType} from '@loaders.gl/images';
 
 export type UrlOptions = {
@@ -12,3 +15,15 @@ export type UrlOptions = {
   direction?: string;
 };
 export type GetUrl = (options: UrlOptions) => string;
+
+export type TextureLoaderOptions = LoaderOptions & {
+  core?: NonNullable<LoaderOptions['core']> & {
+    /** Base URL for resolving composite image members when no loader context URL is available */
+    baseUrl?: string;
+  };
+  /** @deprecated Legacy helper alias kept for loadImageTexture* compatibility */
+  baseUrl?: string;
+  image?: NonNullable<ImageLoaderOptions['image']> & {
+    mipLevels?: number | 'auto';
+  };
+};

package/src/lib/utils/detect-supported-texture-formats.ts

@@ -27,7 +27,7 @@ const WEBGL_TEXTURE_FORMATS: {[key: string]: TextureFormat[]} = {
     'bc7-rgba-unorm',
     'bc7-rgba-unorm-srgb'
   ],
-  WEBGL_compressed_texture_etc1: ['etc1-rbg-unorm-webgl'],
+  WEBGL_compressed_texture_etc1: ['etc1-rgb-unorm-webgl'],
   WEBGL_compressed_texture_etc: [
     'etc2-rgb8unorm',
     'etc2-rgb8unorm-srgb',
@@ -43,7 +43,7 @@ const WEBGL_TEXTURE_FORMATS: {[key: string]: TextureFormat[]} = {
   WEBGL_compressed_texture_pvrtc: [
     'pvrtc-rgb4unorm-webgl',
     'pvrtc-rgba4unorm-webgl',
-    'pvrtc-rbg2unorm-webgl',
+    'pvrtc-rgb2unorm-webgl',
     'pvrtc-rgba2unorm-webgl'
   ],
   WEBGL_compressed_texture_atc: [
@@ -92,7 +92,7 @@ const GPU_TEXTURE_FORMATS: {[key in GPUTextureFormat]: TextureFormat[]} = {
     'bc2-rgba-unorm-srgb',
     'bc3-rgba-unorm-srgb'
   ],
-  etc1: ['etc1-rbg-unorm-webgl'],
+  etc1: ['etc1-rgb-unorm-webgl'],
   etc2: [
     'etc2-rgb8unorm',
     'etc2-rgb8unorm-srgb',
@@ -108,7 +108,7 @@ const GPU_TEXTURE_FORMATS: {[key in GPUTextureFormat]: TextureFormat[]} = {
   pvrtc: [
     'pvrtc-rgb4unorm-webgl',
     'pvrtc-rgba4unorm-webgl',
-    'pvrtc-rbg2unorm-webgl',
+    'pvrtc-rgb2unorm-webgl',
     'pvrtc-rgba2unorm-webgl'
   ],
   atc: ['atc-rgb-unorm-webgl', 'atc-rgba-unorm-webgl', 'atc-rgbai-unorm-webgl'],

package/src/lib/utils/extract-mipmap-images.ts

@@ -2,8 +2,12 @@
 // SPDX-License-Identifier: MIT
 // Copyright (c) vis.gl contributors
 
-import type {GLTextureFormat, TextureLevel} from '@loaders.gl/schema';
-import {getTextureFormatFromWebGLFormat} from './texture-format-map';
+import type {TextureFormat, TextureLevel} from '@loaders.gl/schema';
+import type {GLTextureFormat} from '../gl-types';
+import {
+  getTextureFormatFromWebGLFormat,
+  getWebGLFormatFromTextureFormat
+} from './texture-format-map';
 
 export type CompressedTextureExtractOptions = {
   mipMapLevels: number;
@@ -11,6 +15,8 @@ export type CompressedTextureExtractOptions = {
   height: number;
   sizeFunction: Function;
   internalFormat?: GLTextureFormat;
+  /** Canonical loaders.gl texture format for the mip levels being extracted. */
+  textureFormat?: TextureFormat;
 };
 
 /**
@@ -21,6 +27,7 @@ export type CompressedTextureExtractOptions = {
  * @param options.height - height of 0 - level
  * @param options.sizeFunction - format-related function to calculate level size in bytes
  * @param options.internalFormat - WebGL compatible format code
+ * @param options.textureFormat - canonical loaders.gl texture format
  * @returns Array of the texture levels
  */
 export function extractMipmapImages(
@@ -28,8 +35,9 @@ export function extractMipmapImages(
   options: CompressedTextureExtractOptions
 ): TextureLevel[] {
   const images = new Array(options.mipMapLevels);
-  const format = options.internalFormat;
-  const textureFormat = format === undefined ? undefined : getTextureFormatFromWebGLFormat(format);
+  const textureFormat =
+    options.textureFormat || getTextureFormatFromWebGLFormat(options.internalFormat);
+  const format = options.internalFormat || getWebGLFormatFromTextureFormat(options.textureFormat);
 
   let levelWidth = options.width;
   let levelHeight = options.height;

package/src/lib/utils/ktx-format-helper.ts

@@ -3,7 +3,8 @@
 // Copyright (c) vis.gl contributors
 
 /* eslint-disable camelcase */
-import type {GLTextureFormat} from '@loaders.gl/schema';
+import type {TextureFormat} from '@loaders.gl/schema';
+import type {GLTextureFormat} from '../gl-types';
 import {
   GL_COMPRESSED_R11_EAC,
   GL_COMPRESSED_RED_GREEN_RGTC2_EXT,
@@ -58,6 +59,7 @@ import {
   GL_COMPRESSED_SRGB_ALPHA_S3TC_DXT5_EXT,
   GL_COMPRESSED_SRGB_S3TC_DXT1_EXT
 } from '../gl-extensions';
+import {getTextureFormatFromWebGLFormat} from './texture-format-map';
 
 const VULKAN_TO_WEBGL_FORMAT_MAP: Record<number, GLTextureFormat> = {
   131: GL_COMPRESSED_RGB_S3TC_DXT1_EXT,
@@ -138,3 +140,12 @@ const VULKAN_TO_WEBGL_FORMAT_MAP: Record<number, GLTextureFormat> = {
 export function mapVkFormatToWebGL(vkFormat: number): GLTextureFormat | undefined {
   return VULKAN_TO_WEBGL_FORMAT_MAP[vkFormat];
 }
+
+/**
+ * Returns the canonical loaders.gl texture format corresponding to a Vulkan `vkFormat` value.
+ * @param vkFormat - Vulkan format constant from the KTX container.
+ * @returns Canonical texture format string, if known.
+ */
+export function mapVkFormatToTextureFormat(vkFormat: number): TextureFormat | undefined {
+  return getTextureFormatFromWebGLFormat(mapVkFormatToWebGL(vkFormat));
+}

package/src/lib/utils/texture-format-map.ts

@@ -4,7 +4,9 @@
 
 /* eslint-disable camelcase */
 import type {TextureFormat} from '@loaders.gl/schema';
+import type {GLTextureFormat} from '../gl-types';
 import {
+  GL_RGBA32F,
   GL_COMPRESSED_R11_EAC,
   GL_COMPRESSED_RED_GREEN_RGTC2_EXT,
   GL_COMPRESSED_RED_RGTC1_EXT,
@@ -66,6 +68,7 @@ import {
 } from '../gl-extensions';
 
 const WEBGL_TO_TEXTURE_FORMAT: Record<number, TextureFormat> = {
+  [GL_RGBA32F]: 'rgba32float',
   [GL_COMPRESSED_RGB_S3TC_DXT1_EXT]: 'bc1-rgb-unorm-webgl',
   [GL_COMPRESSED_SRGB_S3TC_DXT1_EXT]: 'bc1-rgb-unorm-srgb-webgl',
   [GL_COMPRESSED_RGBA_S3TC_DXT1_EXT]: 'bc1-rgba-unorm',
@@ -118,18 +121,42 @@ const WEBGL_TO_TEXTURE_FORMAT: Record<number, TextureFormat> = {
   [GL_COMPRESSED_SRGB8_ALPHA8_ASTC_12x12_KHR]: 'astc-12x12-unorm-srgb',
   [GL_COMPRESSED_RGB_PVRTC_4BPPV1_IMG]: 'pvrtc-rgb4unorm-webgl',
   [GL_COMPRESSED_RGBA_PVRTC_4BPPV1_IMG]: 'pvrtc-rgba4unorm-webgl',
-  [GL_COMPRESSED_RGB_PVRTC_2BPPV1_IMG]: 'pvrtc-rbg2unorm-webgl',
+  [GL_COMPRESSED_RGB_PVRTC_2BPPV1_IMG]: 'pvrtc-rgb2unorm-webgl',
   [GL_COMPRESSED_RGBA_PVRTC_2BPPV1_IMG]: 'pvrtc-rgba2unorm-webgl',
-  [GL_COMPRESSED_RGB_ETC1_WEBGL]: 'etc1-rbg-unorm-webgl',
+  [GL_COMPRESSED_RGB_ETC1_WEBGL]: 'etc1-rgb-unorm-webgl',
   [GL_COMPRESSED_RGB_ATC_WEBGL]: 'atc-rgb-unorm-webgl',
   [GL_COMPRESSED_RGBA_ATC_EXPLICIT_ALPHA_WEBGL]: 'atc-rgba-unorm-webgl',
   [GL_COMPRESSED_RGBA_ATC_INTERPOLATED_ALPHA_WEBGL]: 'atc-rgbai-unorm-webgl'
 };
 
-export function getTextureFormatFromWebGLFormat(format?: number): TextureFormat | undefined {
+const TEXTURE_FORMAT_TO_WEBGL = Object.fromEntries(
+  Object.entries(WEBGL_TO_TEXTURE_FORMAT).map(([format, textureFormat]) => [
+    textureFormat,
+    Number(format)
+  ])
+) as Partial<Record<TextureFormat, GLTextureFormat>>;
+
+export function getTextureFormatFromWebGLFormat(
+  format?: GLTextureFormat
+): TextureFormat | undefined {
   if (format === undefined) {
     return undefined;
   }
 
   return WEBGL_TO_TEXTURE_FORMAT[format];
 }
+
+/**
+ * Returns the WebGL/OpenGL compressed texture constant for a canonical loaders.gl texture format.
+ * @param textureFormat - Canonical texture format string.
+ * @returns Matching WebGL/OpenGL constant, if known.
+ */
+export function getWebGLFormatFromTextureFormat(
+  textureFormat?: TextureFormat
+): GLTextureFormat | undefined {
+  if (textureFormat === undefined) {
+    return undefined;
+  }
+
+  return TEXTURE_FORMAT_TO_WEBGL[textureFormat];
+}

package/src/radiance-hdr-loader.ts

@@ -0,0 +1,36 @@
+// loaders.gl
+// SPDX-License-Identifier: MIT
+// Copyright (c) vis.gl contributors
+
+import type {LoaderWithParser, StrictLoaderOptions} from '@loaders.gl/loader-utils';
+import type {Texture} from '@loaders.gl/schema';
+import {VERSION} from './lib/utils/version';
+import type {RadianceHDRMetadata} from './lib/parsers/parse-hdr';
+import {isHDR, parseHDR} from './lib/parsers/parse-hdr';
+
+export type RadianceHDRLoaderOptions = StrictLoaderOptions & {
+  hdr?: {};
+};
+
+export const RadianceHDRLoader = {
+  dataType: null as unknown as Texture<RadianceHDRMetadata>,
+  batchType: null as never,
+
+  name: 'Radiance HDR',
+  id: 'hdr',
+  module: 'textures',
+  version: VERSION,
+  extensions: ['hdr'],
+  mimeTypes: ['image/vnd.radiance', 'image/x-hdr', 'application/octet-stream'],
+  binary: true,
+  tests: [isHDR],
+  options: {
+    hdr: {}
+  },
+  parseSync: parseHDR,
+  parse: async (arrayBuffer: ArrayBuffer) => parseHDR(arrayBuffer)
+} as const satisfies LoaderWithParser<
+  Texture<RadianceHDRMetadata>,
+  never,
+  RadianceHDRLoaderOptions
+>;

package/src/texture-array-loader.ts

@@ -0,0 +1,46 @@
+// loaders.gl
+// SPDX-License-Identifier: MIT
+// Copyright (c) vis.gl contributors
+
+import type {LoaderContext, LoaderWithParser} from '@loaders.gl/loader-utils';
+import type {Texture} from '@loaders.gl/schema';
+import type {TextureLoaderOptions as TextureApiLoaderOptions} from './lib/texture-api/texture-api-types';
+import {VERSION} from './lib/utils/version';
+import {
+  parseCompositeImageManifest,
+  testCompositeImageManifestShape,
+  type ImageTextureArrayManifest
+} from './lib/composite-image/parse-composite-image';
+
+export type TextureArrayLoaderOptions = TextureApiLoaderOptions;
+export type {ImageTextureArrayManifest as TextureArrayManifest};
+
+export const TextureArrayLoader = {
+  dataType: null as unknown as Texture,
+  batchType: null as never,
+  id: 'texture-array',
+  name: 'Texture Array',
+  module: 'textures',
+  version: VERSION,
+  extensions: [],
+  mimeTypes: [],
+  text: true,
+  worker: false,
+  testText: (text: string) => testCompositeImageManifestShape(text, 'image-texture-array'),
+  options: {
+    image: {}
+  },
+  parse: async (
+    arrayBuffer: ArrayBuffer,
+    options?: TextureArrayLoaderOptions,
+    context?: LoaderContext
+  ) =>
+    await parseCompositeImageManifest(
+      new TextDecoder().decode(arrayBuffer),
+      'image-texture-array',
+      options,
+      context
+    ),
+  parseText: async (text: string, options?: TextureArrayLoaderOptions, context?: LoaderContext) =>
+    await parseCompositeImageManifest(text, 'image-texture-array', options, context)
+} as const satisfies LoaderWithParser<Texture, never, TextureArrayLoaderOptions>;

package/src/texture-cube-array-loader.ts

@@ -0,0 +1,49 @@
+// loaders.gl
+// SPDX-License-Identifier: MIT
+// Copyright (c) vis.gl contributors
+
+import type {LoaderContext, LoaderWithParser} from '@loaders.gl/loader-utils';
+import type {Texture} from '@loaders.gl/schema';
+import type {TextureLoaderOptions as TextureApiLoaderOptions} from './lib/texture-api/texture-api-types';
+import {VERSION} from './lib/utils/version';
+import {
+  parseCompositeImageManifest,
+  testCompositeImageManifestShape,
+  type ImageTextureCubeArrayManifest
+} from './lib/composite-image/parse-composite-image';
+
+export type TextureCubeArrayLoaderOptions = TextureApiLoaderOptions;
+export type {ImageTextureCubeArrayManifest as TextureCubeArrayManifest};
+
+export const TextureCubeArrayLoader = {
+  dataType: null as unknown as Texture,
+  batchType: null as never,
+  id: 'texture-cube-array',
+  name: 'Texture Cube Array',
+  module: 'textures',
+  version: VERSION,
+  extensions: [],
+  mimeTypes: [],
+  text: true,
+  worker: false,
+  testText: (text: string) => testCompositeImageManifestShape(text, 'image-texture-cube-array'),
+  options: {
+    image: {}
+  },
+  parse: async (
+    arrayBuffer: ArrayBuffer,
+    options?: TextureCubeArrayLoaderOptions,
+    context?: LoaderContext
+  ) =>
+    await parseCompositeImageManifest(
+      new TextDecoder().decode(arrayBuffer),
+      'image-texture-cube-array',
+      options,
+      context
+    ),
+  parseText: async (
+    text: string,
+    options?: TextureCubeArrayLoaderOptions,
+    context?: LoaderContext
+  ) => await parseCompositeImageManifest(text, 'image-texture-cube-array', options, context)
+} as const satisfies LoaderWithParser<Texture, never, TextureCubeArrayLoaderOptions>;

package/src/texture-cube-loader.ts

@@ -0,0 +1,46 @@
+// loaders.gl
+// SPDX-License-Identifier: MIT
+// Copyright (c) vis.gl contributors
+
+import type {LoaderContext, LoaderWithParser} from '@loaders.gl/loader-utils';
+import type {Texture} from '@loaders.gl/schema';
+import type {TextureLoaderOptions as TextureApiLoaderOptions} from './lib/texture-api/texture-api-types';
+import {VERSION} from './lib/utils/version';
+import {
+  parseCompositeImageManifest,
+  testCompositeImageManifestShape,
+  type ImageTextureCubeManifest
+} from './lib/composite-image/parse-composite-image';
+
+export type TextureCubeLoaderOptions = TextureApiLoaderOptions;
+export type {ImageTextureCubeManifest as TextureCubeManifest};
+
+export const TextureCubeLoader = {
+  dataType: null as unknown as Texture,
+  batchType: null as never,
+  id: 'texture-cube',
+  name: 'Texture Cube',
+  module: 'textures',
+  version: VERSION,
+  extensions: [],
+  mimeTypes: [],
+  text: true,
+  worker: false,
+  testText: (text: string) => testCompositeImageManifestShape(text, 'image-texture-cube'),
+  options: {
+    image: {}
+  },
+  parse: async (
+    arrayBuffer: ArrayBuffer,
+    options?: TextureCubeLoaderOptions,
+    context?: LoaderContext
+  ) =>
+    await parseCompositeImageManifest(
+      new TextDecoder().decode(arrayBuffer),
+      'image-texture-cube',
+      options,
+      context
+    ),
+  parseText: async (text: string, options?: TextureCubeLoaderOptions, context?: LoaderContext) =>
+    await parseCompositeImageManifest(text, 'image-texture-cube', options, context)
+} as const satisfies LoaderWithParser<Texture, never, TextureCubeLoaderOptions>;

package/src/texture-loader.ts

@@ -0,0 +1,49 @@
+// loaders.gl
+// SPDX-License-Identifier: MIT
+// Copyright (c) vis.gl contributors
+
+import type {LoaderContext, LoaderWithParser} from '@loaders.gl/loader-utils';
+import type {Texture} from '@loaders.gl/schema';
+import type {TextureLoaderOptions as TextureApiLoaderOptions} from './lib/texture-api/texture-api-types';
+import {VERSION} from './lib/utils/version';
+import {
+  parseCompositeImageManifest,
+  testCompositeImageManifestShape,
+  type ImageTextureManifest
+} from './lib/composite-image/parse-composite-image';
+
+export type TextureManifestLoaderOptions = TextureApiLoaderOptions;
+export type {ImageTextureManifest as TextureManifest};
+
+export const TextureLoader = {
+  dataType: null as unknown as Texture,
+  batchType: null as never,
+  id: 'texture',
+  name: 'Texture',
+  module: 'textures',
+  version: VERSION,
+  extensions: [],
+  mimeTypes: [],
+  text: true,
+  worker: false,
+  testText: (text: string) => testCompositeImageManifestShape(text, 'image-texture'),
+  options: {
+    image: {}
+  },
+  parse: async (
+    arrayBuffer: ArrayBuffer,
+    options?: TextureManifestLoaderOptions,
+    context?: LoaderContext
+  ) =>
+    await parseCompositeImageManifest(
+      new TextDecoder().decode(arrayBuffer),
+      'image-texture',
+      options,
+      context
+    ),
+  parseText: async (
+    text: string,
+    options?: TextureManifestLoaderOptions,
+    context?: LoaderContext
+  ) => await parseCompositeImageManifest(text, 'image-texture', options, context)
+} as const satisfies LoaderWithParser<Texture, never, TextureManifestLoaderOptions>;