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

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
+};

package/src/shadertypes/{texture-formats.ts → textures/texture-formats.ts}

@@ -2,7 +2,61 @@
 // SPDX-License-Identifier: MIT
 // Copyright (c) vis.gl contributors
 
-import {NormalizedDataType} from './data-types';
+import {NormalizedDataType} from '../data-types/data-types';
+
+/** Information about the structure of a texture format */
+export type TextureFormatInfo = {
+  /** The format that is described */
+  format: TextureFormat;
+  /** Color or depth stencil attachment formats */
+  attachment?: 'color' | 'depth' | 'stencil' | 'depth-stencil';
+  /** String describing which channels this texture has */
+  channels: 'r' | 'rg' | 'rgb' | 'rgba' | 'bgra';
+  /** Number of components (corresponds to channels string) */
+  components: 1 | 2 | 3 | 4;
+  /** What is the data type of each component */
+  dataType?: NormalizedDataType;
+  /** Number of bytes per pixel */
+  bytesPerPixel: number;
+  /** Number of bits per channel (may be unreliable for packed formats) */
+  bitsPerChannel: [number, number, number, number];
+  /** If this is a packed data type */
+  packed?: boolean;
+  /** SRGB texture format? */
+  srgb?: boolean;
+  /** WebGL specific texture format? */
+  webgl?: boolean;
+  /** Is this an integer or floating point format? */
+  integer: boolean;
+  /** Is this a signed or unsigned format? */
+  signed: boolean;
+  /** Is this a normalized integer format? */
+  normalized: boolean;
+  /** Is this a compressed texture format */
+  compressed?: boolean;
+  /** Compressed formats only: Block size for ASTC formats (texture width must be a multiple of this value) */
+  blockWidth?: number;
+  /** Compressed formats only: Block size for ASTC formats (texture height must be a multiple of this value) */
+  blockHeight?: number;
+};
+
+/**
+ * Texture format capabilities.
+ * @note Not directly usable. Can contain TextureFeature strings that need to be checked against a specific device.
+ */
+export type TextureFormatCapabilities = {
+  format: TextureFormat;
+  /** Can the format be created */
+  create: TextureFeature | boolean;
+  /** If a feature string, the specified device feature determines if format is renderable. */
+  render: TextureFeature | boolean;
+  /** If a feature string, the specified device feature determines if format is filterable. */
+  filter: TextureFeature | boolean;
+  /** If a feature string, the specified device feature determines if format is blendable. */
+  blend: TextureFeature | boolean;
+  /** If a feature string, the specified device feature determines if format is storeable. */
+  store: TextureFeature | boolean;
+};
 
 /**
  * These represent the main compressed texture formats
@@ -18,11 +72,40 @@ export type TextureCompression =
   | 'astc'
   | 'rgtc';
 
+// TEXTURE FEATURES (optionally supported by the device)
+
+/**
+ * Texture feature checks
+ * @note these must be a subset of DeviceFeatures.
+ */
+export type TextureFeature =
+  | 'texture-compression-bc'
+  | 'texture-compression-astc'
+  | 'texture-compression-etc2'
+  | 'texture-compression-etc1-webgl'
+  | 'texture-compression-pvrtc-webgl'
+  | 'texture-compression-atc-webgl'
+  | 'float32-renderable-webgl'
+  | 'float16-renderable-webgl'
+  | 'rgb9e5ufloat-renderable-webgl'
+  | 'snorm8-renderable-webgl'
+  | 'norm16-renderable-webgl'
+  | 'snorm16-renderable-webgl'
+  | 'float32-filterable'
+  | 'float16-filterable-webgl';
+
+/** Chrome-specific extensions. Expected to eventually become standard features. */
+export type ChromeExperimentalTextureFeature =
+  | 'chromium-experimental-unorm16-texture-formats' // 'r16unorm', 'rg16unorm', 'rgba16unorm'
+  | 'chromium-experimental-snorm16-texture-formats'; // 'r16snorm', 'rg16snorm', 'rgba16snorm'
+
+// TEXTURE FORMATS
+
 /** Texture formats */
-export type TextureFormat = ColorTextureFormat | DepthStencilTextureFormat;
+export type TextureFormat = TextureFormatColor | TextureFormatDepthStencil;
 
 /** Depth and stencil texture formats */
