@luma.gl/core 9.0.17 → 9.1.0-alpha.10

package/src/adapter/types/{types.ts → attachments.ts}

@@ -2,19 +2,19 @@
 // SPDX-License-Identifier: MIT
 // Copyright (c) vis.gl contributors
 
-import type {ColorTextureFormat, DepthStencilTextureFormat, TextureFormat} from './texture-formats';
-import type {Buffer} from '../resources/buffer';
+import {NumberArray} from '../../types';
+import type {
+  ColorTextureFormat,
+  DepthStencilTextureFormat,
+  TextureFormat
+} from '../../gpu-type-utils/texture-formats';
 import type {Texture} from '../resources/texture'; // TextureView...
+import type {TextureView} from '../resources/texture-view'; // TextureView...
 
 // UNIFORMS
 
 /** Valid values for uniforms. @note boolean values get converted to 0 or 1 before setting */
-export type UniformValue = number | boolean | Readonly<number[]>;
-
-// BINDINGS
-
-/** Buffer bindings */
-export type Binding = Texture | Buffer | {buffer: Buffer; offset?: number; size?: number};
+export type UniformValue = number | boolean | Readonly<NumberArray>; // Float32Array> | Readonly<Int32Array> | Readonly<Uint32Array> | Readonly<number[]>;
 
 // BINDING LAYOUTS
 
@@ -54,14 +54,6 @@ export type BindingDeclaration =
   | TextureBindingLayout
   | StorageTextureBindingLayout;
 
