@luma.gl/core 9.3.0-alpha.6 → 9.3.0-alpha.9

package/src/shadertypes/data-types/data-types.ts

@@ -13,7 +13,7 @@ export type PrimitiveDataType = 'u32' | 'i32' | 'f32' | 'f16';
  * Signed data types describe signed and unsigned integers as well as floats of varying sizes
  * @note These formats describe physical memory layouts in vertex and pixel formats, they are not used inside shaders
  */
-export type SignedDataType =
+export type DataType =
   | 'uint8'
   | 'sint8'
   | 'uint16'
@@ -23,6 +23,8 @@ export type SignedDataType =
   | 'float16'
   | 'float32';
 
+export type SignedDataType = DataType;
+
 /**
  * Normalized data types describe signed and unsigned integers as well as floats of varying sizes together with normalization behavior
  * @note These formats describe physical memory layouts in vertex and pixel formats, they are not used inside shaders
@@ -32,65 +34,115 @@ export type SignedDataType =
 export type NormalizedDataType = SignedDataType | 'unorm8' | 'snorm8' | 'unorm16' | 'snorm16';
 
 /** Returns information about a signed or normalized DataType */
-export type DataTypeInfo = {
-  signedType: SignedDataType;
-  primitiveType: PrimitiveDataType;
-  byteLength: 1 | 2 | 4;
-  normalized: boolean;
-  integer: boolean;
-  signed: boolean;
+export type DataTypeInfo<T extends NormalizedDataType = NormalizedDataType> = {
+  /** The corresponding data type without normalization */
+  signedType: SignedDataTypeT<T>;
+  /** The primitive data type (what the shader sees) */
+  primitiveType: PrimitiveDataTypeT<T>;
+  /** @type number - Length in bytes of the data type */
+  byteLength: DataTypeByteLengthT<T>;
+  /** @type boolean - indicating whether the data type is normalized */
+  normalized: DataTypeIsNormalizedT<T>;
+  /** @type boolean - indicating whether the data type is integer */
+  integer: DataTypeIsIntegerT<T>;
+  /** @type boolean - indicating whether the data type is signed */
+  signed: DataTypeIsSignedT<T>;
 };
 
-/** Returns a typed array appropriate to hold the actual values of a data type (integers for normalized integers) */
-export type DataTypeArray<T extends NormalizedDataType> = T extends 'uint8'
-  ? Uint8Array
-  : T extends 'sint8'
-    ? Int8Array
-    : T extends 'unorm8'
-      ? Uint8Array
-      : T extends 'snorm8'
-        ? Int8Array
-        : T extends 'uint16'
-          ? Uint16Array
-          : T extends 'sint16'
-            ? Int16Array
-            : T extends 'unorm16'
-              ? Uint16Array
-              : T extends 'snorm16'
-                ? Int16Array
-                : T extends 'uint32'
-                  ? Uint32Array
-                  : T extends 'sint32'
-                    ? Int32Array
-                    : T extends 'float16'
-                      ? Uint16Array
-                      : T extends 'float32'
-                        ? Float32Array
-                        : never;
+/** @type the primitive data type seen by the shader */
+export type PrimitiveDataTypeT<T extends NormalizedDataType> = T extends 'float32'
+  ? 'f32'
+  : T extends 'float16'
+    ? 'f16'
+    : T extends 'unorm8' | 'snorm8' | 'unorm16' | 'snorm16'
+      ? 'f32'
+      : T extends 'uint8' | 'uint16' | 'uint32'
+        ? 'u32'
+        : T extends 'sint8' | 'sint16' | 'sint32'
+          ? 'i32'
+          : never;
+
+/** @type The signed data type representing a normalized data type */
+export type SignedDataTypeT<T extends NormalizedDataType> = T extends 'unorm8'
+  ? 'uint8'
+  : T extends 'snorm8'
+    ? 'sint8'
+    : T extends 'unorm16'
+      ? 'uint16'
+      : T extends 'snorm16'
+        ? 'sint16'
+        : T extends NormalizedDataType
+          ? T
+          : never;
+
+/** @type a number type that is is the length in bytes of the data type */
+export type DataTypeByteLengthT<T extends NormalizedDataType = NormalizedDataType> = T extends
+  | 'uint8'
+  | 'sint8'
+  | 'unorm8'
+  | 'snorm8'
+  ? 1
+  : T extends 'uint16' | 'sint16' | 'unorm16' | 'snorm16' | 'float16'
+    ? 2
+    : T extends 'uint32' | 'sint32' | 'float32'
+      ? 4
+      : never;
+
+/** @type a boolean type that is true if the data format is signed */
+export type DataTypeIsSignedT<T extends NormalizedDataType = NormalizedDataType> = T extends
+  | 'sint8'
+  | 'sint16'
+  | 'sint32'
+  ? true
+  : false;
 
-/** Returns a type array appropriate to hold the logical values of a data type (floats for normalized integers) */
-export type NormalizedDataTypeArray<T extends NormalizedDataType> = T extends 'uint8'
-  ? Uint8Array
+/** @type a boolean type that is true if the data format is a normalized format */
+export type DataTypeIsNormalizedT<T extends NormalizedDataType = NormalizedDataType> =
+  T extends SignedDataType ? false : true;
+
+/** @type a boolean type that is true if the data format is an integer format */
+export type DataTypeIsIntegerT<T extends NormalizedDataType = NormalizedDataType> = T extends
+  | 'uint8'
+  | 'sint8'
+  | 'uint16'
+  | 'sint16'
+  | 'uint32'
+  | 'sint32'
+  ? true
+  : false;
+
+/** @type A typed array constructor type appropriate to hold the actual values of a data type (i.e. integers for normalized data types) */
+export type TypedArrayConstructorT<T extends NormalizedDataType> = T extends 'uint8'
+  ? Uint8ArrayConstructor
   : T extends 'sint8'
-    ? Int8Array
+    ? Int8ArrayConstructor
     : T extends 'unorm8'
-      ? Float32Array
+      ? Uint8ArrayConstructor
       : T extends 'snorm8'
-        ? Float32Array
+        ? Int8ArrayConstructor
         : T extends 'uint16'
-          ? Uint16Array
+          ? Uint16ArrayConstructor
           : T extends 'sint16'
-            ? Int16Array
+            ? Int16ArrayConstructor
             : T extends 'unorm16'
-              ? Uint16Array
+              ? Uint16ArrayConstructor
               : T extends 'snorm16'
-                ? Int16Array
+                ? Int16ArrayConstructor
                 : T extends 'uint32'
-                  ? Uint32Array
+                  ? Uint32ArrayConstructor
                   : T extends 'sint32'
-                    ? Int32Array
+                    ? Int32ArrayConstructor
                     : T extends 'float16'
-                      ? Float32Array
+                      ? Uint16ArrayConstructor
                       : T extends 'float32'
-                        ? Float32Array
+                        ? Float32ArrayConstructor
                         : never;
+
+/** @type A typed array constructor appropriate to hold the logical values of a data type (i.e. floats for normalized data types) */
+export type NormalizedTypedArrayConstructorT<T extends NormalizedDataType> = T extends
+  | 'unorm8'
+  | 'snorm8'
+  | 'unorm16'
+  | 'snorm16'
+  ? Float32ArrayConstructor
+  : TypedArrayConstructorT<T>;

package/src/{image-utils → shadertypes/image-types}/image-types.ts

@@ -15,13 +15,6 @@ export type ExternalImage =
   | HTMLCanvasElement
   | OffscreenCanvas;
 
-export type ExternalImageData = {
-  data: ArrayBuffer | SharedArrayBuffer | ArrayBufferView;
-  byteOffset?: number;
-  bytesPerRow?: number;
-  rowsPerImage?: number;
-};
-
 /** Check if data is an external image */
 export function isExternalImage(data: unknown): data is ExternalImage {
   return (

package/src/shadertypes/{data-types/decode-shader-types.ts → shader-types/shader-type-decoder.ts}

@@ -2,20 +2,38 @@
 // SPDX-License-Identifier: MIT
 // Copyright (c) vis.gl contributors
 
-import {PrimitiveDataType} from './data-types';
-import type {
-  VariableShaderType,
-  AttributeShaderType,
-  AttributeShaderTypeInfo,
-  VariableShaderTypeAlias,
-  AttributeShaderTypeAlias
+import {type PrimitiveDataType} from '../data-types/data-types';
+import {
+  type VariableShaderType,
+  type AttributeShaderType,
+  type VariableShaderTypeAlias,
+  type AttributeShaderTypeAlias
 } from './shader-types';
 
-/** Split a uniform type string into type and components */
-export function getVariableShaderTypeInfo(format: VariableShaderType | VariableShaderTypeAlias): {
+/** 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) {
@@ -47,6 +65,39 @@ export function getAttributeShaderTypeInfo(
   };
 }
 
+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
@@ -66,6 +117,9 @@ export function resolveVariableShaderTypeAlias(
   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> = {
@@ -177,7 +231,18 @@ export const WGSL_ATTRIBUTE_TYPE_ALIAS_MAP: Record<AttributeShaderTypeAlias, Att
 
 /** @todo These tables are quite big, consider parsing alias strings instead */
 export const WGSL_VARIABLE_TYPE_ALIAS_MAP: Record<VariableShaderTypeAlias, VariableShaderType> = {
-  ...WGSL_ATTRIBUTE_TYPE_ALIAS_MAP,
+  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>',

package/src/shadertypes/shader-types/shader-types.ts

@@ -0,0 +1,207 @@
+// luma.gl
+// SPDX-License-Identifier: MIT
+// Copyright (c) vis.gl contributors
+
+import type {PrimitiveDataType} from '../data-types/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 */
+// prettier-ignore
+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 */
+// prettier-ignore
+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
+
+// prettier-ignore
+type TypeOfAliasSuffix<T extends string> =
+  T extends 'f' ? 'f32' :
+  T extends 'i' ? 'i32' :
+  T extends 'u' ? 'u32' :
+  T extends 'h' ? 'f16' :
+  never;
+
+// prettier-ignore
+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;
+
+// prettier-ignore
+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/shadertypes/{textures → texture-types}/texture-format-decoder.ts

@@ -3,7 +3,7 @@
 // Copyright (c) vis.gl contributors
 
 import type {NormalizedDataType} from '../data-types/data-types';
-import {getDataTypeInfo} from '../data-types/decode-data-types';
+import {dataTypeDecoder} from '../data-types/data-type-decoder';
 import type {
   TextureFormat,
   TextureFormatCompressed,
@@ -72,6 +72,7 @@ export class TextureFormatDecoder {
   }
 }
 
+/** Decoder for luma.gl texture types */
 export const textureFormatDecoder = new TextureFormatDecoder();
 
 // HELPERS - MEMORY LAYOUT
@@ -163,11 +164,11 @@ export function getTextureFormatInfo(format: TextureFormat): TextureFormatInfo {
   }
 
   // Fill in missing information that can be derived from the format string
-  const matches = RGB_FORMAT_REGEX.exec(format as string);
+  const matches = !formatInfo.packed ? RGB_FORMAT_REGEX.exec(format as string) : null;
   if (matches) {
     const [, channels, length, type, srgb, suffix] = matches;
     const dataType = `${type}${length}` as NormalizedDataType;
-    const decodedType = getDataTypeInfo(dataType);
+    const decodedType = dataTypeDecoder.getDataTypeInfo(dataType);
     const bits = decodedType.byteLength * 8;
     const components = (channels?.length ?? 1) as 1 | 2 | 3 | 4;
     const bitsPerChannel: [number, number, number, number] = [

package/src/shadertypes/{textures → texture-types}/texture-format-generics.ts

@@ -8,54 +8,8 @@ import {
   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
+/** @type data type for a texture format */
+export type TextureFormatDataTypeT<T extends TextureFormat> = T extends TextureFormatUint8
   ? 'uint8'
   : T extends TextureFormatSint8
     ? 'sint8'
@@ -89,6 +43,46 @@ export type TextureFormatDataType<T extends TextureFormat> = T extends TextureFo
                                 ? 'uint32'
                                 : never;
 
+/** @type A numeric array of length matching the number of components in the texture format */
+export type TextureFormatPixelT<T extends TextureFormat> =
+  TextureFormatPackedComponentsT<T> extends 1
+    ? [number]
+    : TextureFormatPackedComponentsT<T> extends 2
+      ? [number, number]
+      : TextureFormatPackedComponentsT<T> extends 3
+        ? [number, number, number]
+        : TextureFormatPackedComponentsT<T> extends 4
+          ? [number, number, number, number]
+          : never;
+
+/**
+ * @type number - the number of components in a texture format
+ * @note packed formats have only one component. Use TextureFormatPackedComponentsT
+ */
+export type TextureFormatComponentsT<T extends TextureFormat> = T extends
+  | TextureFormatR
+  | TextureFormatPackedRGB
+  | TextureFormatPackedRGBA
+  ? 1
+  : T extends TextureFormatRG
+    ? 2
+    : T extends TextureFormatRGB
+      ? 3
+      : T extends TextureFormatRGBA
+        ? 4
+        : never;
+
+/** @type number - the number of components in a packed texture format */
+export type TextureFormatPackedComponentsT<T extends TextureFormat> = T extends TextureFormatR
+  ? 1
+  : T extends TextureFormatRG
+    ? 2
+    : T extends TextureFormatRGB | TextureFormatPackedRGB
+      ? 3
+      : T extends TextureFormatRGBA | TextureFormatPackedRGBA
+        ? 4
+        : never;
+
 // Component groups
 
 type TextureFormatR =