-export type DepthStencilTextureFormat =
+export type TextureFormatDepthStencil =
   | 'stencil8'
   | 'depth16unorm'
   | 'depth24plus'
@@ -32,61 +115,72 @@ export type DepthStencilTextureFormat =
   | 'depth32float-stencil8';
 
 /** Texture formats for color attachments */
-export type ColorTextureFormat =
-  | WebGPUColorTextureFormat
-  | WebGL2ColorTextureFormat
-  | CompressedTextureFormat;
+export type TextureFormatColor = TextureFormatColorUncompressed | TextureFormatCompressed;
 
-export type WebGPUColorTextureFormat =
-  // 8-bit formats
-  | 'r8unorm'
-  | 'r8snorm'
-  | 'r8uint'
-  | 'r8sint'
+export type TextureFormatColorUncompressed =
+  | TextureFormatUnorm8
+  | TextureFormatSnorm8
+  | TextureFormatUint8
+  | TextureFormatSint8
+  | TextureFormatUnorm16
+  | TextureFormatSnorm16
+  | TextureFormatUint16
+  | TextureFormatSint16
+  | TextureFormatFloat16
+  | TextureFormatUint32
+  | TextureFormatSint32
+  | TextureFormatFloat32
+  | TextureFormatPacked16
+  | TextureFormatPacked32;
 
-  // 16-bit formats
-  | 'r16uint'
-  | 'r16sint'
-  | 'r16float'
+type TextureFormatUnorm8 =
+  | 'r8unorm'
   | 'rg8unorm'
-  | 'rg8snorm'
-  | 'rg8uint'
-  | 'rg8sint'
-
-  // 32-bit formats
-  | 'r32uint'
-  | 'r32sint'
-  | 'r32float'
-  | 'rg16uint'
-  | 'rg16sint'
-  | 'rg16float'
+  | 'rgb8unorm-webgl'
   | 'rgba8unorm'
   | 'rgba8unorm-srgb'
-  | 'rgba8snorm'
-  | 'rgba8uint'
-  | 'rgba8sint'
   | 'bgra8unorm'
-  | 'bgra8unorm-srgb'
-  // Packed 32-bit formats
-  | 'rgb9e5ufloat'
-  | 'rgb10a2unorm'
-  | 'rgb10a2uint'
-  | 'rg11b10ufloat'
+  | 'bgra8unorm-srgb';
 
-  // 64-bit formats
-  | 'rg32uint'
-  | 'rg32sint'
-  | 'rg32float'
-  | 'rgba16uint'
-  | 'rgba16sint'
-  | 'rgba16float'
+type TextureFormatSnorm8 = 'r8snorm' | 'rg8snorm' | 'rgb8snorm-webgl' | 'rgba8snorm';
 
-  // 128-bit formats
-  | 'rgba32uint'
-  | 'rgba32sint'
-  | 'rgba32float';
+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';
+
+export type TextureFormatCompressed =
+  | 'bc1-rgb-unorm-webgl'
+  | 'bc1-rgb-unorm-srgb-webgl'
+  | 'pvrtc-rgb4unorm-webgl'
+  | 'pvrtc-rgba4unorm-webgl'
+  | 'pvrtc-rbg2unorm-webgl'
+  | 'pvrtc-rgba2unorm-webgl'
+  | 'etc1-rbg-unorm-webgl'
+  | 'atc-rgb-unorm-webgl'
+  | 'atc-rgba-unorm-webgl'
+  | 'atc-rgbai-unorm-webgl'
 
-export type CompressedTextureFormat =
   // BC compressed formats usable if 'texture-compression-bc' is both
   // supported by the device/user agent and enabled in requestDevice.
   | 'bc1-rgba-unorm'
@@ -149,104 +243,92 @@ export type CompressedTextureFormat =
   | 'astc-12x12-unorm'
   | 'astc-12x12-unorm-srgb';
 
