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

package/src/adapter/device.ts

@@ -5,7 +5,8 @@
 import {StatsManager, lumaStats} from '../utils/stats-manager';
 import {log} from '../utils/log';
 import {uid} from '../utils/uid';
-import type {TextureFormat, TextureFormatInfo} from '../shadertypes/texture-formats';
+import type {VertexFormat, VertexFormatInfo} from '../shadertypes/vertex-arrays/vertex-formats';
+import type {TextureFormat, TextureFormatInfo} from '../shadertypes/textures/texture-formats';
 import type {CanvasContext, CanvasContextProps} from './canvas-context';
 import type {BufferProps} from './resources/buffer';
 import {Buffer} from './resources/buffer';
@@ -24,12 +25,8 @@ import type {VertexArray, VertexArrayProps} from './resources/vertex-array';
 import type {TransformFeedback, TransformFeedbackProps} from './resources/transform-feedback';
 import type {QuerySet, QuerySetProps} from './resources/query-set';
 
-import {
-  isTextureFormatCompressed,
-  getTextureFormatInfo,
-  getTextureFormatCapabilities
-} from '../shadertypes/utils/decode-texture-format';
-
+import {getVertexFormatInfo} from '../shadertypes/vertex-arrays/decode-vertex-format';
+import {textureFormatDecoder} from '../shadertypes/textures/texture-format-decoder';
 import type {ExternalImage} from '../image-utils/image-types';
 import {isExternalImage, getExternalImageSize} from '../image-utils/image-types';
 
@@ -147,19 +144,29 @@ export type DeviceFeature =
   | WebGPUDeviceFeature
   | WebGLDeviceFeature
   | WebGLCompressedTextureFeatures;
+// | ChromeExperimentalFeatures
+
+/** Chrome-specific extensions. Expected to eventually become standard features. */
+// export type ChromeExperimentalFeatures = ;
 
 export type WebGPUDeviceFeature =
   | 'depth-clip-control'
-  | 'indirect-first-instance'
+  | 'depth32float-stencil8'
+  | 'texture-compression-bc'
+  | 'texture-compression-bc-sliced-3d'
+  | 'texture-compression-etc2'
+  | 'texture-compression-astc'
+  | 'texture-compression-astc-sliced-3d'
   | 'timestamp-query'
+  | 'indirect-first-instance'
   | 'shader-f16'
-  | 'depth32float-stencil8'
   | 'rg11b10ufloat-renderable' // Is the rg11b10ufloat texture format renderable?
-  | 'float32-filterable' // Is the float32 format filterable?
   | 'bgra8unorm-storage' // Can the bgra8unorm texture format be used in storage buffers?
-  | 'texture-compression-bc'
-  | 'texture-compression-etc2'
-  | 'texture-compression-astc';
+  | 'float32-filterable' // Is the float32 format filterable?
+  | 'float32-blendable' // Is the float32 format blendable?
+  | 'clip-distances'
+  | 'dual-source-blending'
+  | 'subgroups';
 // | 'depth-clamping' // removed from the WebGPU spec...
 // | 'pipeline-statistics-query' // removed from the WebGPU spec...
 
