@luma.gl/shaders 0.0.0-stage → 10.0.0-alpha.5

package/src/types/shader-type-decoder.ts

@@ -0,0 +1,285 @@
+// luma.gl
+// SPDX-License-Identifier: MIT
+// SPDX-FileCopyrightText: Copyright (c) vis.gl contributors
+
+import {type PrimitiveDataType} from './primitive-data-types';
+import {
+  type VariableShaderType,
+  type AttributeShaderType,
+  type VariableShaderTypeAlias,
+  type AttributeShaderTypeAlias
+} from './shader-types';
+
+/** Information extracted from a VariableShaderType constant */
+export type VariableShaderTypeInfo = {
+  type: PrimitiveDataType;
+  components: number;
+};
+
+/** Information extracted from a AttributeShaderType constant */
+export type AttributeShaderTypeInfo = {
+  /** WGSL-style primitive data type, f32, i32, u32 */
+  primitiveType: PrimitiveDataType;
+  /** Whether this is a normalized integer (that must be used as float) */
+  components: 1 | 2 | 3 | 4;
+  /** Length in bytes of the data for one vertex */
+  byteLength?: number;
+  /** Whether this is for integer or float vert */
+  integer: boolean;
+  /** Whether this data type is signed */
+  signed: boolean;
+};
+
+/** Split a uniform type string into type and components */
+export function getVariableShaderTypeInfo(
+  format: VariableShaderType | VariableShaderTypeAlias
+): VariableShaderTypeInfo {
+  const resolvedFormat = resolveVariableShaderTypeAlias(format);
+  const decoded = UNIFORM_FORMATS[resolvedFormat];
+  if (!decoded) {
+    throw new Error(`Unsupported variable shader type: ${format}`);
+  }
+  return decoded;
+}
+
+/** Decodes a vertex type, returning byte length and flags (integer, signed, normalized) */
+export function getAttributeShaderTypeInfo(
+  attributeType: AttributeShaderType | AttributeShaderTypeAlias
+): AttributeShaderTypeInfo {
+  const resolvedAttributeType = resolveAttributeShaderTypeAlias(attributeType);
+  const decoded = TYPE_INFO[resolvedAttributeType];
+  if (!decoded) {
+    throw new Error(`Unsupported attribute shader type: ${attributeType}`);
+  }
+  const [primitiveType, components] = decoded;
+  const integer: boolean = primitiveType === 'i32' || primitiveType === 'u32';
+  const signed: boolean = primitiveType !== 'u32';
+
+  const byteLength = PRIMITIVE_TYPE_SIZES[primitiveType] * components;
+  return {
+    primitiveType,
+    components,
+    byteLength,
+    integer,
+    signed
+  };
+}
+
+export class ShaderTypeDecoder {
+  getVariableShaderTypeInfo(
+    format: VariableShaderType | VariableShaderTypeAlias
+  ): VariableShaderTypeInfo {
+    return getVariableShaderTypeInfo(format);
+  }
+
+  getAttributeShaderTypeInfo(
+    attributeType: AttributeShaderType | AttributeShaderTypeAlias
+  ): AttributeShaderTypeInfo {
+    return getAttributeShaderTypeInfo(attributeType);
+  }
+
+  makeShaderAttributeType(
+    primitiveType: PrimitiveDataType,
+    components: 1 | 2 | 3 | 4
+  ): AttributeShaderType {
+    return makeShaderAttributeType(primitiveType, components);
+  }
+
+  resolveAttributeShaderTypeAlias(
+    alias: AttributeShaderTypeAlias | AttributeShaderType
+  ): AttributeShaderType {
+    return resolveAttributeShaderTypeAlias(alias);
+  }
+
+  resolveVariableShaderTypeAlias(
+    alias: VariableShaderTypeAlias | VariableShaderType
+  ): VariableShaderType {
+    return resolveVariableShaderTypeAlias(alias);
+  }
+}
+
+export function makeShaderAttributeType(
+  primitiveType: PrimitiveDataType,
+  components: 1 | 2 | 3 | 4
+): AttributeShaderType {
+  return components === 1 ? primitiveType : `vec${components}<${primitiveType}>`;
+}
+
+export function resolveAttributeShaderTypeAlias(
+  alias: AttributeShaderTypeAlias | AttributeShaderType
+): AttributeShaderType {
+  return WGSL_ATTRIBUTE_TYPE_ALIAS_MAP[alias as AttributeShaderTypeAlias] || alias;
+}
+
+export function resolveVariableShaderTypeAlias(
+  alias: VariableShaderTypeAlias | VariableShaderType
+): VariableShaderType {
+  return WGSL_VARIABLE_TYPE_ALIAS_MAP[alias as VariableShaderTypeAlias] || alias;
+}
+
+/** Decoder for luma.gl shader types */
+export const shaderTypeDecoder = new ShaderTypeDecoder();
+
+// TABLES
+
+const PRIMITIVE_TYPE_SIZES: Record<PrimitiveDataType, 2 | 4> = {
+  f32: 4,
+  f16: 2,
+  i32: 4,
+  u32: 4
+  // 'bool-webgl': 4,
+};
+
+/** All valid shader attribute types. A table guarantees exhaustive list and fast execution */
+const TYPE_INFO: Record<AttributeShaderType, [PrimitiveDataType, components: 1 | 2 | 3 | 4]> = {
+  f32: ['f32', 1],
+  'vec2<f32>': ['f32', 2],
+  'vec3<f32>': ['f32', 3],
+  'vec4<f32>': ['f32', 4],
+  f16: ['f16', 1],
+  'vec2<f16>': ['f16', 2],
+  'vec3<f16>': ['f16', 3],
+  'vec4<f16>': ['f16', 4],
+  i32: ['i32', 1],
+  'vec2<i32>': ['i32', 2],
+  'vec3<i32>': ['i32', 3],
+  'vec4<i32>': ['i32', 4],
+  u32: ['u32', 1],
+  'vec2<u32>': ['u32', 2],
+  'vec3<u32>': ['u32', 3],
+  'vec4<u32>': ['u32', 4]
+};
+
+/** @todo These tables are quite big, consider parsing type strings instead */
+const UNIFORM_FORMATS: Record<VariableShaderType, {type: PrimitiveDataType; components: number}> = {
+  f32: {type: 'f32', components: 1},
+  f16: {type: 'f16', components: 1},
+  i32: {type: 'i32', components: 1},
+  u32: {type: 'u32', components: 1},
+  // 'bool-webgl': {type: 'bool-webgl', components: 1},
+  'vec2<f32>': {type: 'f32', components: 2},
+  'vec3<f32>': {type: 'f32', components: 3},
+  'vec4<f32>': {type: 'f32', components: 4},
+  'vec2<f16>': {type: 'f16', components: 2},
+  'vec3<f16>': {type: 'f16', components: 3},
+  'vec4<f16>': {type: 'f16', components: 4},
+  'vec2<i32>': {type: 'i32', components: 2},
+  'vec3<i32>': {type: 'i32', components: 3},
+  'vec4<i32>': {type: 'i32', components: 4},
+  'vec2<u32>': {type: 'u32', components: 2},
+  'vec3<u32>': {type: 'u32', components: 3},
+  'vec4<u32>': {type: 'u32', components: 4},
+
+  'mat2x2<f32>': {type: 'f32', components: 4},
+  'mat2x3<f32>': {type: 'f32', components: 6},
+  'mat2x4<f32>': {type: 'f32', components: 8},
+  'mat3x2<f32>': {type: 'f32', components: 6},
+  'mat3x3<f32>': {type: 'f32', components: 9},
+  'mat3x4<f32>': {type: 'f32', components: 12},
+  'mat4x2<f32>': {type: 'f32', components: 8},
+  'mat4x3<f32>': {type: 'f32', components: 12},
+  'mat4x4<f32>': {type: 'f32', components: 16},
+
+  'mat2x2<f16>': {type: 'f16', components: 4},
+  'mat2x3<f16>': {type: 'f16', components: 6},
+  'mat2x4<f16>': {type: 'f16', components: 8},
+  'mat3x2<f16>': {type: 'f16', components: 6},
+  'mat3x3<f16>': {type: 'f16', components: 9},
+  'mat3x4<f16>': {type: 'f16', components: 12},
+  'mat4x2<f16>': {type: 'f16', components: 8},
+  'mat4x3<f16>': {type: 'f16', components: 12},
+  'mat4x4<f16>': {type: 'f16', components: 16},
+
+  'mat2x2<i32>': {type: 'i32', components: 4},
+  'mat2x3<i32>': {type: 'i32', components: 6},
+  'mat2x4<i32>': {type: 'i32', components: 8},
+  'mat3x2<i32>': {type: 'i32', components: 6},
+  'mat3x3<i32>': {type: 'i32', components: 9},
+  'mat3x4<i32>': {type: 'i32', components: 12},
+  'mat4x2<i32>': {type: 'i32', components: 8},
+  'mat4x3<i32>': {type: 'i32', components: 12},
+  'mat4x4<i32>': {type: 'i32', components: 16},
+
+  'mat2x2<u32>': {type: 'u32', components: 4},
+  'mat2x3<u32>': {type: 'u32', components: 6},
+  'mat2x4<u32>': {type: 'u32', components: 8},
+  'mat3x2<u32>': {type: 'u32', components: 6},
+  'mat3x3<u32>': {type: 'u32', components: 9},
+  'mat3x4<u32>': {type: 'u32', components: 12},
+  'mat4x2<u32>': {type: 'u32', components: 8},
+  'mat4x3<u32>': {type: 'u32', components: 12},
+  'mat4x4<u32>': {type: 'u32', components: 16}
+};
+
+/**  Predeclared aliases @see https://www.w3.org/TR/WGSL/#vector-types */
+export const WGSL_ATTRIBUTE_TYPE_ALIAS_MAP: Record<AttributeShaderTypeAlias, AttributeShaderType> =
+  {
+    vec2i: 'vec2<i32>',
+    vec3i: 'vec3<i32>',
+    vec4i: 'vec4<i32>',
+    vec2u: 'vec2<u32>',
+    vec3u: 'vec3<u32>',
+    vec4u: 'vec4<u32>',
+    vec2f: 'vec2<f32>',
+    vec3f: 'vec3<f32>',
+    vec4f: 'vec4<f32>',
+    // Requires the f16 extension.
+    vec2h: 'vec2<f16>',
+    vec3h: 'vec3<f16>',
+    vec4h: 'vec4<f16>'
+  };
+
+/** @todo These tables are quite big, consider parsing alias strings instead */
+export const WGSL_VARIABLE_TYPE_ALIAS_MAP: Record<VariableShaderTypeAlias, VariableShaderType> = {
+  vec2i: 'vec2<i32>',
+  vec3i: 'vec3<i32>',
+  vec4i: 'vec4<i32>',
+  vec2u: 'vec2<u32>',
+  vec3u: 'vec3<u32>',
+  vec4u: 'vec4<u32>',
+  vec2f: 'vec2<f32>',
+  vec3f: 'vec3<f32>',
+  vec4f: 'vec4<f32>',
+  vec2h: 'vec2<f16>',
+  vec3h: 'vec3<f16>',
+  vec4h: 'vec4<f16>',
+  mat2x2f: 'mat2x2<f32>',
+  mat2x3f: 'mat2x3<f32>',
+  mat2x4f: 'mat2x4<f32>',
+  mat3x2f: 'mat3x2<f32>',
+  mat3x3f: 'mat3x3<f32>',
+  mat3x4f: 'mat3x4<f32>',
+  mat4x2f: 'mat4x2<f32>',
+  mat4x3f: 'mat4x3<f32>',
+  mat4x4f: 'mat4x4<f32>',
+
+  mat2x2i: 'mat2x2<i32>',
+  mat2x3i: 'mat2x3<i32>',
+  mat2x4i: 'mat2x4<i32>',
+  mat3x2i: 'mat3x2<i32>',
+  mat3x3i: 'mat3x3<i32>',
+  mat3x4i: 'mat3x4<i32>',
+  mat4x2i: 'mat4x2<i32>',
+  mat4x3i: 'mat4x3<i32>',
+  mat4x4i: 'mat4x4<i32>',
+
+  mat2x2u: 'mat2x2<u32>',
+  mat2x3u: 'mat2x3<u32>',
+  mat2x4u: 'mat2x4<u32>',
+  mat3x2u: 'mat3x2<u32>',
+  mat3x3u: 'mat3x3<u32>',
+  mat3x4u: 'mat3x4<u32>',
+  mat4x2u: 'mat4x2<u32>',
+  mat4x3u: 'mat4x3<u32>',
+  mat4x4u: 'mat4x4<u32>',
+
+  mat2x2h: 'mat2x2<f16>',
+  mat2x3h: 'mat2x3<f16>',
+  mat2x4h: 'mat2x4<f16>',
+  mat3x2h: 'mat3x2<f16>',
+  mat3x3h: 'mat3x3<f16>',
+  mat3x4h: 'mat3x4<f16>',
+  mat4x2h: 'mat4x2<f16>',
+  mat4x3h: 'mat4x3<f16>',
+  mat4x4h: 'mat4x4<f16>'
+};