-/** Sized formats in WebGL 2 that are not (yet?) supported by WebGPU */
-export type WebGL2ColorTextureFormat =
-  | 'r16unorm-webgl'
-  | 'r16snorm-webgl'
-  | 'rgba4unorm-webgl'
-  | 'rgb565unorm-webgl'
-  | 'rgb5a1unorm-webgl'
-  | 'rgb8unorm-webgl'
-  | 'rgb8snorm-webgl'
-  | 'rg16unorm-webgl'
-  | 'rg16snorm-webgl'
-  | 'rgb10a2uint'
-  | 'rgb16unorm-webgl'
-  | 'rgb16snorm-webgl'
-  | 'rgba16unorm-webgl'
-  | 'rgba16snorm-webgl'
-  | 'rgb32float-webgl'
-  | 'bc1-rgb-unorm-webgl'
-  | 'bc1-rgb-unorm-srgb-webgl'
-  | 'pvrtc-rgb4unorm-webgl'
-  | 'pvrtc-rgba4unorm-webgl'
-  | 'pvrtc-rbg2unorm-webgl'
-  | 'pvrtc-rgba2unorm-webgl'
-  | 'etc1-rbg-unorm-webgl'
-  | 'atc-rgb-unorm-webgl'
-  | 'atc-rgba-unorm-webgl'
-  | 'atc-rgbai-unorm-webgl';
+// Texture format helper types
 
-/**
- * Texture feature checks
- * @note these must be a subset of DeviceFeatures.
- */
-export type TextureFeature =
-  | 'texture-compression-bc'
-  | 'texture-compression-astc'
-  | 'texture-compression-etc2'
-  | 'texture-compression-etc1-webgl'
-  | 'texture-compression-pvrtc-webgl'
-  | 'texture-compression-atc-webgl'
-  | 'float32-renderable-webgl'
-  | 'float16-renderable-webgl'
-  | 'rgb9e5ufloat-renderable-webgl'
-  | 'snorm8-renderable-webgl'
-  | 'norm16-renderable-webgl'
-  | 'snorm16-renderable-webgl'
-  | 'float32-filterable'
-  | 'float16-filterable-webgl';
+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;
 
-/** Information about the structure of a texture format */
-export type TextureFormatInfo = {
-  /** The format that is described */
-  format: TextureFormat;
-  /** Color or depth stencil attachment formats */
-  attachment?: 'color' | 'depth' | 'stencil' | 'depth-stencil';
-  /** String describing which channels this texture has */
-  channels: 'r' | 'rg' | 'rgb' | 'rgba' | 'bgra';
-  /** Number of components (corresponds to channels string) */
-  components: 1 | 2 | 3 | 4;
-  /** What is the data type of each component */
-  dataType?: NormalizedDataType;
-  /** If this is a packed data type */
-  packed?: boolean;
-  /** Number of bytes per pixel */
-  bytesPerPixel?: number;
-  /** Number of bits per channel (may be unreliable for packed formats) */
-  bitsPerChannel: [number, number, number, number];
-  /** SRGB texture format? */
-  srgb?: boolean;
-  /** WebGL specific texture format? */
-  webgl?: boolean;
-  /** Is this an integer or floating point format? */
-  integer: boolean;
-  /** Is this a signed or unsigned format? */
-  signed: boolean;
-  /** Is this a normalized integer format? */
-  normalized: boolean;
-  /** Is this a compressed texture format */
-  compressed?: boolean;
-  /** Compressed formats only: Block size for ASTC formats (texture width must be a multiple of this value) */
-  blockWidth?: number;
-  /** Compressed formats only: Block size for ASTC formats (texture height must be a multiple of this value) */
-  blockHeight?: number;
-};
+/*
+export type TextureFormatColorWebGPU =
+  // 8-bit formats
+  | 'r8unorm'
+  | 'r8snorm'
+  | 'r8uint'
+  | 'r8sint'
+  | 'rg8unorm'
+  | 'rg8snorm'
+  | 'rg8uint'
+  | 'rg8sint'
+  | 'rgba8unorm'
+  | 'rgba8unorm-srgb'
+  | 'rgba8snorm'
+  | 'rgba8uint'
+  | 'rgba8sint'
+  | 'bgra8unorm'
+  | 'bgra8unorm-srgb'
 
-/**
- * Texture format capabilities.
- * @note Not directly usable. Can contain TextureFeature strings that need to be checked against a specific device.
- */
-export type TextureFormatCapabilities = {
-  format: TextureFormat;
-  /** Can the format be created */
-  create: TextureFeature | boolean;
-  /** If a feature string, the specified device feature determines if format is renderable. */
-  render: TextureFeature | boolean;
-  /** If a feature string, the specified device feature determines if format is filterable. */
-  filter: TextureFeature | boolean;
-  /** If a feature string, the specified device feature determines if format is blendable. */
-  blend: TextureFeature | boolean;
-  /** If a feature string, the specified device feature determines if format is storeable. */
-  store: TextureFeature | boolean;
-};
+  // 16-bit formats
+  | 'r16unorm' // feature: 'chromium-experimental-snorm16-texture-formats' chrome://flags/#enable-unsafe-webgpu 'r16unorm', 'rg16unorm', 'rgba16unorm',
+  | 'r16snorm' // feature: 'chromium-experimental-unorm16-texture-formats' chrome://flags/#enable-unsafe-webgpu 'r16snorm', 'rg16snorm',  'rgba16snorm'.
+  | 'r16uint'
+  | 'r16sint'
+  | 'r16float'
+  | 'rg16unorm' // feature: 'chromium-experimental-snorm16-texture-formats' chrome://flags/#enable-unsafe-webgpu 'r16unorm', 'rg16unorm', 'rgba16unorm',
+  | 'rg16snorm' // feature: 'chromium-experimental-unorm16-texture-formats' chrome://flags/#enable-unsafe-webgpu 'r16snorm', 'rg16snorm',  'rgba16snorm'.
+  | 'rgba16unorm' // feature: 'chromium-experimental-snorm16-texture-formats' chrome://flags/#enable-unsafe-webgpu 'r16unorm', 'rg16unorm', 'rgba16unorm',
+  | 'rgba16snorm' // feature: 'chromium-experimental-unorm16-texture-formats' chrome://flags/#enable-unsafe-webgpu 'r16snorm', 'rg16snorm',  'rgba16snorm'.
+  | 'rg16uint'
+  | 'rgba16uint'
+  | 'rg16sint'
+  | 'rgba16sint'
+  | 'rg16float'
+  | 'rgba16float'
+
+  // 32-bit formats
+  | 'r32uint'
+  | 'rg32uint'
+  | 'rgba32uint'
+  | 'r32sint'
+  | 'rg32sint'
+  | 'rgba32sint'
+  | 'r32float'
+  | 'rg32float'
+  | 'rgba32float'
+
+  // Packed 32-bit formats
+  | 'rgb9e5ufloat'
+  | 'rgb10a2unorm'
+  | 'rgb10a2uint'
+  | 'rg11b10ufloat';
+*/