@@ -231,20 +238,22 @@ export type DeviceProps = {
 
   // CALLBACKS
 
-  /** Error handling - uncaught errors */
+  /** Error handler. If it returns a probe logger style function, it will be called at the site of the error to optimize console error links. */
   onError?: (error: Error, context?: unknown) => unknown;
-  /** Called when the size of a canvas changes */
+  /** Called when the size of a CanvasContext's canvas changes */
   onResize?: (ctx: CanvasContext, info: {oldPixelSize: [number, number]}) => unknown;
-  /** Called when the visibility of a canvas changes */
+  /** Called when the absolute position of a CanvasContext's canvas changes. Must set `CanvasContextProps.trackPosition: true` */
+  onPositionChange?: (ctx: CanvasContext, info: {oldPosition: [number, number]}) => unknown;
+  /** Called when the visibility of a CanvasContext's canvas changes */
   onVisibilityChange?: (ctx: CanvasContext) => unknown;
-  /** Called when the device pixel ratio of a canvas changes */
+  /** Called when the device pixel ratio of a CanvasContext's canvas changes */
   onDevicePixelRatioChange?: (ctx: CanvasContext, info: {oldRatio: number}) => unknown;
 
   // DEBUG SETTINGS
 
   /** Turn on implementation defined checks that slow down execution but help break where errors occur */
   debug?: boolean;
-  /** Show shader source in browser? The default is`'error'`, meaning that logs are shown when shader compilation has errors */
+  /** Show shader source in browser? The default is `'error'`, meaning that logs are shown when shader compilation has errors */
   debugShaders?: 'never' | 'errors' | 'warnings' | 'always';
   /** Renders a small version of updated Framebuffers into the primary canvas context. Can be set in console luma.log.set('debug-framebuffers', true) */
   debugFramebuffers?: boolean;
@@ -259,6 +268,8 @@ export type DeviceProps = {
 
   // EXPERIMENTAL SETTINGS - subject to change
 
+  /** adapter.create() returns the existing Device if the provided canvas' WebGL context is already associated with a Device.  */
+  _reuseDevices?: boolean;
   /** WebGPU specific - Request a Device with the highest limits supported by platform. On WebGPU devices can be created with minimal limits. */
   _requestMaxLimits?: boolean;
   /** Disable specific features */
@@ -278,14 +289,24 @@ export type DeviceProps = {
 
 /** WebGL independent copy of WebGLContextAttributes */
 type WebGLContextProps = {
-  alpha?: boolean; // indicates if the canvas contains an alpha buffer.
-  desynchronized?: boolean; // hints the user agent to reduce the latency by desynchronizing the canvas paint cycle from the event loop
-  antialias?: boolean; // indicates whether or not to perform anti-aliasing.
-  depth?: boolean; // indicates that the drawing buffer has a depth buffer of at least 16 bits.
-  failIfMajorPerformanceCaveat?: boolean; // indicates if a context will be created if the system performance is low or if no hardware GPU is available.
+  /** indicates if the canvas contains an alpha buffer. */
+  alpha?: boolean;
+  /** hints the user agent to reduce the latency by desynchronizing the canvas paint cycle from the event loop */
+  desynchronized?: boolean;
+  /** indicates whether or not to perform anti-aliasing. */
+  antialias?: boolean;
+  /** indicates that the render target has a stencil buffer of at least `8` bits. */
+  stencil?: boolean;
+  /** indicates that the drawing buffer has a depth buffer of at least 16 bits. */
+  depth?: boolean;
+  /** indicates if a context will be created if the system performance is low or if no hardware GPU is available. */
+  failIfMajorPerformanceCaveat?: boolean;
+  /** Selects GPU */
   powerPreference?: 'default' | 'high-performance' | 'low-power';
-  premultipliedAlpha?: boolean; // page compositor will assume the drawing buffer contains colors with pre-multiplied alpha.
-  preserveDrawingBuffer?: boolean; // buffers will not be cleared and will preserve their values until cleared or overwritten by the author.
+  /** page compositor will assume the drawing buffer contains colors with pre-multiplied alpha. */
+  premultipliedAlpha?: boolean;
+  /** buffers will not be cleared and will preserve their values until cleared or overwritten by the author. */
+  preserveDrawingBuffer?: boolean;
 };
 
 /**
@@ -312,11 +333,15 @@ export abstract class Device {
     webgl: {},
 
     // Callbacks
-    onError: (error: Error, context: unknown) => log.error(error.message, context)(),
+    // eslint-disable-next-line handle-callback-err
+    onError: (error: Error, context: unknown) => {},
     onResize: (context: CanvasContext, info: {oldPixelSize: [number, number]}) => {
       const [width, height] = context.getDevicePixelSize();
-      const [prevWidth, prevHeight] = info.oldPixelSize;
-      log.log(1, `${context} Resized ${prevWidth}x${prevHeight} => ${width}x${height}px`)();
+      log.log(1, `${context} resized => ${width}x${height}px`)();
+    },
+    onPositionChange: (context: CanvasContext, info: {oldPosition: [number, number]}) => {
+      const [left, top] = context.getPosition();
+      log.log(1, `${context} repositioned => ${left},${top}`)();
     },
     onVisibilityChange: (context: CanvasContext) =>
       log.log(1, `${context} Visibility changed ${context.isVisible}`)(),
@@ -333,6 +358,7 @@ export abstract class Device {
     debugSpectorJSUrl: undefined!,
 
     // Experimental
+    _reuseDevices: false,
     _requestMaxLimits: true,
     _cacheShaders: false,
     _cachePipelines: false,
@@ -351,9 +377,8 @@ export abstract class Device {
     return 'Device';
   }
 
-  constructor(props: DeviceProps) {
-    this.props = {...Device.defaultProps, ...props};
-    this.id = this.props.id || uid(this[Symbol.toStringTag].toLowerCase());
+  toString(): string {
+    return `Device(${this.id})`;
   }
 
   /** id of this device, primarily for debugging */
@@ -372,11 +397,11 @@ export abstract class Device {
   /** An abstract timestamp used for change tracking */
   timestamp: number = 0;
 
+  /** True if this device has been reused during device creation (app has multiple references) */
+  _reused: boolean = false;
   /** Used by other luma.gl modules to store data on the device */
   _lumaData: {[key: string]: unknown} = {};
 
-  abstract destroy(): void;
-
   // Capabilities
 
   /** Information about the device (vendor, versions etc) */
@@ -395,9 +420,24 @@ export abstract class Device {
 
   protected _textureCaps: Partial<Record<TextureFormat, DeviceTextureFormatCapabilities>> = {};
 
+  constructor(props: DeviceProps) {
+    this.props = {...Device.defaultProps, ...props};
+    this.id = this.props.id || uid(this[Symbol.toStringTag].toLowerCase());
+  }
+
+  abstract destroy(): void;
+
+  getVertexFormatInfo(format: VertexFormat): VertexFormatInfo {
+    return getVertexFormatInfo(format);
+  }
+
+  isVertexFormatSupported(format: VertexFormat): boolean {
+    return true;
+  }
+
   /** Returns information about a texture format, such as data type, channels, bits per channel, compression etc */
   getTextureFormatInfo(format: TextureFormat): TextureFormatInfo {
-    return getTextureFormatInfo(format);
+    return textureFormatDecoder.getInfo(format);
   }
 
   /** Determines what operations are supported on a texture format on this particular device (checks against supported device features) */
@@ -411,6 +451,9 @@ export abstract class Device {
     return textureCaps;
   }
 
+  /** Return the implementation specific alignment for a texture format. 1 on WebGL, 256 on WebGPU */
+  abstract getTextureByteAlignment(): number;
+
   /** Calculates the number of mip levels for a texture of width, height and in case of 3d textures only, depth */
   getMipLevelCount(width: number, height: number, depth3d: number = 1): number {
     const maxSize = Math.max(width, height, depth3d);
@@ -444,7 +487,7 @@ export abstract class Device {
 
   /** Check if a specific texture format is GPU compressed */
   isTextureFormatCompressed(format: TextureFormat): boolean {
-    return isTextureFormatCompressed(format);
+    return textureFormatDecoder.isCompressed(format);
   }
 
   // DEBUG METHODS
@@ -483,13 +526,45 @@ export abstract class Device {
     return this.timestamp++;
   }
 
-  /** Report error (normally called for unhandled device errors) */
-  reportError(error: Error, context?: unknown): void {
+  /**
+   * Reports Device errors in a way that optimizes for developer experience / debugging.
+   * - Logs so that the console error links directly to the source code that generated the error.
+   * - Includes the object that reported the error in the log message, even if the error is asynchronous.
+   *
+   * Conventions when calling reportError():
+   * - Always call the returned function - to ensure error is logged, at the error site
+   * - Follow with a call to device.debug() - to ensure that the debugger breaks at the error site
+   *
+   * @param error - the error to report. If needed, just create a new Error object with the appropriate message.
+   * @param context - pass `this` as context, otherwise it may not be available in the debugger for async errors.
+   * @returns the logger function returned by device.props.onError() so that it can be called from the error site.
+   *
+   * @example
+   *   device.reportError(new Error(...), this)();
+   *   device.debug();
+   */
+  reportError(error: Error, context: unknown, ...args: unknown[]): () => unknown {
+    // Call the error handler
+    const isHandled = this.props.onError(error, context);
+    if (!isHandled) {
+      // Note: Returns a function that must be called: `device.reportError(...)()`
+      return log.error(error.message, context, ...args);
+    }
+    return () => {};
+  }
+
+  /** Break in the debugger - if device.props.debug is true */
+  debug(): void {
     if (this.props.debug) {
       // @ts-ignore
       debugger; // eslint-disable-line
+    } else {
+      // TODO(ibgreen): Does not appear to be printed in the console
+      const message = `\
+'Type luma.log.set({debug: true}) in console to enable debug breakpoints',
+or create a device with the 'debug: true' prop.`;
+      log.once(0, message)();
     }
-    this.props.onError(error, context);
   }
 
   // Canvas context
@@ -638,10 +713,15 @@ export abstract class Device {
 
   // IMPLEMENTATION
 
+  /** Helper to get the canvas context props */
+  static _getCanvasContextProps(props: DeviceProps): CanvasContextProps | undefined {
+    return props.createCanvasContext === true ? {} : props.createCanvasContext;
+  }
+
   protected _getDeviceTextureFormatCapabilities(
     format: TextureFormat
   ): DeviceTextureFormatCapabilities {
-    const genericCapabilities = getTextureFormatCapabilities(format);
+    const genericCapabilities = textureFormatDecoder.getCapabilities(format);
 
     // Check standard features
     const checkFeature = (feature: DeviceFeature | boolean | undefined) =>
@@ -664,20 +744,25 @@ export abstract class Device {
       props = {data: props};
     }
 
-    // TODO - fragile, as this is done before we merge with default options
+    // TODO(ibgreen) - fragile, as this is done before we merge with default options
     // inside the Buffer constructor
 
     const newProps = {...props};
     // Deduce indexType
-    if ((props.usage || 0) & Buffer.INDEX && !props.indexType) {
-      if (props.data instanceof Uint32Array) {
-        newProps.indexType = 'uint32';
-      } else if (props.data instanceof Uint16Array) {
-        newProps.indexType = 'uint16';
-      } else {
-        log.warn('indices buffer content must be of type uint16 or uint32')();
+    const usage = props.usage || 0;
+    if (usage & Buffer.INDEX) {
+      if (!props.indexType) {
+        if (props.data instanceof Uint32Array) {
+          newProps.indexType = 'uint32';
+        } else if (props.data instanceof Uint16Array) {
+          newProps.indexType = 'uint16';
+        }
+      }
+      if (!newProps.indexType) {
+        throw new Error('indices buffer content must be of type uint16 or uint32');
       }
     }
+
     return newProps;
   }
 }

package/src/adapter/resources/buffer.ts

@@ -5,6 +5,9 @@
 import type {Device} from '../device';
 import {Resource, ResourceProps} from './resource';
 
+/** Callback for Buffer.mapAndReadAsync */
+export type BufferMapCallback<T> = (arrayBuffer: ArrayBuffer, lifetime: 'mapped' | 'copied') => T;
+
 export type BufferProps = ResourceProps & {
   /** Supply a handle to connect to an existing device-specific buffer */
   handle?: WebGLBuffer;
@@ -12,15 +15,14 @@ export type BufferProps = ResourceProps & {
   usage?: number;
   /** Length in bytes of memory to be allocated. If not specified, `byteLength` of  `props.data` will be used. */
   byteLength?: number;
-  /** Data to initialize the buffer with. */
-  data?: ArrayBuffer | ArrayBufferView | null;
   /** Byte offset into the newly created Buffer to store data at */
   byteOffset?: number;
   /** If props.usage includes Buffer.INDEX */
   indexType?: 'uint16' | 'uint32';
-
-  // TBD
-  mappedAtCreation?: boolean;
+  /** Data to initialize the buffer with. */
+  data?: ArrayBuffer | ArrayBufferView | null;
+  /** Callback to initialize data without copy */
+  onMapped?: BufferMapCallback<void>;
 };
 
 /** Abstract GPU buffer */
@@ -88,15 +90,29 @@ export abstract class Buffer extends Resource<BufferProps> {
   }
 
   /** Write data to buffer */
-  abstract write(data: ArrayBufferView, byteOffset?: number): void;
-
-  /** Read data asynchronously */
+  abstract write(
+    data: ArrayBufferLike | ArrayBufferView | SharedArrayBuffer,
+    byteOffset?: number
+  ): void;
+
+  abstract mapAndWriteAsync(
+    onMapped: BufferMapCallback<void | Promise<void>>,
+    byteOffset?: number,
+    byteLength?: number
+  ): Promise<void>;
+
+  /** Reads data asynchronously, returns a copy of the buffer data */
   abstract readAsync(byteOffset?: number, byteLength?: number): Promise<Uint8Array>;
 
+  /** Maps buffer data to CPU memory. Mapped memory is only accessible in the callback */
+  abstract mapAndReadAsync<T>(
+    onMapped: BufferMapCallback<T>,
+    byteOffset?: number,
+    byteLength?: number
+  ): Promise<T>;
+
   /** Read data synchronously. @note WebGL2 only */
-  readSyncWebGL(byteOffset?: number, byteLength?: number): Uint8Array {
-    throw new Error('not implemented');
-  }
+  abstract readSyncWebGL(byteOffset?: number, byteLength?: number): Uint8Array;
 
   // PROTECTED METHODS (INTENDED FOR USE BY OTHER FRAMEWORK CODE ONLY)
 
@@ -108,11 +124,11 @@ export abstract class Buffer extends Resource<BufferProps> {
 
   /** This doesn't handle partial non-zero offset updates correctly */
   protected _setDebugData(
-    data: ArrayBufferView | ArrayBuffer | null,
+    data: ArrayBufferView | ArrayBufferLike | null,
     byteOffset: number,
     byteLength: number
   ): void {
-    const arrayBuffer: ArrayBuffer | null = ArrayBuffer.isView(data) ? data.buffer : data;
+    const arrayBuffer: ArrayBufferLike | null = ArrayBuffer.isView(data) ? data.buffer : data;
     const debugDataLength = Math.min(
       data ? data.byteLength : byteLength,
       Buffer.DEBUG_DATA_MAX_LENGTH
@@ -133,6 +149,6 @@ export abstract class Buffer extends Resource<BufferProps> {
     byteOffset: 0,
     data: null,
     indexType: 'uint16',
-    mappedAtCreation: false
+    onMapped: undefined!
   };
 }

package/src/adapter/resources/command-encoder.ts

@@ -134,8 +134,6 @@ export type CommandEncoderProps = ResourceProps & {
  * Encodes commands to queue that can be executed later
  */
 export abstract class CommandEncoder extends Resource<CommandEncoderProps> {
-  abstract readonly handle: unknown;
-
   override get [Symbol.toStringTag](): string {
     return 'CommandEncoder';
   }

package/src/adapter/resources/framebuffer.ts

@@ -3,10 +3,10 @@
 // Copyright (c) vis.gl contributors
 
 import type {
-  ColorTextureFormat,
-  DepthStencilTextureFormat,
+  TextureFormatColor,
+  TextureFormatDepthStencil,
   TextureFormat
-} from '../../shadertypes/texture-formats';
+} from '../../shadertypes/textures/texture-formats';
 import type {Device} from '../device';
 import {Resource, ResourceProps} from './resource';
 import {Texture} from './texture';
@@ -16,8 +16,8 @@ import {log} from '../../utils/log';
 export type FramebufferProps = ResourceProps & {
   width?: number;
   height?: number;
-  colorAttachments?: (TextureView | Texture | ColorTextureFormat)[];
-  depthStencilAttachment?: (TextureView | Texture | DepthStencilTextureFormat) | null;
+  colorAttachments?: (TextureView | Texture | TextureFormatColor)[];
+  depthStencilAttachment?: (TextureView | Texture | TextureFormatDepthStencil) | null;
 };
 
 /**

package/src/adapter/resources/pipeline-layout.ts

@@ -0,0 +1,30 @@
+// luma.gl
+// SPDX-License-Identifier: MIT
+// Copyright (c) vis.gl contributors
+
+import {Device} from '../device';
+import {ShaderLayout} from '../types/shader-layout';
+import {Resource, ResourceProps} from './resource';
+
+export type PipelineLayoutProps = ResourceProps & {
+  shaderLayout: ShaderLayout;
+};
+
+/** Immutable PipelineLayout object */
+export abstract class PipelineLayout extends Resource<PipelineLayoutProps> {
+  get [Symbol.toStringTag](): string {
+    return 'PipelineLayout';
+  }
+
+  constructor(device: Device, props: PipelineLayoutProps) {
+    super(device, props, PipelineLayout.defaultProps);
+  }
+
+  static override defaultProps: Required<PipelineLayoutProps> = {
+    ...Resource.defaultProps,
+    shaderLayout: {
+      attributes: [],
+      bindings: []
+    }
+  };
+}

package/src/adapter/resources/render-pipeline.ts

@@ -8,9 +8,9 @@ import type {PrimitiveTopology, RenderPipelineParameters} from '../types/paramet
 import type {ShaderLayout, Binding} from '../types/shader-layout';
 import type {BufferLayout} from '../types/buffer-layout';
 import type {
-  ColorTextureFormat,
-  DepthStencilTextureFormat
-} from '@luma.gl/core/shadertypes/texture-formats';
+  TextureFormatColor,
+  TextureFormatDepthStencil
+} from '@luma.gl/core/shadertypes/textures/texture-formats';
 import type {Shader} from './shader';
 import type {RenderPass} from './render-pass';
 import {Resource, ResourceProps} from './resource';
@@ -44,9 +44,9 @@ export type RenderPipelineProps = ResourceProps & {
   // color attachment information (needed on WebGPU)
 
   /** Color attachments expected by this pipeline. Defaults to [device.preferredColorFormat]. Array needs not be contiguous. */
-  colorAttachmentFormats?: (ColorTextureFormat | null)[];
-  /** Depth attachment expected by this pipeline (if depth parameters are specified). Defaults to device.preferredDepthFormat */
-  depthStencilAttachmentFormat?: DepthStencilTextureFormat;
+  colorAttachmentFormats?: (TextureFormatColor | null)[];
+  /** Depth attachment expected by this pipeline. Defaults to device.preferredDepthFormat, if depthWriteEnables parameter is set */
+  depthStencilAttachmentFormat?: TextureFormatDepthStencil;
 
   /** Parameters that are controlled by pipeline */
   parameters?: RenderPipelineParameters;

package/src/adapter/resources/resource.ts

@@ -36,6 +36,7 @@ export abstract class Resource<Props extends ResourceProps> {
   readonly props: Required<Props>;
   readonly userData: Record<string, unknown> = {};
   abstract readonly device: Device;
+  abstract readonly handle: unknown;
   private _device: Device;
 
   /** Whether this resource has been destroyed */

package/src/adapter/resources/texture-view.ts

@@ -4,7 +4,7 @@
 
 import type {Device} from '../device';
 import type {Texture} from './texture';
-import type {TextureFormat} from '../../shadertypes/texture-formats';
+import type {TextureFormat} from '../../shadertypes/textures/texture-formats';
 import {Resource, ResourceProps} from './resource';
 
 /** Properties for initializing a texture view */

package/src/adapter/resources/texture.ts

@@ -4,7 +4,7 @@
 
 import {TypedArray} from '@math.gl/types';
 import type {Device} from '../device';
-import type {TextureFormat} from '../../shadertypes/texture-formats';
+import type {TextureFormat} from '../../shadertypes/textures/texture-formats';
 import type {TextureView, TextureViewProps} from './texture-view';
 import {Resource, ResourceProps} from './resource';
 import {Sampler, SamplerProps} from './sampler';

package/src/adapter/resources/vertex-array.ts

@@ -71,6 +71,6 @@ export abstract class VertexArray extends Resource<VertexArrayProps> {
 
   /** @deprecated Set constant attributes (WebGL only) */
   setConstantWebGL(location: number, value: TypedArray | null): void {
-    throw new Error('constant attributes not supported');
+    this.device.reportError(new Error('constant attributes not supported'), this)();
   }
 }

package/src/adapter/types/attachments.ts

@@ -3,10 +3,10 @@
 // Copyright (c) vis.gl contributors
 
 import type {
-  ColorTextureFormat,
-  DepthStencilTextureFormat,
+  TextureFormatColor,
+  TextureFormatDepthStencil,
   TextureFormat
-} from '../../shadertypes/texture-formats';
+} from '../../shadertypes/textures/texture-formats';
 import type {Texture} from '../resources/texture'; // TextureView...
 import type {TextureView} from '../resources/texture-view'; // TextureView...
 
@@ -60,7 +60,7 @@ export type ColorAttachment = {
   /** Describes the texture subresource that will be output to for this color attachment. */
   texture?: TextureView | Texture;
   /** Format of the texture resource. Used to auto create texture if not supplied */
-  format?: ColorTextureFormat;
+  format?: TextureFormatColor;
   /* Describes the texture subresource that will receive  resolved output for this color attachment if multisampled. */
   // resolveTarget?: GPUTextureView;
 
@@ -80,7 +80,7 @@ export type DepthStencilAttachment = {
   /** Describes the texture subresource that will be output to and read from for this depth/stencil attachment. */
   texture?: TextureView | Texture;
   /** Format of the texture resource. Used to auto create texture if not supplied */
-  format?: DepthStencilTextureFormat;
+  format?: TextureFormatDepthStencil;
 
   /** Value to clear depth component to prior to executing the render pass, if depthLoadOp is "clear". 0.0-1.0. */
   depthClearValue?: number;

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

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

package/src/adapter/types/parameters.ts

@@ -3,7 +3,7 @@
 // Copyright (c) vis.gl contributors
 
 import {NumberArray4, NumberArray6} from '@math.gl/types';
-import {DepthStencilTextureFormat} from '../../shadertypes/texture-formats';
+import {TextureFormatDepthStencil} from '../../shadertypes/textures/texture-formats';
 
 export type CompareFunction =
   | 'never'
@@ -101,7 +101,7 @@ export type DepthStencilParameters = {
   /** The comparison operation used to test fragment depths against existing depthStencilAttachment depth values. */
   depthCompare?: CompareFunction;
   /** The format of depthStencilAttachment this GPURenderPipeline will be compatible with. */
-  depthFormat?: DepthStencilTextureFormat;
+  depthFormat?: TextureFormatDepthStencil;
 
   /** Bitmask controlling which depthStencilAttachment stencil value bits are read when performing stencil comparison tests. */
   stencilReadMask?: number;

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

@@ -2,8 +2,11 @@
 // SPDX-License-Identifier: MIT
 // Copyright (c) vis.gl contributors
 
-import type {TextureFormat} from '../../shadertypes/texture-formats';
-import type {VariableShaderType, AttributeShaderType} from '../../shadertypes/shader-types';
+import type {TextureFormat} from '../../shadertypes/textures/texture-formats';
+import type {
+  VariableShaderType,
+  AttributeShaderType
+} from '../../shadertypes/data-types/shader-types';
 import type {Buffer} from '../resources/buffer';
 import type {Sampler} from '../resources/sampler';
 import type {Texture} from '../resources/texture';
@@ -110,7 +113,7 @@ export type StorageBufferBindingLayout = {
   minBindingSize?: number;
 };
 
-type TextureBindingLayout = {
+export type TextureBindingLayout = {
   type: 'texture';
   /** Name of the binding. Used by luma to map bindings by name */
   name: string;
@@ -125,7 +128,7 @@ type TextureBindingLayout = {
   multisampled?: boolean;
 };
 
-type SamplerBindingLayout = {
+export type SamplerBindingLayout = {
   type: 'sampler';
   /** Name of the binding. Used by luma to map bindings by name */
   name: string;
@@ -138,7 +141,7 @@ type SamplerBindingLayout = {
   samplerType?: 'filtering' | 'non-filtering' | 'comparison'; // default: filtering
 };
 
-type StorageTextureBindingLayout = {
+export type StorageTextureBindingLayout = {
   type: 'storage';
   /** Name of the binding. Used by luma to map bindings by name */
   name: string;