@luma.gl/core 9.2.0-alpha.1 → 9.2.0-alpha.3

package/src/shadertypes/{utils/decode-texture-format.ts → textures/texture-format-decoder.ts}

@@ -2,14 +2,15 @@
 // SPDX-License-Identifier: MIT
 // Copyright (c) vis.gl contributors
 
-import type {NormalizedDataType} from '../data-types';
+import type {NormalizedDataType} from '../data-types/data-types';
+import {getDataTypeInfo} from '../data-types/decode-data-types';
 import type {
   TextureFormat,
-  CompressedTextureFormat,
+  TextureFormatCompressed,
   TextureFormatInfo,
-  TextureFormatCapabilities
-} from '../texture-formats';
-import {getDataTypeInfo} from './decode-data-types';
+  TextureFormatCapabilities,
+  TextureFormatColor
+} from './texture-formats';
 import {getTextureFormatDefinition} from './texture-format-table';
 
 // prettier-ignore
@@ -19,22 +20,69 @@ const COMPRESSED_TEXTURE_FORMAT_PREFIXES = [
 
 const RGB_FORMAT_REGEX = /^(r|rg|rgb|rgba|bgra)([0-9]*)([a-z]*)(-srgb)?(-webgl)?$/;
 
-/**
- * Returns true if a texture format is GPU compressed
- */
-export function isTextureFormatCompressed(
-  format: TextureFormat
-): format is CompressedTextureFormat {
-  return COMPRESSED_TEXTURE_FORMAT_PREFIXES.some(prefix => (format as string).startsWith(prefix));
+export class TextureFormatDecoder {
+  /** Returns information about a texture format, e.g. attatchment type, components, byte length and flags (integer, signed, normalized) */
+  getInfo(format: TextureFormat): TextureFormatInfo {
+    return getTextureFormatInfo(format);
+  }
+
+  /** Checks if a texture format is color */
+  isColor(format: TextureFormat): format is TextureFormatColor {
+    return format.startsWith('rgba') || format.startsWith('bgra') || format.startsWith('rgb');
+  }
+
+  /** Checks if a texture format is depth or stencil */
+  isDepthStencil(format: TextureFormat): boolean {
+    return format.startsWith('depth') || format.startsWith('stencil');
+  }
+
+  /** Checks if a texture format is compressed */
+  isCompressed(format: TextureFormat): format is TextureFormatCompressed {
+    return COMPRESSED_TEXTURE_FORMAT_PREFIXES.some(prefix => (format as string).startsWith(prefix));
+  }
+
+  /**
+   * Returns the "static" capabilities of a texture format.
+   * @note Needs to be checked against current device
+   */
+  getCapabilities(format: TextureFormat): TextureFormatCapabilities {
+    const info = getTextureFormatDefinition(format);
+
+    const formatCapabilities: Required<TextureFormatCapabilities> = {
+      format,
+      create: info.f ?? true,
+      render: info.render ?? true,
+      filter: info.filter ?? true,
+      blend: info.blend ?? true,
+      store: info.store ?? true
+    };
+
+    const formatInfo = getTextureFormatInfo(format);
+    const isDepthStencil = format.startsWith('depth') || format.startsWith('stencil');
+    const isSigned = formatInfo?.signed;
+    const isInteger = formatInfo?.integer;
+    const isWebGLSpecific = formatInfo?.webgl;
+
+    // signed formats are not renderable
+    formatCapabilities.render &&= !isSigned;
+    // signed and integer formats are not filterable
+    formatCapabilities.filter &&= !isDepthStencil && !isSigned && !isInteger && !isWebGLSpecific;
+
+    return formatCapabilities;
+  }
 }
 
+export const textureFormatDecoder = new TextureFormatDecoder();
+
+// HELPERS
+
 /**
  * Decodes a texture format, returning e.g. attatchment type, components, byte length and flags (integer, signed, normalized)
  */
-export function getTextureFormatInfo(format: TextureFormat): TextureFormatInfo {
+function getTextureFormatInfo(format: TextureFormat): TextureFormatInfo {
   let formatInfo: TextureFormatInfo = getTextureFormatInfoUsingTable(format);
 
-  if (isTextureFormatCompressed(format)) {
+  if (textureFormatDecoder.isCompressed(format)) {
     formatInfo.channels = 'rgb';
     formatInfo.components = 3;
     formatInfo.bytesPerPixel = 1;
@@ -97,38 +145,6 @@ export function getTextureFormatInfo(format: TextureFormat): TextureFormatInfo {
   return formatInfo;
 }
 
-/**
- * Returns the "static" capabilities of a texture format.
- * @note Needs to be checked against current device
- */
-export function getTextureFormatCapabilities(format: TextureFormat): TextureFormatCapabilities {
-  const info = getTextureFormatDefinition(format);
-
-  const formatCapabilities: Required<TextureFormatCapabilities> = {
-    format,
-    create: info.f ?? true,
-    render: info.render ?? true,
-    filter: info.filter ?? true,
-    blend: info.blend ?? true,
-    store: info.store ?? true
-  };
-
-  const formatInfo = getTextureFormatInfo(format);
-  const isDepthStencil = format.startsWith('depth') || format.startsWith('stencil');
-  const isSigned = formatInfo?.signed;
-  const isInteger = formatInfo?.integer;
-  const isWebGLSpecific = formatInfo?.webgl;
-
-  // signed formats are not renderable
-  formatCapabilities.render &&= !isSigned;
-  // signed and integer formats are not filterable
-  formatCapabilities.filter &&= !isDepthStencil && !isSigned && !isInteger && !isWebGLSpecific;
-
-  return formatCapabilities;
-}
-
-// HELPERS
-
 /** Decode texture format info from the table */
 function getTextureFormatInfoUsingTable(format: TextureFormat): TextureFormatInfo {
   const info = getTextureFormatDefinition(format);
@@ -166,7 +182,7 @@ function getTextureFormatInfoUsingTable(format: TextureFormat): TextureFormatInf
 
 /** Parses ASTC block widths from format string */
 function getCompressedTextureBlockSize(
-  format: CompressedTextureFormat
+  format: TextureFormatCompressed
 ): {blockWidth: number; blockHeight: number} | null {
   const REGEX = /.*-(\d+)x(\d+)-.*/;
   const matches = REGEX.exec(format as string);

package/src/shadertypes/textures/texture-format-generics.ts

@@ -0,0 +1,190 @@
+// luma.gl
+// SPDX-License-Identifier: MIT
+// Copyright (c) vis.gl contributors
+
+import {
+  type TextureFormat,
+  type TextureFormatDepthStencil,
+  type TextureFormatCompressed
+} from './texture-formats';
+
+import {type DataTypeArray, NormalizedDataTypeArray} from '../data-types/data-types';
+
+export type TextureFormatTypedArray<T extends TextureFormat> = DataTypeArray<
+  TextureFormatDataType<T>
+>;
+
+export type TextureFormatNormalizedTypedArray<T extends TextureFormat> = NormalizedDataTypeArray<
+  TextureFormatDataType<T>
+>;
+
+/** A numeric array of length matching the number of components in the texture format */
+export type TextureFormatPixel<T extends TextureFormat> =
+  TextureFormatPackedComponents<T> extends 1
+    ? [number]
+    : TextureFormatPackedComponents<T> extends 2
+      ? [number, number]
+      : TextureFormatPackedComponents<T> extends 3
+        ? [number, number, number]
+        : TextureFormatPackedComponents<T> extends 4
+          ? [number, number, number, number]
+          : never;
+
+/** @note packed formats have only one component. Use TextureFormatPackedComponents */
+export type TextureFormatComponents<T extends TextureFormat> = T extends
+  | TextureFormatR
+  | TextureFormatPackedRGB
+  | TextureFormatPackedRGBA
+  ? 1
+  : T extends TextureFormatRG
+    ? 2
+    : T extends TextureFormatRGB
+      ? 3
+      : T extends TextureFormatRGBA
+        ? 4
+        : never;
+
+export type TextureFormatPackedComponents<T extends TextureFormat> = T extends TextureFormatR
+  ? 1
+  : T extends TextureFormatRG
+    ? 2
+    : T extends TextureFormatRGB | TextureFormatPackedRGB
+      ? 3
+      : T extends TextureFormatRGBA | TextureFormatPackedRGBA
+        ? 4
+        : never;
+
+/** Get the data type for a texture format */
+export type TextureFormatDataType<T extends TextureFormat> = T extends TextureFormatUint8
+  ? 'uint8'
+  : T extends TextureFormatSint8
+    ? 'sint8'
+    : T extends TextureFormatUnorm8
+      ? 'unorm8'
+      : T extends TextureFormatSnorm8
+        ? 'snorm8'
+        : T extends TextureFormatUint16
+          ? 'uint16'
+          : T extends TextureFormatSint16
+            ? 'sint16'
+            : T extends TextureFormatUnorm16
+              ? 'unorm16'
+              : T extends TextureFormatSnorm16
+                ? 'snorm16'
+                : T extends TextureFormatUint32
+                  ? 'uint32'
+                  : T extends TextureFormatSint32
+                    ? 'sint32'
+                    : T extends TextureFormatFloat16
+                      ? 'float16'
+                      : T extends TextureFormatFloat32
+                        ? 'float32'
+                        : T extends TextureFormatDepthStencil
+                          ? 'uint32'
+                          : T extends TextureFormatCompressed
+                            ? 'uint8'
+                            : T extends TextureFormatPacked16
+                              ? 'uint16'
+                              : T extends TextureFormatPacked32
+                                ? 'uint32'
+                                : never;
+
+// Component groups
+
+type TextureFormatR =
+  | 'r8uint'
+  | 'r8sint'
+  | 'r8unorm'
+  | 'r8snorm'
+  | 'r16unorm'
+  | 'r16snorm'
+  | 'r16uint'
+  | 'r16sint'
+  | 'r16float'
+  | 'r32uint'
+  | 'r32sint'
+  | 'r32float';
+
+type TextureFormatRG =
+  | 'rg8unorm'
+  | 'rg8snorm'
+  | 'rg8uint'
+  | 'rg8sint'
+  | 'rg16unorm'
+  | 'rg16snorm'
+  | 'rg16uint'
+  | 'rg16sint'
+  | 'rg16float'
+  | 'rg32uint'
+  | 'rg32sint'
+  | 'rg32float';
+
+type TextureFormatRGB =
+  | 'rgb8unorm-webgl'
+  | 'rgb8snorm-webgl'
+  | 'rgb16unorm-webgl'
+  | 'rgb16snorm-webgl'
+  | 'rgb32float-webgl';
+
+type TextureFormatRGBA =
+  | 'rgba8uint'
+  | 'rgba8unorm'
+  | 'rgba8unorm-srgb'
+  | 'rgba8snorm'
+  | 'bgra8unorm'
+  | 'bgra8unorm-srgb'
+  | 'rgba8sint'
+  | 'rgba16unorm'
+  | 'rgba16snorm'
+  | 'rgba16uint'
+  | 'rgba16sint'
+  | 'rgba16float'
+  | 'rgba32uint'
+  | 'rgba32sint'
+  | 'rgba32float';
+
+type TextureFormatPackedRGB = 'rgb565unorm-webgl' | 'rgb9e5ufloat' | 'rg11b10ufloat';
+
+type TextureFormatPackedRGBA =
+  | 'rgba4unorm-webgl'
+  | 'rgb5a1unorm-webgl'
+  | 'rgb10a2unorm'
+  | 'rgb10a2uint';
+
+// Data type groups
+
+type TextureFormatUnorm8 =
+  | 'r8unorm'
+  | 'rg8unorm'
+  | 'rgb8unorm-webgl'
+  | 'rgba8unorm'
+  | 'rgba8unorm-srgb'
+  | 'bgra8unorm'
+  | 'bgra8unorm-srgb';
+
+type TextureFormatSnorm8 = 'r8snorm' | 'rg8snorm' | 'rgb8snorm-webgl' | 'rgba8snorm';
+
+type TextureFormatUint8 = 'r8uint' | 'rg8uint' | 'rgba8uint';
+
+type TextureFormatSint8 = 'r8sint' | 'rg8sint' | 'rgba8sint';
+
+type TextureFormatUnorm16 = 'r16unorm' | 'rg16unorm' | 'rgb16unorm-webgl' | 'rgba16unorm';
+
+type TextureFormatSnorm16 = 'r16snorm' | 'rg16snorm' | 'rgb16snorm-webgl' | 'rgba16snorm';
+
+type TextureFormatUint16 = 'r16uint' | 'rg16uint' | 'rgba16uint';
+
+type TextureFormatSint16 = 'r16sint' | 'rg16sint' | 'rgba16sint';
+
+type TextureFormatFloat16 = 'r16float' | 'rg16float' | 'rgba16float';
+
+// 96-bit formats (deprecated!)
+type TextureFormatUint32 = 'r32uint' | 'rg32uint' | 'rgba32uint';
+
+type TextureFormatSint32 = 'r32sint' | 'rg32sint' | 'rgba32sint';
+
+type TextureFormatFloat32 = 'r32float' | 'rg32float' | 'rgb32float-webgl' | 'rgba32float';
+
+type TextureFormatPacked16 = 'rgba4unorm-webgl' | 'rgb565unorm-webgl' | 'rgb5a1unorm-webgl';
+
+type TextureFormatPacked32 = 'rgb9e5ufloat' | 'rg11b10ufloat' | 'rgb10a2unorm' | 'rgb10a2uint';

package/src/shadertypes/{utils → textures}/texture-format-table.ts

@@ -2,7 +2,14 @@
 // SPDX-License-Identifier: MIT
 // Copyright (c) vis.gl contributors
 
-import {TextureFormat, TextureFeature, TextureFormatInfo} from '../texture-formats';
+import {
+  TextureFormat,
+  TextureFormatColorUncompressed,
+  TextureFormatDepthStencil,
+  TextureFeature,
+  TextureFormatInfo,
+  TextureFormatCompressed
+} from './texture-formats';
 /* eslint-disable camelcase */
 
 // Define local device feature strings to optimize minification
@@ -61,54 +68,70 @@ export function getTextureFormatTable(): Readonly<Record<TextureFormat, TextureF
 }
 
 // prettier-ignore
-const TEXTURE_FORMAT_TABLE: Readonly<Record<TextureFormat, TextureFormatDefinition>> = {
+const TEXTURE_FORMAT_COLOR_DEPTH_TABLE: Readonly<Record<TextureFormatColorUncompressed | TextureFormatDepthStencil, TextureFormatDefinition>> = {
   // 8-bit formats
   'r8unorm': {},
-  'r8snorm': {render: snorm8_renderable},
-  'r8uint': {},
-  'r8sint': {},
-
-  // 16-bit formats
   'rg8unorm': {},
-  'rg8snorm': {render: snorm8_renderable},
-  'rg8uint': {},
-  'rg8sint': {},
-
-  'r16uint': {},
-  'r16sint': {},
-  'r16float': {render: float16_renderable, filter: 'float16-filterable-webgl'},
-  'r16unorm-webgl': {f: norm16_renderable},
-  'r16snorm-webgl': {f: snorm16_renderable},
-
-  // Packed 16-bit formats
-  'rgba4unorm-webgl': {channels: 'rgba', bitsPerChannel: [4, 4, 4, 4], packed: true},
-  'rgb565unorm-webgl': {channels: 'rgb', bitsPerChannel: [5, 6, 5, 0], packed: true},
-  'rgb5a1unorm-webgl': {channels: 'rgba', bitsPerChannel: [5, 5, 5, 1], packed: true},
-
-  // 24-bit formats
   'rgb8unorm-webgl': {},
-  'rgb8snorm-webgl': {},
-
-  // 32-bit formats  
   'rgba8unorm': {},
   'rgba8unorm-srgb': {},
+
+  'r8snorm': {render: snorm8_renderable},
+  'rg8snorm': {render: snorm8_renderable},
+  'rgb8snorm-webgl': {},
   'rgba8snorm': {render: snorm8_renderable},
+
+  'r8uint': {},
+  'rg8uint': {},
   'rgba8uint': {},
+
+  'r8sint': {},
+  'rg8sint': {},
   'rgba8sint': {},
 
-  // 32-bit, reverse colors, webgpu only
   'bgra8unorm': {},
   'bgra8unorm-srgb': {},
 
+
+  'r16unorm': {f: norm16_renderable},
+  'rg16unorm': {render: norm16_renderable},
+  'rgb16unorm-webgl': {f: norm16_renderable}, // rgb not renderable
+  'rgba16unorm': {render: norm16_renderable},
+
+  'r16snorm': {f: snorm16_renderable},
+  'rg16snorm': {render: snorm16_renderable},
+  'rgb16snorm-webgl': {f: norm16_renderable}, // rgb not renderable
+  'rgba16snorm': {render: snorm16_renderable},
+
+  'r16uint': {},
   'rg16uint': {},
+  'rgba16uint': {},
+
+  'r16sint': {},
   'rg16sint': {},
+  'rgba16sint': {},
+
+  'r16float': {render: float16_renderable, filter: 'float16-filterable-webgl'},
   'rg16float': {render: float16_renderable, filter: float16_filterable},
-  'rg16unorm-webgl': {render: norm16_renderable},
-  'rg16snorm-webgl': {render: snorm16_renderable},
+  'rgba16float': {render: float16_renderable, filter: float16_filterable},
 
   'r32uint': {},
+  'rg32uint': {},
+  'rgba32uint': {},
+
   'r32sint': {},
+  'rg32sint': {},
+  'rgba32sint': {},
+
   'r32float': {render: float32_renderable, filter: float32_filterable},
+  'rg32float': {render: false, filter: float32_filterable},
+  'rgb32float-webgl': {render: float32_renderable, filter: float32_filterable},
+  'rgba32float': {render: float32_renderable, filter: float32_filterable},
+
+  // Packed 16-bit formats
+  'rgba4unorm-webgl': {channels: 'rgba', bitsPerChannel: [4, 4, 4, 4], packed: true},
+  'rgb565unorm-webgl': {channels: 'rgb', bitsPerChannel: [5, 6, 5, 0], packed: true},
+  'rgb5a1unorm-webgl': {channels: 'rgba', bitsPerChannel: [5, 5, 5, 1], packed: true},
 
   // Packed 32 bit formats
   'rgb9e5ufloat': {channels: 'rgb', packed: true, render: rgb9e5ufloat_renderable}, // , filter: true},
@@ -116,29 +139,7 @@ const TEXTURE_FORMAT_TABLE: Readonly<Record<TextureFormat, TextureFormatDefiniti
   'rgb10a2unorm': {channels: 'rgba',  bitsPerChannel: [10, 10, 10, 2], packed: true, p: 1},
   'rgb10a2uint': {channels: 'rgba',  bitsPerChannel: [10, 10, 10, 2], packed: true, p: 1},
 
-  // 48-bit formats
-  'rgb16unorm-webgl': {f: norm16_renderable}, // rgb not renderable
-  'rgb16snorm-webgl': {f: norm16_renderable}, // rgb not renderable
-
-  // 64-bit formats
-  'rg32uint': {},
-  'rg32sint': {},
-  'rg32float': {render: false, filter: float32_filterable},
-  'rgba16uint': {},
-  'rgba16sint': {},
-  'rgba16float': {render: float16_renderable, filter: float16_filterable},
-  'rgba16unorm-webgl': {render: norm16_renderable},
-  'rgba16snorm-webgl': {render: snorm16_renderable},
-
-  // 96-bit formats (deprecated!)
-  'rgb32float-webgl': {render: float32_renderable, filter: float32_filterable},
-  
-  // 128-bit formats
-  'rgba32uint': {},
-  'rgba32sint': {},
-  'rgba32float': {render: float32_renderable, filter: float32_filterable},
-
-  // Depth/stencil
+  // Depth/stencil Formats
   
   // Depth and stencil formats
   stencil8: {attachment: 'stencil', bitsPerChannel: [8, 0, 0, 0], dataType: 'uint8'},
@@ -149,6 +150,10 @@ const TEXTURE_FORMAT_TABLE: Readonly<Record<TextureFormat, TextureFormatDefiniti
   'depth24plus-stencil8': {attachment: 'depth-stencil', bitsPerChannel: [24, 8, 0, 0], packed: true},
   // "depth32float-stencil8" feature
   'depth32float-stencil8': {attachment: 'depth-stencil', bitsPerChannel: [32, 8, 0, 0], packed: true},
+};
+
+// prettier-ignore
+const TEXTURE_FORMAT_COMPRESSED_TABLE: Readonly<Record<TextureFormatCompressed, TextureFormatDefinition>> = {
 
   // BC compressed formats: check device.features.has("texture-compression-bc");
 
@@ -233,3 +238,8 @@ const TEXTURE_FORMAT_TABLE: Readonly<Record<TextureFormat, TextureFormatDefiniti
   'atc-rgba-unorm-webgl': {f: texture_compression_atc_webgl},
   'atc-rgbai-unorm-webgl': {f: texture_compression_atc_webgl}
 };
+
+export const TEXTURE_FORMAT_TABLE: Readonly<Record<TextureFormat, TextureFormatDefinition>> = {
+  ...TEXTURE_FORMAT_COLOR_DEPTH_TABLE,
+  ...TEXTURE_FORMAT_COMPRESSED_TABLE
+};