package/src/shadertypes/{utils → vertex-arrays}/decode-vertex-format.ts

@@ -3,13 +3,9 @@
 // Copyright (c) vis.gl contributors
 
 import type {TypedArray} from '../../types';
-import type {NormalizedDataType, PrimitiveDataType, SignedDataType} from '../data-types';
-import type {VertexFormat, VertexFormatInfo} from '../vertex-formats';
-import {
-  getDataTypeInfo,
-  getDataTypeFromTypedArray,
-  makeNormalizedDataType
-} from './decode-data-types';
+import type {NormalizedDataType, PrimitiveDataType, SignedDataType} from '../data-types/data-types';
+import type {VertexFormat, VertexFormatInfo} from './vertex-formats';
+import {getDataTypeInfo, getDataType, getNormalizedDataType} from '../data-types/decode-data-types';
 
 /**
  * Decodes a vertex format, returning type, components, byte  length and flags (integer, signed, normalized)
@@ -48,14 +44,14 @@ export function makeVertexFormat(
   normalized?: boolean
 ): VertexFormat {
   const dataType: NormalizedDataType = normalized
-    ? makeNormalizedDataType(signedDataType)
+    ? getNormalizedDataType(signedDataType)
     : signedDataType;
 
   switch (dataType) {
     // TODO - Special cases for WebGL (not supported on WebGPU), overrides the check below
     case 'unorm8':
       if (components === 1) {
-        return 'unorm8-webgl';
+        return 'unorm8';
       }
       if (components === 3) {
         return 'unorm8x3-webgl';
@@ -94,7 +90,7 @@ export function getVertexFormatFromAttribute(
   }
 
   const components = size as 1 | 2 | 3 | 4;
-  const signedDataType = getDataTypeFromTypedArray(typedArray);
+  const signedDataType = getDataType(typedArray);
   return makeVertexFormat(signedDataType, components, normalized);
 }