package/src/types/shader-types.ts

@@ -0,0 +1,207 @@
+// luma.gl
+// SPDX-License-Identifier: MIT
+// SPDX-FileCopyrightText: Copyright (c) vis.gl contributors
+
+import type {PrimitiveDataType} from './primitive-data-types';
+
+/**
+ * @type the type of an attribute as defined in the shader source code.
+ * @note This is a subset of shader variable types
+ * @note Buffers with various `VertexFormat`s can be supplied for each type, GPU will convert them at runtime/
+ */
+export type AttributeShaderType =
+  | 'i32'
+  | 'u32'
+  | 'f32'
+  | 'f16'
+  | `vec2<${PrimitiveDataType}>`
+  | `vec3<${PrimitiveDataType}>`
+  | `vec4<${PrimitiveDataType}>`;
+
+/**
+ * @type Describes the type of a variable that can declared in shader source code.
+ * @note Uniforms can be declared using these types
+ * @note Uniforms can be of a wider range of types than attributes.
+ * @note to WebGL users: "bindings" (textures, samplers, and uniform buffers) are considered "bindings", not shader variables/uniforms
+ */
+export type VariableShaderType =
+  | 'i32'
+  | 'u32'
+  | 'f32'
+  | 'f16'
+  | `vec2<${PrimitiveDataType}>`
+  | `vec3<${PrimitiveDataType}>`
+  | `vec4<${PrimitiveDataType}>`
+  | `mat2x2<${PrimitiveDataType}>`
+  | `mat2x3<${PrimitiveDataType}>`
+  | `mat2x4<${PrimitiveDataType}>`
+  | `mat3x2<${PrimitiveDataType}>`
+  | `mat3x3<${PrimitiveDataType}>`
+  | `mat3x4<${PrimitiveDataType}>`
+  | `mat4x2<${PrimitiveDataType}>`
+  | `mat4x3<${PrimitiveDataType}>`
+  | `mat4x4<${PrimitiveDataType}>`;
+
+/** @type A composite shader type can include structs and arrays, recursively */
+export type CompositeShaderType = VariableShaderType | StructShaderType | ArrayShaderType;
+
+/** @type Represents a struct in WGSL */
+export type StructShaderType = {
+  [memberName: string]: CompositeShaderType;
+};
+
+/** @type Represents an array in WGSL */
+export type ArrayShaderType = readonly [type: CompositeShaderType, length: number];
+
+// Alias types
+
+/** @type Shorthand type aliases recognized by WGSL */
+export type AttributeShaderTypeAlias = keyof AttributeShaderTypeAliasMap;
+
+/** @note work around for lack of type narrowing in conditional generics */
+// biome-ignore format: preserve layout
+type AttributeShaderTypeAliasMap = {
+  vec2f: 'vec2<f32>';
+  vec3f: 'vec3<f32>';
+  vec4f: 'vec4<f32>';
+  vec2i: 'vec2<i32>';
+  vec3i: 'vec3<i32>';
+  vec4i: 'vec4<i32>';
+  vec2u: 'vec2<u32>';
+  vec3u: 'vec3<u32>';
+  vec4u: 'vec4<u32>';
+  vec2h: 'vec2<f16>';
+  vec3h: 'vec3<f16>';
+  vec4h: 'vec4<f16>';
+};
+
+/** @type Shorthand type aliases recognized by WGSL */
+export type VariableShaderTypeAlias = keyof VariableShaderTypeAliasMap;
+
+/** @note work around for lack of type narrowing in conditional generics */
+// biome-ignore format: preserve layout
+type VariableShaderTypeAliasMap = {
+  // Vector aliases
+  vec2f: 'vec2<f32>';
+  vec3f: 'vec3<f32>';
+  vec4f: 'vec4<f32>';
+  vec2i: 'vec2<i32>';
+  vec3i: 'vec3<i32>';
+  vec4i: 'vec4<i32>';
+  vec2u: 'vec2<u32>';
+  vec3u: 'vec3<u32>';
+  vec4u: 'vec4<u32>';
+  vec2h: 'vec2<f16>';
+  vec3h: 'vec3<f16>';
+  vec4h: 'vec4<f16>';
+
+  // Matrix aliases
+  mat2x2f: 'mat2x2<f32>';
+  mat2x3f: 'mat2x3<f32>';
+  mat2x4f: 'mat2x4<f32>';
+  mat3x2f: 'mat3x2<f32>';
+  mat3x3f: 'mat3x3<f32>';
+  mat3x4f: 'mat3x4<f32>';
+  mat4x2f: 'mat4x2<f32>';
+  mat4x3f: 'mat4x3<f32>';
+  mat4x4f: 'mat4x4<f32>';
+
+  mat2x2i: 'mat2x2<i32>';
+  mat2x3i: 'mat2x3<i32>';
+  mat2x4i: 'mat2x4<i32>';
+  mat3x2i: 'mat3x2<i32>';
+  mat3x3i: 'mat3x3<i32>';
+  mat3x4i: 'mat3x4<i32>';
+  mat4x2i: 'mat4x2<i32>';
+  mat4x3i: 'mat4x3<i32>';
+  mat4x4i: 'mat4x4<i32>';
+
+  mat2x2u: 'mat2x2<u32>';
+  mat2x3u: 'mat2x3<u32>';
+  mat2x4u: 'mat2x4<u32>';
+  mat3x2u: 'mat3x2<u32>';
+  mat3x3u: 'mat3x3<u32>';
+  mat3x4u: 'mat3x4<u32>';
+  mat4x2u: 'mat4x2<u32>';
+  mat4x3u: 'mat4x3<u32>';
+  mat4x4u: 'mat4x4<u32>';
+
+  mat2x2h: 'mat2x2<f16>';
+  mat2x3h: 'mat2x3<f16>';
+  mat2x4h: 'mat2x4<f16>';
+  mat3x2h: 'mat3x2<f16>';
+  mat3x3h: 'mat3x3<f16>';
+  mat3x4h: 'mat3x4<f16>';
+  mat4x2h: 'mat4x2<f16>';
+  mat4x3h: 'mat4x3<f16>';
+  mat4x4h: 'mat4x4<f16>';
+};
+
+// GENERICS
+
+/** @type The unaliased type */
+export type AttributeShaderTypeT<T extends AttributeShaderTypeAlias | AttributeShaderType> =
+  T extends AttributeShaderTypeAlias ? AttributeShaderTypeAliasMap[T] : T;
+
+/** @type The unaliased type */
+export type VariableShaderTypeT<T extends VariableShaderType | keyof VariableShaderTypeAliasMap> =
+  T extends VariableShaderTypeAlias ? VariableShaderTypeAliasMap[T] : T;
+
+// HELPER TYPES
+
+// biome-ignore format: preserve layout
+type TypeOfAliasSuffix<T extends string> =
+  T extends 'f' ? 'f32' :
+  T extends 'i' ? 'i32' :
+  T extends 'u' ? 'u32' :
+  T extends 'h' ? 'f16' :
+  never;
+
+// biome-ignore format: preserve layout
+export type AttributeShaderTypeAliasT<T extends AttributeShaderTypeAlias> =
+  T extends `vec2${infer S}` ? `vec2<${TypeOfAliasSuffix<S>}>` :
+  T extends `vec3${infer S}` ? `vec3<${TypeOfAliasSuffix<S>}>` :
+  T extends `vec4${infer S}` ? `vec4<${TypeOfAliasSuffix<S>}>` :
+  never;
+
+// biome-ignore format: preserve layout
+export type VariableShaderTypeAliasT<T extends VariableShaderTypeAlias> =
+  T extends `vec2${infer S}` ? `vec2<${TypeOfAliasSuffix<S>}>` :
+  T extends `vec3${infer S}` ? `vec3<${TypeOfAliasSuffix<S>}>` :
+  T extends `vec4${infer S}` ? `vec4<${TypeOfAliasSuffix<S>}>` :
+  T extends `mat2x2${infer S}` ? `mat2x2<${TypeOfAliasSuffix<S>}>` :
+  T extends `mat2x3${infer S}` ? `mat2x3<${TypeOfAliasSuffix<S>}>` :
+  T extends `mat2x4${infer S}` ? `mat2x4<${TypeOfAliasSuffix<S>}>` :
+  T extends `mat3x2${infer S}` ? `mat3x2<${TypeOfAliasSuffix<S>}>` :
+  T extends `mat3x3${infer S}` ? `mat3x3<${TypeOfAliasSuffix<S>}>` :
+  T extends `mat3x4${infer S}` ? `mat3x4<${TypeOfAliasSuffix<S>}>` :
+  T extends `mat4x2${infer S}` ? `mat4x2<${TypeOfAliasSuffix<S>}>` :
+  T extends `mat4x3${infer S}` ? `mat4x3<${TypeOfAliasSuffix<S>}>` :
+  T extends `mat4x4${infer S}` ? `mat4x4<${TypeOfAliasSuffix<S>}>` :
+  never;
+
+// : T extends `vec2<${infer S}>`
+//   ? `vec2<${S}>`
+//   : T extends `vec3<${infer S}>`
+//     ? `vec3<${S}>`
+//     : T extends `vec4<${infer S}>`
+//       ? `vec4<${S}>`
+//       : T extends `mat2x2<${infer S}>`
+//         ? `mat2x2<${S}>`
+//         : T extends `mat2x3<${infer S}>`
+//           ? `mat2x3<${S}>`
+//           : T extends `mat2x4<${infer S}>`
+//             ? `mat2x4<${S}>`
+//             : T extends `mat3x2<${infer S}>`
+//               ? `mat3x2<${S}>`
+//               : T extends `mat3x3<${infer S}>`
+//                 ? `mat3x3<${S}>`
+//                 : T extends `mat3x4<${infer S}>`
+//                   ? `mat3x4<${S}>`
+//                   : T extends `mat4x2<${infer S}>`
+//                     ? `mat4x2<${S}>`
+//                     : T extends `mat4x3<${infer S}>`
+//                       ? `mat4x3<${S}>`
+//                       : T extends `mat4x4<${infer S}>`
+//                         ? `mat4x4<${S}>`
+//                         : never;