-// TEXTURE VIEWS
-
-export type TextureView = {
-  texture: WebGLTexture;
-  layer?: number; //  = 0
-  level?: number; // = 0
-};
-
 // ATTACHMENTS (See Framebuffer)
 
 /**
@@ -70,7 +62,7 @@ export type TextureView = {
  */
 export type ColorAttachment = {
   /** Describes the texture subresource that will be output to for this color attachment. */
-  texture?: Texture;
+  texture?: TextureView | Texture;
   /** Format of the texture resource. Used to auto create texture if not supplied */
   format?: ColorTextureFormat;
   /* Describes the texture subresource that will receive  resolved output for this color attachment if multisampled. */
@@ -90,7 +82,7 @@ export type ColorAttachment = {
  */
 export type DepthStencilAttachment = {
   /** Describes the texture subresource that will be output to and read from for this depth/stencil attachment. */
-  texture?: Texture;
+  texture?: TextureView | Texture;
   /** Format of the texture resource. Used to auto create texture if not supplied */
   format?: DepthStencilTextureFormat;
 

package/src/adapter/types/buffer-layout.ts

@@ -2,7 +2,7 @@
 // SPDX-License-Identifier: MIT
 // Copyright (c) vis.gl contributors
 
-import type {VertexFormat} from './vertex-formats';
+import type {VertexFormat} from '../../gpu-type-utils/vertex-formats';
 
 /**
  * Provides specific details about the memory layout of the actual buffers

package/src/adapter/types/parameters.ts

@@ -2,7 +2,7 @@
 // SPDX-License-Identifier: MIT
 // Copyright (c) vis.gl contributors
 
-import {DepthStencilTextureFormat} from './texture-formats';
+import {DepthStencilTextureFormat} from '../../gpu-type-utils/texture-formats';
 
 export type CompareFunction =
   | 'never'
@@ -20,12 +20,8 @@ export type PrimitiveTopology =
   | 'point-list'
   | 'line-list'
   | 'line-strip'
-  /** @deprecated */
-  | 'line-loop-webgl'
   | 'triangle-list'
-  | 'triangle-strip'
-  /** @deprecated */
-  | 'triangle-fan-webgl';
+  | 'triangle-strip';
 
 export type IndexFormat = 'uint16' | 'uint32';
 
@@ -146,6 +142,9 @@ export type BlendOperation = 'add' | 'subtract' | 'reverse-subtract' | 'min' | '
 
 /* Color parameters are set on the RenderPipeline */
 export type ColorParameters = {
+  /** Enable blending */
+  blend?: boolean;
+
   /** Defines the operation used to calculate the values written to the target attachment components. */
   blendColorOperation?: BlendOperation;
   /** Defines the operation to be performed on values from the fragment shader. */
@@ -233,6 +232,7 @@ export const DEFAULT_PARAMETERS: Required<Parameters> = {
   sampleAlphaToCoverageEnabled: false,
 
   // Color and blend parameters
+  blend: false,
 
   blendColorOperation: 'add',
   blendColorSrcFactor: 'one',
@@ -251,12 +251,12 @@ export const DEFAULT_PARAMETERS: Required<Parameters> = {
   polygonMode: 'fill',
   polygonOffsetLine: false,
 
-  clipDistance0: undefined,
-  clipDistance1: undefined,
-  clipDistance2: undefined,
-  clipDistance3: undefined,
-  clipDistance4: undefined,
-  clipDistance5: undefined,
-  clipDistance6: undefined,
-  clipDistance7: undefined
+  clipDistance0: undefined!,
+  clipDistance1: undefined!,
+  clipDistance2: undefined!,
+  clipDistance3: undefined!,
+  clipDistance4: undefined!,
+  clipDistance5: undefined!,
+  clipDistance6: undefined!,
+  clipDistance7: undefined!
 };

package/src/adapter/types/shader-layout.ts

@@ -2,9 +2,8 @@
 // SPDX-License-Identifier: MIT
 // Copyright (c) vis.gl contributors
 
-import type {TextureFormat} from '../types/texture-formats';
-import type {ShaderUniformType, ShaderAttributeType} from './shader-types';
-import {AccessorObject} from '../types/accessor';
+import type {TextureFormat} from '../../gpu-type-utils/texture-formats';
+import type {ShaderUniformType, ShaderAttributeType} from '../../gpu-type-utils/shader-types';
 import type {Buffer} from '../resources/buffer';
 import type {Sampler} from '../resources/sampler';
 import type {Texture} from '../resources/texture';
@@ -64,32 +63,6 @@ export type AttributeDeclaration = {
 
 // BINDING LAYOUTS
 
-/*
-type Binding = {
-  binding: number;
-  visibility: number;
-
-  buffer?: {
-    type?: 'uniform' | 'storage' | 'read-only-storage';
-    hasDynamicOffset?: false;
-    minBindingSize?: number;
-  };
-
-  // type = sampler
-  samplerType?: 'filtering' | 'non-filtering' | 'comparison';
-
-  // type = texture
-  viewDimension?: '1d' | '2d' | '2d-array' | 'cube' | 'cube-array' | '3d';
-  sampleType?: 'float' | 'unfilterable-float' | 'depth' | 'sint' | 'uint';
-  multisampled?: boolean;
-
-  // type = storage
-  viewDimension?: '1d' | '2d' | '2d-array' | 'cube' | 'cube-array' | '3d';
-  access: 'read-only' | 'write-only';
-  format: string;
-};
-*/
-
 /** ShaderLayout for bindings */
 export type BindingDeclaration =
   | UniformBufferBindingLayout
@@ -205,3 +178,32 @@ export type AttributeBinding = {
   location: number;
   accessor: AccessorObject;
 };
+
+/**
+ * Attribute descriptor object
+ * @deprecated Use ShaderLayout
+ */
+export interface AccessorObject {
+  buffer?: Buffer;
+  // format: VertexFormat;
+  offset?: number;
+  // can now be described with single WebGPU-style `format` string
+
+  //
+  stride?: number;
+
+  /** @deprecated - Use accessor.stepMode */
+  divisor?: number;
+
+  /** @deprecated - Infer from format */
+  type?: number;
+  /** @deprecated - Infer from format */
+  size?: number;
+  /** @deprecated - Infer from format */
+  normalized?: boolean;
+  /** @deprecated - Infer from format */
+  integer?: boolean;
+
+  /** @deprecated */
+  index?: number;
+}

package/src/adapter/types/uniforms.ts

@@ -0,0 +1,10 @@
+// luma.gl
+// SPDX-License-Identifier: MIT
+// Copyright (c) vis.gl contributors
+
+import {NumberArray} from '../../types';
+
+// UNIFORMS
+
+/** Valid values for uniforms. @note boolean values get converted to 0 or 1 before setting */
+export type UniformValue = number | boolean | Readonly<NumberArray>; // Float32Array> | Readonly<Int32Array> | Readonly<Uint32Array> | Readonly<number[]>;

package/src/{lib/compiler-log → adapter-utils}/format-compiler-log.ts

@@ -2,7 +2,7 @@
 // SPDX-License-Identifier: MIT
 // Copyright (c) vis.gl contributors
 
-import type {CompilerMessage} from './compiler-message';
+import type {CompilerMessage} from '../adapter/types/compiler-message';
 
 /** @returns annotated errors or warnings */
 export function formatCompilerLog(

package/src/{adapter/attribute-utils → adapter-utils}/get-attribute-from-layouts.ts

@@ -2,13 +2,13 @@
 // SPDX-License-Identifier: MIT
 // Copyright (c) vis.gl contributors
 
-import {log} from '../../utils/log';
-import type {ShaderLayout, AttributeDeclaration} from '../types/shader-layout';
-import type {BufferLayout} from '../types/buffer-layout';
-import type {ShaderDataType, ShaderAttributeType} from '../types/shader-types';
-import {decodeShaderAttributeType} from '../type-utils/decode-attribute-type';
-import type {VertexFormat, VertexType} from '../types/vertex-formats';
-import {decodeVertexFormat} from '../type-utils/decode-vertex-format';
+import {log} from '../utils/log';
+import type {ShaderLayout, AttributeDeclaration} from '../adapter/types/shader-layout';
+import type {BufferLayout} from '../adapter/types/buffer-layout';
+import type {ShaderDataType, ShaderAttributeType} from '../gpu-type-utils/shader-types';
+import {decodeShaderAttributeType} from '../gpu-type-utils/decode-attribute-type';
+import type {VertexFormat, VertexType} from '../gpu-type-utils/vertex-formats';
+import {decodeVertexFormat} from '../gpu-type-utils/decode-vertex-format';
 
 /** Resolved info for a buffer / attribute combination to help backend configure it correctly */
 export type AttributeInfo = {
@@ -64,11 +64,10 @@ export function getAttributeInfosFromLayouts(
 ): Record<string, AttributeInfo> {
   const attributeInfos: Record<string, AttributeInfo> = {};
   for (const attribute of shaderLayout.attributes) {
-    attributeInfos[attribute.name] = getAttributeInfoFromLayouts(
-      shaderLayout,
-      bufferLayout,
-      attribute.name
-    );
+    const attributeInfo = getAttributeInfoFromLayouts(shaderLayout, bufferLayout, attribute.name);
+    if (attributeInfo) {
+      attributeInfos[attribute.name] = attributeInfo;
+    }
   }
   return attributeInfos;
 }
@@ -98,7 +97,10 @@ function getAttributeInfoFromLayouts(
   name: string
 ): AttributeInfo | null {
   const shaderDeclaration = getAttributeFromShaderLayout(shaderLayout, name);
-  const bufferMapping: BufferAttributeInfo = getAttributeFromBufferLayout(bufferLayout, name);
+  const bufferMapping: BufferAttributeInfo | null = getAttributeFromBufferLayout(
+    bufferLayout,
+    name
+  );
 
   // TODO should no longer happen
   if (!shaderDeclaration) {
@@ -124,7 +126,7 @@ function getAttributeInfoFromLayouts(
     normalized: vertexFormatInfo.normalized,
     // integer is a property of the shader declaration
     integer: attributeTypeInfo.integer,
-    stepMode: bufferMapping?.stepMode || shaderDeclaration.stepMode,
+    stepMode: bufferMapping?.stepMode || shaderDeclaration.stepMode || 'vertex',
     byteOffset: bufferMapping?.byteOffset || 0,
     byteStride: bufferMapping?.byteStride || 0
   };
@@ -211,6 +213,7 @@ function getAttributeFromAttributesList(
     if (typeof bufferLayout.byteStride !== 'number') {
       for (const attributeMapping of bufferLayout.attributes || []) {
         const info = decodeVertexFormat(attributeMapping.format);
+        // @ts-ignore
         byteStride += info.byteLength;
       }
     }
@@ -223,6 +226,7 @@ function getAttributeFromAttributesList(
         stepMode: bufferLayout.stepMode,
         vertexFormat: attributeMapping.format,
         byteOffset: attributeMapping.byteOffset,
+        // @ts-ignore
         byteStride
       };
     }
@@ -230,31 +234,3 @@ function getAttributeFromAttributesList(
 
   return null;
 }
-
-/**
- * Merges an provided shader layout into a base shader layout
- * In WebGL, this allows the auto generated shader layout to be overridden by the application
- * Typically to change the format of the vertex attributes (from float32x4 to uint8x4 etc).
- * @todo Drop this? Aren't all use cases covered by mergeBufferLayout()?
- */
-export function mergeShaderLayout(
-  baseLayout: ShaderLayout,
-  overrideLayout: ShaderLayout
-): ShaderLayout {
-  // Deep clone the base layout
-  const mergedLayout: ShaderLayout = {
-    ...baseLayout,
-    attributes: baseLayout.attributes.map(attribute => ({...attribute}))
-  };
-  // Merge the attributes
-  for (const attribute of overrideLayout?.attributes || []) {
-    const baseAttribute = mergedLayout.attributes.find(attr => attr.name === attribute.name);
-    if (!baseAttribute) {
-      log.warn(`shader layout attribute ${attribute.name} not present in shader`);
-    } else {
-      baseAttribute.type = attribute.type || baseAttribute.type;
-      baseAttribute.stepMode = attribute.stepMode || baseAttribute.stepMode;
-    }
-  }
-  return mergedLayout;
-}

package/src/adapter-utils/is-uniform-value.ts

@@ -0,0 +1,10 @@
+// luma.gl
+// SPDX-License-Identifier: MIT
+// Copyright (c) vis.gl contributors
+
+import {isNumberArray} from '../utils/is-array';
+import {UniformValue} from '../adapter/types/uniforms';
+
+export function isUniformValue(value: unknown): value is UniformValue {
+  return isNumberArray(value) || typeof value === 'number' || typeof value === 'boolean';
+}

package/src/{adapter/type-utils → gpu-type-utils}/decode-attribute-type.ts

@@ -2,8 +2,8 @@
 // SPDX-License-Identifier: MIT
 // Copyright (c) vis.gl contributors
 
-import {ShaderDataType, ShaderAttributeType} from '../types/shader-types';
-import {VertexFormat, VertexType} from '../types/vertex-formats';
+import {ShaderDataType, ShaderAttributeType} from './shader-types';
+import {VertexFormat, VertexType} from './vertex-formats';
 
 /** Information extracted from a ShaderAttributeInfo constant */
 export type ShaderAttributeTypeInfo = {
@@ -18,7 +18,7 @@ export type ShaderAttributeTypeInfo = {
   /** Whether this data type is signed */
   signed: boolean;
   /** The simplest vertex format that matches the shader attribute's data type */
-  defaultVertexFormat?: VertexFormat;
+  defaultVertexFormat: VertexFormat;
 };
 
 /** Decodes a vertex type, returning byte length and flags (integer, signed, normalized) */

package/src/{adapter/type-utils → gpu-type-utils}/decode-data-type.ts

@@ -2,7 +2,7 @@
 // SPDX-License-Identifier: MIT
 // Copyright (c) vis.gl contributors
 
-import {DataType, NormalizedDataType} from '../types/vertex-formats';
+import {DataType, NormalizedDataType} from './vertex-formats';
 
 export type DecodedVertexType = {
   /** WebGPU data type */

package/src/{adapter/type-utils → gpu-type-utils}/decode-shader-types.ts

@@ -2,8 +2,7 @@
 // SPDX-License-Identifier: MIT
 // Copyright (c) vis.gl contributors
 
-import {assert} from '../../utils/assert';
-import {ShaderUniformType, ShaderDataType} from '../types/shader-types';
+import {ShaderUniformType, ShaderDataType} from './shader-types';
 
 const UNIFORM_FORMATS: Record<ShaderUniformType, {type: ShaderDataType; components: number}> = {
   f32: {type: 'f32', components: 1},
@@ -36,7 +35,6 @@ export function decodeShaderUniformType(format: ShaderUniformType): {
   components: number;
 } {
   const decoded = UNIFORM_FORMATS[format];
-  assert(format);
   return decoded;
 }
 

package/src/{adapter/type-utils → gpu-type-utils}/decode-texture-format.ts

@@ -2,8 +2,8 @@
 // SPDX-License-Identifier: MIT
 // Copyright (c) vis.gl contributors
 
-import {TextureFormat} from '../types/texture-formats';
-import {VertexType} from '../types/vertex-formats';
+import {TextureFormat} from './texture-formats';
+import {VertexType} from './vertex-formats';
 import {decodeVertexType} from './decode-data-type';
 
 // prettier-ignore
@@ -11,19 +11,40 @@ const COMPRESSED_TEXTURE_FORMAT_PREFIXES = [
   'bc1', 'bc2', 'bc3', 'bc4', 'bc5', 'bc6', 'bc7', 'etc1', 'etc2', 'eac', 'atc', 'astc', 'pvrtc'
 ];
 
-const REGEX = /^(rg?b?a?)([0-9]*)([a-z]*)(-srgb)?(-webgl|-unsized)?$/;
+const REGEX = /^(r|rg|rgb|rgba|bgra)([0-9]*)([a-z]*)(-srgb)?(-webgl)?$/;
 
 export type DecodedTextureFormat = {
-  format: 'r' | 'rg' | 'rgb' | 'rgba';
+  /** 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?: VertexType;
-  srgb: boolean;
-  webgl: boolean;
-  unsized: boolean;
-  byteLength: number;
+  /** 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;
+  /** Depth stencil formats */
+  a?: 'depth' | 'stencil' | 'depth-stencil';
+  /** 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;
+  /** Block size for ASTC formats (texture must be a multiple) */
+  blockWidth?: number;
+  /** Block size for ASTC formats (texture must be a multiple) */
+  blockHeight?: number;
+  /** */
 };
 
 /**
@@ -39,19 +60,28 @@ export function isTextureFormatCompressed(textureFormat: TextureFormat): boolean
 export function decodeTextureFormat(format: TextureFormat): DecodedTextureFormat {
   const matches = REGEX.exec(format as string);
   if (matches) {
-    const [, format, length, type, srgb, suffix] = matches;
+    const [, channels, length, type, srgb, suffix] = matches;
     if (format) {
       const dataType = `${type}${length}` as VertexType;
       const decodedType = decodeVertexType(dataType);
-      return {
-        format: format as 'r' | 'rg' | 'rgb' | 'rgba',
-        components: format.length as 1 | 2 | 3 | 4,
-        // dataType - overwritten by decodedType
-        srgb: srgb === '-srgb',
-        unsized: suffix === '-unsized',
-        webgl: suffix === '-webgl',
-        ...decodedType
+      const info: DecodedTextureFormat = {
+        channels: channels as 'r' | 'rg' | 'rgb' | 'rgba',
+        components: channels.length as 1 | 2 | 3 | 4,
+        bitsPerChannel: decodedType.byteLength * 8,
+        bytesPerPixel: decodedType.byteLength * channels.length,
+        dataType: decodedType.dataType,
+        integer: decodedType.integer,
+        signed: decodedType.signed,
+        normalized: decodedType.normalized
       };
+      if (suffix === '-webgl') {
+        info.webgl = true;
+      }
+      // dataType - overwritten by decodedType
+      if (srgb === '-srgb') {
+        info.srgb = true;
+      }
+      return info;
     }
   }
 
@@ -60,40 +90,70 @@ export function decodeTextureFormat(format: TextureFormat): DecodedTextureFormat
 
 // https://www.w3.org/TR/webgpu/#texture-format-caps
 
-const EXCEPTIONS: Partial<Record<TextureFormat, any>> = {
+const EXCEPTIONS: Partial<Record<TextureFormat, Partial<DecodedTextureFormat>>> = {
   // Packed 16 bit formats
-  'rgba4unorm-webgl': {format: 'rgba', bpp: 2},
-  'rgb565unorm-webgl': {format: 'rgb', bpp: 2},
-  'rgb5a1unorm-webgl': {format: 'rgba', bbp: 2},
+  'rgba4unorm-webgl': {channels: 'rgba', bytesPerPixel: 2, packed: true},
+  'rgb565unorm-webgl': {channels: 'rgb', bytesPerPixel: 2, packed: true},
+  'rgb5a1unorm-webgl': {channels: 'rgba', bytesPerPixel: 2, packed: true},
   // Packed 32 bit formats
-  rgb9e5ufloat: {format: 'rgb', bbp: 4},
-  rg11b10ufloat: {format: 'rgb', bbp: 4},
-  rgb10a2unorm: {format: 'rgba', bbp: 4},
-  'rgb10a2uint-webgl': {format: 'rgba', bbp: 4},
+  rgb9e5ufloat: {channels: 'rgb', bytesPerPixel: 4, packed: true},
+  rg11b10ufloat: {channels: 'rgb', bytesPerPixel: 4, packed: true},
+  rgb10a2unorm: {channels: 'rgba', bytesPerPixel: 4, packed: true},
+  'rgb10a2uint-webgl': {channels: 'rgba', bytesPerPixel: 4, packed: true},
   // Depth/stencil
-  stencil8: {components: 1, bpp: 1, a: 'stencil'},
-  depth16unorm: {components: 1, bpp: 2, a: 'depth'},
-  depth24plus: {components: 1, bpp: 3, a: 'depth'},
-  depth32float: {components: 1, bpp: 4, a: 'depth'},
-  'depth24plus-stencil8': {components: 2, bpp: 4, a: 'depth-stencil'},
-  // "depth24unorm-stencil8" feature
-  'depth24unorm-stencil8': {components: 2, bpp: 4, a: 'depth-stencil'},
+  stencil8: {components: 1, bytesPerPixel: 1, a: 'stencil', dataType: 'uint8'},
+  depth16unorm: {components: 1, bytesPerPixel: 2, a: 'depth', dataType: 'uint16'},
+  depth24plus: {components: 1, bytesPerPixel: 3, a: 'depth', dataType: 'uint32'},
+  depth32float: {components: 1, bytesPerPixel: 4, a: 'depth', dataType: 'float32'},
+  'depth24plus-stencil8': {components: 2, bytesPerPixel: 4, a: 'depth-stencil', packed: true},
   // "depth32float-stencil8" feature
-  'depth32float-stencil8': {components: 2, bpp: 4, a: 'depth-stencil'}
+  'depth32float-stencil8': {components: 2, bytesPerPixel: 4, a: 'depth-stencil', packed: true}
 };
 
 function decodeNonStandardFormat(format: TextureFormat): DecodedTextureFormat {
+  if (isTextureFormatCompressed(format)) {
+    const info: DecodedTextureFormat = {
+      channels: 'rgb',
+      components: 3,
+      bytesPerPixel: 1,
+      srgb: false,
+      compressed: true
+    } as DecodedTextureFormat;
+    const blockSize = getCompressedTextureBlockSize(format);
+    if (blockSize) {
+      info.blockWidth = blockSize.blockWidth;
+      info.blockHeight = blockSize.blockHeight;
+    }
+    return info;
+  }
   const data = EXCEPTIONS[format];
   if (!data) {
     throw new Error(`Unknown format ${format}`);
   }
-  return {
-    format: data.format || '',
-    components: data.components || data.format?.length || 1,
-    byteLength: data.bpp || 1,
-    srgb: false,
-    unsized: false
+  const info: DecodedTextureFormat = {
+    ...data,
+    channels: data.channels || '',
+    components: data.components || data.channels?.length || 1,
+    bytesPerPixel: data.bytesPerPixel || 1,
+    srgb: false
   } as DecodedTextureFormat;
+  if (data.packed) {
+    info.packed = data.packed;
+  }
+  return info;
+}
+
+/** Parses ASTC block widths from format string */
+function getCompressedTextureBlockSize(
+  format: string
+): {blockWidth: number; blockHeight: number} | null {
+  const REGEX = /.*-(\d+)x(\d+)-.*/;
+  const matches = REGEX.exec(format);
+  if (matches) {
+    const [, blockWidth, blockHeight] = matches;
+    return {blockWidth: Number(blockWidth), blockHeight: Number(blockHeight)};
+  }
+  return null;
 }
 
 /*

package/src/{adapter/type-utils → gpu-type-utils}/decode-vertex-format.ts

@@ -2,7 +2,7 @@
 // SPDX-License-Identifier: MIT
 // Copyright (c) vis.gl contributors
 
-import {VertexFormat, VertexType} from '../types/vertex-formats';
+import {VertexFormat, VertexType} from './vertex-formats';
 import {decodeVertexType} from './decode-data-type';
 
 export type VertexFormatInfo = {

package/src/{adapter/types → gpu-type-utils}/texture-formats.ts

@@ -12,16 +12,11 @@ export type DepthStencilTextureFormat =
   | 'depth24plus'
   | 'depth24plus-stencil8'
   | 'depth32float'
-  // device.features.has('depth24unorm-stencil8')
-  | 'depth24unorm-stencil8'
   // device.features.has('depth32float-stencil8')
   | 'depth32float-stencil8';
 
 /** Texture formats for color attachments */
-export type ColorTextureFormat =
-  | WebGPUColorTextureFormat
-  | WebGL2ColorTextureFormat
-  | UnsizedColorTextureFormat;
+export type ColorTextureFormat = WebGPUColorTextureFormat | WebGL2ColorTextureFormat;
 
 export type WebGPUColorTextureFormat =
   // 8-bit formats
@@ -103,6 +98,7 @@ export type WebGPUColorTextureFormat =
 
   // 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'
@@ -132,14 +128,7 @@ export type WebGPUColorTextureFormat =
   | 'astc-12x12-unorm'
   | 'astc-12x12-unorm-srgb';
 
-/** Unsized texture formats (the only formats supported by WebGL1) */
-export type UnsizedColorTextureFormat = 'rgb8unorm-unsized' | 'rgba8unorm-unsized';
-// 'r8unorm-unsized' |
-// 'ra8unorm-unsized' |
-// 'rgb8unorm-srgb-unsized' |
-// 'rgba8unorm-srgb-unsized'
-
-/** Sized formats unique to WebGL 2. Some will perhaps be added to WebGPU standard? */
+/** Sized formats in WebGL 2 that are not (yet?) supported by WebGPU */
 export type WebGL2ColorTextureFormat =
   | 'r16unorm-webgl'
   | 'r16snorm-webgl'

package/src/{adapter/type-utils → gpu-type-utils}/vertex-format-from-attribute.ts

@@ -2,8 +2,8 @@
 // SPDX-License-Identifier: MIT
 // Copyright (c) vis.gl contributors
 
-import {TypedArray, TypedArrayConstructor} from '../../types';
-import {VertexFormat} from '../types/vertex-formats';
+import {TypedArray, TypedArrayConstructor} from '../types';
+import {VertexFormat} from './vertex-formats';
 
 // import {DataType} from '../types/vertex-formats';
 // type Omit<DataType, 'float16'> unfortunately breaks Typescript inferance

package/src/{adapter/type-utils → gpu-type-utils}/wgsl-utils.ts

@@ -2,7 +2,7 @@
 // SPDX-License-Identifier: MIT
 // Copyright (c) vis.gl contributors
 
-import {ShaderAttributeType} from '../types/shader-types';
+import {ShaderAttributeType} from './shader-types';
 
 /**  Predeclared aliases @see https://www.w3.org/TR/WGSL/#vector-types */
 export const WGSL_TYPE_ALIAS_MAP: Record<string, ShaderAttributeType> = {