package/src/types/texture-formats.ts

@@ -0,0 +1,155 @@
+// luma.gl
+// SPDX-License-Identifier: MIT
+// SPDX-FileCopyrightText: Copyright (c) vis.gl contributors
+
+// 'r16snorm', 'rg16snorm', 'rgba16snorm'
+
+// TEXTURE FORMATS
+
+/** Texture formats */
+export type TextureFormat = TextureFormatColor | TextureFormatDepthStencil;
+
+/** Depth and stencil texture formats */
+export type TextureFormatDepthStencil =
+  | 'stencil8'
+  | 'depth16unorm'
+  | 'depth24plus'
+  | 'depth24plus-stencil8'
+  | 'depth32float'
+  // device.features.has('depth32float-stencil8')
+  | 'depth32float-stencil8';
+
+/** Texture formats for color attachments */
+export type TextureFormatColor = TextureFormatColorUncompressed | TextureFormatCompressed;
+
+export type TextureFormatColorUncompressed =
+  | TextureFormatUnorm8
+  | TextureFormatSnorm8
+  | TextureFormatUint8
+  | TextureFormatSint8
+  | TextureFormatUnorm16
+  | TextureFormatSnorm16
+  | TextureFormatUint16
+  | TextureFormatSint16
+  | TextureFormatFloat16
+  | TextureFormatUint32
+  | TextureFormatSint32
+  | TextureFormatFloat32
+  | TextureFormatPacked16
+  | TextureFormatPacked32;
+
+export type TextureFormatUnorm8 =
+  | 'r8unorm'
+  | 'rg8unorm'
+  | 'rgb8unorm-webgl'
+  | 'rgba8unorm'
+  | 'rgba8unorm-srgb'
+  | 'bgra8unorm'
+  | 'bgra8unorm-srgb';
+
+export type TextureFormatSnorm8 = 'r8snorm' | 'rg8snorm' | 'rgb8snorm-webgl' | 'rgba8snorm';
+
+export type TextureFormatUint8 = 'r8uint' | 'rg8uint' | 'rgba8uint';
+
+export type TextureFormatSint8 = 'r8sint' | 'rg8sint' | 'rgba8sint';
+
+export type TextureFormatUnorm16 = 'r16unorm' | 'rg16unorm' | 'rgb16unorm-webgl' | 'rgba16unorm';
+
+export type TextureFormatSnorm16 = 'r16snorm' | 'rg16snorm' | 'rgb16snorm-webgl' | 'rgba16snorm';
+
+export type TextureFormatUint16 = 'r16uint' | 'rg16uint' | 'rgba16uint';
+
+export type TextureFormatSint16 = 'r16sint' | 'rg16sint' | 'rgba16sint';
+
+export type TextureFormatFloat16 = 'r16float' | 'rg16float' | 'rgba16float';
+
+// 96-bit formats (deprecated!)
+export type TextureFormatUint32 = 'r32uint' | 'rg32uint' | 'rgba32uint';
+
+export type TextureFormatSint32 = 'r32sint' | 'rg32sint' | 'rgba32sint';
+
+export type TextureFormatFloat32 = 'r32float' | 'rg32float' | 'rgb32float-webgl' | 'rgba32float';
+
+export type TextureFormatPacked16 = 'rgba4unorm-webgl' | 'rgb565unorm-webgl' | 'rgb5a1unorm-webgl';
+
+export 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-rgb2unorm-webgl'
+  | 'pvrtc-rgba2unorm-webgl'
+  | 'etc1-rbg-unorm-webgl'
+  | 'atc-rgb-unorm-webgl'
+  | 'atc-rgba-unorm-webgl'
+  | 'atc-rgbai-unorm-webgl'
+
+  // BC compressed formats usable if 'texture-compression-bc' is both
+  // supported by the device/user agent and enabled in requestDevice.
+  | 'bc1-rgba-unorm'
+  | 'bc1-rgba-unorm-srgb'
+  | 'bc2-rgba-unorm'
+  | 'bc2-rgba-unorm-srgb'
+  | 'bc3-rgba-unorm'
+  | 'bc3-rgba-unorm-srgb'
+  | 'bc4-r-unorm'
+  | 'bc4-r-snorm'
+  | 'bc5-rg-unorm'
+  | 'bc5-rg-snorm'
+  | 'bc6h-rgb-ufloat'
+  | 'bc6h-rgb-float'
+  | 'bc7-rgba-unorm'
+  | 'bc7-rgba-unorm-srgb'
+
+  // ETC2 compressed formats usable if "texture-compression-etc2" is both
+  // supported by the device/user agent and enabled in requestDevice.
+  | 'etc2-rgb8unorm'
+  | 'etc2-rgb8unorm-srgb'
+  | 'etc2-rgb8a1unorm'
+  | 'etc2-rgb8a1unorm-srgb'
+  | 'etc2-rgba8unorm'
+  | 'etc2-rgba8unorm-srgb'
+  | 'eac-r11unorm'
+  | 'eac-r11snorm'
+  | 'eac-rg11unorm'
+  | 'eac-rg11snorm'
+
+  // ASTC compressed formats usable if "texture-compression-astc" is both
+  // supported by the device/user agent and enabled in requestDevice.
+  // Textures must be multiple of block size (encoded in format string).
+  | 'astc-4x4-unorm'
+  | 'astc-4x4-unorm-srgb'
+  | 'astc-5x4-unorm'
+  | 'astc-5x4-unorm-srgb'
+  | 'astc-5x5-unorm'
+  | 'astc-5x5-unorm-srgb'
+  | 'astc-6x5-unorm'
+  | 'astc-6x5-unorm-srgb'
+  | 'astc-6x6-unorm'
+  | 'astc-6x6-unorm-srgb'
+  | 'astc-8x5-unorm'
+  | 'astc-8x5-unorm-srgb'
+  | 'astc-8x6-unorm'
+  | 'astc-8x6-unorm-srgb'
+  | 'astc-8x8-unorm'
+  | 'astc-8x8-unorm-srgb'
+  | 'astc-10x5-unorm'
+  | 'astc-10x5-unorm-srgb'
+  | 'astc-10x6-unorm'
+  | 'astc-10x6-unorm-srgb'
+  | 'astc-10x8-unorm'
+  | 'astc-10x8-unorm-srgb'
+  | 'astc-10x10-unorm'
+  | 'astc-10x10-unorm-srgb'
+  | 'astc-12x10-unorm'
+  | 'astc-12x10-unorm-srgb'
+  | 'astc-12x12-unorm'
+  | 'astc-12x12-unorm-srgb';
+
+export type CompressedTextureFormat = TextureFormatCompressed;

package/src/types.ts

@@ -0,0 +1,48 @@
+// luma.gl
+// SPDX-License-Identifier: MIT
+// SPDX-FileCopyrightText: Copyright (c) vis.gl contributors
+
+// MATH TYPES
+export type {TypedArray, NumberArray, NumericArray} from '@math.gl/core';
+
+// export type BigIntOrNumberArray = NumberArray | BigIntTypedArray;
+
+// UNIFORM TYPES
+// These are "duplicated" from core module to avoid cross-dependencies
+
+export type UniformDataType = 'uint32' | 'sint32' | 'float32';
+
+export type UniformFormat =
+  | 'f32'
+  | 'i32'
+  | 'u32'
+  | 'vec2<f32>'
+  | 'vec3<f32>'
+  | 'vec4<f32>'
+  | 'vec2<i32>'
+  | 'vec3<i32>'
+  | 'vec4<i32>'
+  | 'vec2<u32>'
+  | 'vec3<u32>'
+  | 'vec4<u32>'
+  | 'mat2x2<f32>'
+  | 'mat2x3<f32>'
+  | 'mat2x4<f32>'
+  | 'mat3x2<f32>'
+  | 'mat3x3<f32>'
+  | 'mat3x4<f32>'
+  | 'mat4x2<f32>'
+  | 'mat4x3<f32>'
+  | 'mat4x4<f32>';
+
+export * from './types/primitive-data-types';
+export * from './types/shader-types';
+export * from './types/shader-type-decoder';
+export * from './types/shader-block-layout';
+export * from './types/shader-layout';
+export * from './types/texture-formats';
+export * from './types/sampler-props';
+export {alignTo} from './types/align-to';
+
+/** Resource values remain opaque until an execution adapter binds them. */
+export type ShaderBinding = unknown;