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

package/src/adapter/device.ts

@@ -2,11 +2,10 @@
 // SPDX-License-Identifier: MIT
 // Copyright (c) vis.gl contributors
 
-import {VERSION} from '../init';
 import {StatsManager, lumaStats} from '../utils/stats-manager';
 import {log} from '../utils/log';
-import {uid} from '../utils/utils';
-import type {TextureFormat} from './types/texture-formats';
+import {uid} from '../utils/uid';
+import type {TextureFormat} from '../gpu-type-utils//texture-formats';
 import type {CanvasContext, CanvasContextProps} from './canvas-context';
 import type {BufferProps} from './resources/buffer';
 import {Buffer} from './resources/buffer';
@@ -14,7 +13,7 @@ import type {RenderPipeline, RenderPipelineProps} from './resources/render-pipel
 import type {ComputePipeline, ComputePipelineProps} from './resources/compute-pipeline';
 import type {Sampler, SamplerProps} from './resources/sampler';
 import type {Shader, ShaderProps} from './resources/shader';
-import type {Texture, TextureProps, TextureData} from './resources/texture';
+import type {Texture, TextureProps} from './resources/texture';
 import type {ExternalTexture, ExternalTextureProps} from './resources/external-texture';
 import type {Framebuffer, FramebufferProps} from './resources/framebuffer';
 import type {RenderPass, RenderPassProps} from './resources/render-pass';
@@ -24,7 +23,7 @@ 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} from './type-utils/decode-texture-format';
+import {isTextureFormatCompressed} from '../gpu-type-utils/decode-texture-format';
 
 /**
  * Identifies the GPU vendor and driver.
@@ -131,7 +130,7 @@ export class DeviceFeatures {
   }
 
   has(feature: DeviceFeature): boolean {
-    return !this.disabledFeatures[feature] && this.features.has(feature);
+    return !this.disabledFeatures?.[feature] && this.features.has(feature);
   }
 }
 
@@ -146,7 +145,6 @@ export type WebGPUDeviceFeature =
   | 'indirect-first-instance'
   | 'timestamp-query'
   | 'shader-f16'
-  | 'depth24unorm-stencil8'
   | 'depth32float-stencil8'
   | 'rg11b10ufloat-renderable' // Is the rg11b10ufloat texture format renderable?
   | 'float32-filterable' // Is the float32 format filterable?
@@ -219,26 +217,42 @@ export type DeviceProps = {
   /** Error handling */
   onError?: (error: Error) => unknown;
 
-  // DEBUG SETTINGS
+  // @deprecated Attach to existing context. Rename to handle? Use Device.attach?
+  gl?: WebGL2RenderingContext | null;
 
+  // DEBUG SETTINGS
   /** WebGL: Instrument WebGL2RenderingContext (at the expense of performance) */
   debug?: boolean;
   /** Break on WebGL functions matching these strings */
   break?: string[];
+
   /** WebGL: Initialize the SpectorJS WebGL debugger */
-  spector?: boolean;
+  debugWithSpectorJS?: boolean;
+  /** SpectorJS URL. Override if CDN is down or different SpectorJS version is desired */
+  spectorUrl?: string;
+
+  // EXPERIMENTAL SETTINGS
+  /** Set to false to disable WebGL state management instrumentation: TODO- Unclear if still supported / useful */
+  manageState?: boolean;
   /** Initialize all features on startup */
   initalizeFeatures?: boolean;
   /** Disable specific features */
   disabledFeatures?: Partial<Record<DeviceFeature, boolean>>;
-
-  /** TODO- Unclear if still supported: Set to false to disable WebGL state management instrumentation */
-  manageState?: boolean;
-
-  // @deprecated Attach to existing context. Rename to handle? Use Device.attach?
-  gl?: WebGL2RenderingContext | null;
+  /** Never destroy cached shaders and pipelines */
+  _factoryDestroyPolicy?: 'unused' | 'never';
 };
 
+/**
+ * Create and attach devices for a specific backend. Currently static methods on each device
+ */
+export interface DeviceFactory {
+  // new (props: DeviceProps): Device; Constructor isn't used
+  type: string;
+  isSupported(): boolean;
+  create(props: DeviceProps): Promise<Device>;
+  attach?(handle: unknown): Device;
+}
+
 /**
  * WebGPU Device/WebGL context abstraction
  */
@@ -250,17 +264,12 @@ export abstract class Device {
     manageState: true,
     width: 800, // width are height are only used by headless gl
     height: 600,
-
     requestMaxLimits: true,
-    debug: Boolean(log.get('debug')), // Instrument context (at the expense of performance)
-    spector: Boolean(log.get('spector') || log.get('spectorjs')), // Initialize the SpectorJS WebGL debugger
-    break: [],
 
-    // TODO - Change these after confirming things work as expected
-    initalizeFeatures: true,
-    disabledFeatures: {
-      'compilation-status-async-webgl': true
-    },
+    // Callbacks
+    onError: (error: Error) => log.error(error.message),
+
+    gl: null,
 
     // alpha: undefined,
     // depth: undefined,
@@ -270,18 +279,25 @@ export abstract class Device {
     // preserveDrawingBuffer: undefined,
     // failIfMajorPerformanceCaveat: undefined
 
-    gl: null,
+    debug: Boolean(log.get('debug')), // Instrument context (at the expense of performance)
+    break: (log.get('break') as string[]) || [],
 
-    // Callbacks
-    onError: (error: Error) => log.error(error.message)
+    // WebGL specific debugging
+    debugWithSpectorJS: undefined!,
+    spectorUrl: undefined!,
+
+    // TODO - Change these after confirming things work as expected
+    initalizeFeatures: true,
+    disabledFeatures: {
+      'compilation-status-async-webgl': true
+    },
+    _factoryDestroyPolicy: 'unused'
   };
 
   get [Symbol.toStringTag](): string {
     return 'Device';
   }
 
-  static VERSION = VERSION;
-
   constructor(props: DeviceProps) {
     this.props = {...Device.defaultProps, ...props};
     this.id = this.props.id || uid(this[Symbol.toStringTag].toLowerCase());
@@ -343,6 +359,11 @@ export abstract class Device {
     return false;
   }
 
+  /** Report error (normally for unhandled device errors) */
+  error(error: Error): void {
+    this.props.onError(error);
+  }
+
   // Canvas context
 
   /** Default / primary canvas context. Can be null as WebGPU devices can be created without a CanvasContext */
@@ -370,14 +391,9 @@ export abstract class Device {
   /** Create a texture */
   abstract _createTexture(props: TextureProps): Texture;
   createTexture(props: TextureProps): Texture;
-  createTexture(data: Promise<TextureData>): Texture;
-  createTexture(url: string): Texture;
+  // createTexture(data: Promise<TextureData>): Texture;
 
-  createTexture(props: TextureProps | Promise<TextureData> | string): Texture {
-    // Signature: new Texture2D(gl, url | Promise)
-    if (props instanceof Promise || typeof props === 'string') {
-      props = {data: props};
-    }
+  createTexture(props: TextureProps): Texture {
     return this._createTexture(props);
   }
 

package/src/adapter/luma.ts

@@ -0,0 +1,219 @@
+// luma.gl
+// SPDX-License-Identifier: MIT
+// Copyright (c) vis.gl contributors
+
+import type {Log} from '@probe.gl/log';
+import type {DeviceProps} from './device';
+import {Device} from './device';
+import {Adapter} from './adapter';
+import {StatsManager} from '../utils/stats-manager';
+import {lumaStats} from '../utils/stats-manager';
+import {log} from '../utils/log';
+
+declare global {
+  // eslint-disable-next-line no-var
+  var luma: Luma;
+}
+
+const STARTUP_MESSAGE = 'set luma.log.level=1 (or higher) to trace rendering';
+
+const ERROR_MESSAGE =
+  'No matching device found. Ensure `@luma.gl/webgl` and/or `@luma.gl/webgpu` modules are imported.';
+
+/** Properties for creating a new device */
+export type CreateDeviceProps = DeviceProps & {
+  /** Selects the type of device. `best-available` uses webgpu if available, then webgl. */
+  type?: 'webgl' | 'webgpu' | 'unknown' | 'best-available';
+  adapters?: Adapter[];
+};
+
+/** Properties for attaching an existing WebGL context or WebGPU device to a new luma Device */
+export type AttachDeviceProps = DeviceProps & {
+  /** Externally created WebGL context or WebGPU device */
+  handle: unknown; // WebGL2RenderingContext | GPUDevice | null;
+  /** List of adapters. Will also search any pre-registered adapterss */
+  adapters?: Adapter[];
+};
+
+/**
+ * Entry point to the luma.gl GPU abstraction
+ * Register WebGPU and/or WebGL adapters (controls application bundle size)
+ * Run-time selection of the first available Device
+ */
+export class Luma {
+  static defaultProps: Required<CreateDeviceProps> = {
+    ...Device.defaultProps,
+    type: 'best-available',
+    adapters: undefined!
+  };
+
+  /** Global stats for all devices */
+  readonly stats: StatsManager = lumaStats;
+
+  /**
+   * Global log
+   *
+   * Assign luma.log.level in console to control logging: \
+   * 0: none, 1: minimal, 2: verbose, 3: attribute/uniforms, 4: gl logs
+   * luma.log.break[], set to gl funcs, luma.log.profile[] set to model names`;
+   */
+  readonly log: Log = log;
+
+  /** Version of luma.gl */
+  readonly VERSION: string =
+    // Version detection using build plugin
+    // @ts-expect-error no-undef
+    typeof __VERSION__ !== 'undefined' ? __VERSION__ : 'running from source';
+
+  spector: unknown;
+
+  protected preregisteredAdapters = new Map<string, Adapter>();
+
+  constructor() {
+    if (globalThis.luma) {
+      if (globalThis.luma.VERSION !== this.VERSION) {
+        log.error(`Found luma.gl ${globalThis.luma.VERSION} while initialzing ${this.VERSION}`)();
+        log.error(`'yarn why @luma.gl/core' can help identify the source of the conflict`)();
+        throw new Error(`luma.gl - multiple versions detected: see console log`);
+      }
+
+      log.error('This version of luma.gl has already been initialized')();
+    }
+
+    log.log(1, `${this.VERSION} - ${STARTUP_MESSAGE}`)();
+
+    globalThis.luma = this;
+  }
+
+  registerAdapters(adapters: Adapter[]): void {
+    for (const deviceClass of adapters) {
+      this.preregisteredAdapters.set(deviceClass.type, deviceClass);
+    }
+  }
+
+  /** Get type strings for supported Devices */
+  getSupportedAdapters(adapters: Adapter[] = []): string[] {
+    const adapterMap = this.getAdapterMap(adapters);
+    return Array.from(adapterMap)
+      .map(([, adapter]) => adapter)
+      .filter(adapter => adapter.isSupported?.())
+      .map(adapter => adapter.type);
+  }
+
+  /** Get type strings for best available Device */
+  getBestAvailableAdapter(adapters: Adapter[] = []): 'webgpu' | 'webgl' | null {
+    const adapterMap = this.getAdapterMap(adapters);
+    if (adapterMap.get('webgpu')?.isSupported?.()) {
+      return 'webgpu';
+    }
+    if (adapterMap.get('webgl')?.isSupported?.()) {
+      return 'webgl';
+    }
+    return null;
+  }
+
+  setDefaultDeviceProps(props: CreateDeviceProps): void {
+    Object.assign(Luma.defaultProps, props);
+  }
+
+  /** Creates a device. Asynchronously. */
+  async createDevice(props: CreateDeviceProps = {}): Promise<Device> {
+    props = {...Luma.defaultProps, ...props};
+
+    // Should be handled by attach device
+    // if (props.gl) {
+    //   props.type = 'webgl';
+    // }
+
+    const adapterMap = this.getAdapterMap(props.adapters);
+
+    let type: string = props.type || '';
+    if (type === 'best-available') {
+      type = this.getBestAvailableAdapter(props.adapters) || type;
+    }
+
+    const adapters = this.getAdapterMap(props.adapters) || adapterMap;
+
+    const adapter = adapters.get(type);
+    const device = await adapter?.create?.(props);
+    if (device) {
+      return device;
+    }
+
+    throw new Error(ERROR_MESSAGE);
+  }
+
+  /** Attach to an existing GPU API handle (WebGL2RenderingContext or GPUDevice). */
+  async attachDevice(props: AttachDeviceProps): Promise<Device> {
+    const adapters = this.getAdapterMap(props.adapters);
+
+    // WebGL
+    let type = '';
+    if (props.handle instanceof WebGL2RenderingContext) {
+      type = 'webgl';
+    }
+
+    // TODO - WebGPU does not yet have a stable API
+    // if (props.handle instanceof GPUDevice) {
+    //   const WebGPUDevice = adapters.get('webgpu') as any;
+    //   if (WebGPUDevice) {
+    //     return (await WebGPUDevice.attach(props.handle)) as Device;
+    //   }
+    // }
+
+    // null
+    if (props.handle === null) {
+      type = 'unknown';
+    }
+
+    const adapter = adapters.get(type);
+    const device = await adapter?.attach?.(null);
+    if (device) {
+      return device;
+    }
+
+    throw new Error(ERROR_MESSAGE);
+  }
+
+  /**
+   * Override `HTMLCanvasContext.getCanvas()` to always create WebGL2 contexts with additional WebGL1 compatibility.
+   * Useful when attaching luma to a context from an external library does not support creating WebGL2 contexts.
+   */
+  enforceWebGL2(enforce: boolean = true, adapters: Adapter[] = []): void {
+    const adapterMap = this.getAdapterMap(adapters);
+    const webgl2Adapter = adapterMap.get('webgl');
+    if (!webgl2Adapter) {
+      log.warn('enforceWebGL2: webgl adapter not found')();
+    }
+    (webgl2Adapter as any)?.enforceWebGL2?.(enforce);
+  }
+
+  /** Convert a list of adapters to a map */
+  protected getAdapterMap(adapters: Adapter[] = []): Map<string, Adapter> {
+    const map = new Map(this.preregisteredAdapters);
+    for (const adapter of adapters) {
+      map.set(adapter.type, adapter);
+    }
+    return map;
+  }
+
+  // DEPRECATED
+
+  /** @deprecated Use registerAdapters */
+  registerDevices(deviceClasses: any[]): void {
+    log.warn('luma.registerDevices() is deprecated, use luma.registerAdapters() instead');
+    for (const deviceClass of deviceClasses) {
+      const adapter = deviceClass.adapter as Adapter;
+      if (adapter) {
+        this.preregisteredAdapters.set(adapter.type, adapter);
+      }
+    }
+  }
+}
+
+/**
+ * Entry point to the luma.gl GPU abstraction
+ * Register WebGPU and/or WebGL adapters (controls application bundle size)
+ * Run-time selection of the first available Device
+ */
+export const luma = new Luma();

package/src/adapter/resources/buffer.ts

@@ -107,17 +107,17 @@ export abstract class Buffer extends Resource<BufferProps> {
     byteOffset: number,
     byteLength: number
   ): void {
-    const buffer: ArrayBuffer | null = ArrayBuffer.isView(data) ? data.buffer : data;
+    const arrayBuffer: ArrayBuffer | null = ArrayBuffer.isView(data) ? data.buffer : data;
     const debugDataLength = Math.min(
       data ? data.byteLength : byteLength,
       Buffer.DEBUG_DATA_MAX_LENGTH
     );
-    if (data === null) {
+    if (arrayBuffer === null) {
       this.debugData = new ArrayBuffer(debugDataLength);
-    } else if (byteOffset === 0 && byteLength === data.byteLength) {
-      this.debugData = buffer.slice(0, debugDataLength);
+    } else if (byteOffset === 0 && byteLength === arrayBuffer.byteLength) {
+      this.debugData = arrayBuffer.slice(0, debugDataLength);
     } else {
-      this.debugData = buffer.slice(byteOffset, byteOffset + debugDataLength);
+      this.debugData = arrayBuffer.slice(byteOffset, byteOffset + debugDataLength);
     }
   }
 }

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

@@ -133,7 +133,7 @@ export type CommandEncoderProps = ResourceProps & {
 export abstract class CommandEncoder extends Resource<CommandEncoderProps> {
   static override defaultProps: Required<CommandEncoderProps> = {
     ...Resource.defaultProps,
-    measureExecutionTime: undefined
+    measureExecutionTime: undefined!
   };
 
   override get [Symbol.toStringTag](): string {

package/src/adapter/resources/compute-pass.ts

@@ -20,9 +20,9 @@ export type ComputePassProps = ResourceProps & {
 export abstract class ComputePass extends Resource<ComputePassProps> {
   static override defaultProps: Required<ComputePassProps> = {
     ...Resource.defaultProps,
-    timestampQuerySet: undefined,
-    beginTimestampIndex: undefined,
-    endTimestampIndex: undefined
+    timestampQuerySet: undefined!,
+    beginTimestampIndex: undefined!,
+    endTimestampIndex: undefined!
   };
 
   override get [Symbol.toStringTag](): string {

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

@@ -28,10 +28,10 @@ export type ComputePipelineProps = ResourceProps & {
 export abstract class ComputePipeline extends Resource<ComputePipelineProps> {
   static override defaultProps: Required<ComputePipelineProps> = {
     ...Resource.defaultProps,
-    shader: undefined,
-    entryPoint: undefined,
+    shader: undefined!,
+    entryPoint: undefined!,
     constants: {},
-    shaderLayout: undefined
+    shaderLayout: undefined!
   };
 
   override get [Symbol.toStringTag](): string {
@@ -39,9 +39,12 @@ export abstract class ComputePipeline extends Resource<ComputePipelineProps> {
   }
 
   hash: string = '';
+  /** The merged shader layout */
+  shaderLayout: ComputeShaderLayout;
 
   constructor(device: Device, props: ComputePipelineProps) {
     super(device, props, ComputePipeline.defaultProps);
+    this.shaderLayout = props.shaderLayout!;
   }
 
   /**

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

@@ -6,13 +6,13 @@ import type {Device} from '../device';
 import {Resource, ResourceProps} from './resource';
 
 export type ExternalTextureProps = ResourceProps & {
-  source: HTMLVideoElement | null;
+  source: HTMLVideoElement; //  | null;
   colorSpace?: 'srgb';
 };
 export abstract class ExternalTexture extends Resource<ExternalTextureProps> {
   static override defaultProps: Required<ExternalTextureProps> = {
     ...Resource.defaultProps,
-    source: null,
+    source: undefined!,
     colorSpace: 'srgb'
   };
 

package/src/adapter/resources/framebuffer.ts

@@ -6,7 +6,7 @@ import type {
   ColorTextureFormat,
   DepthStencilTextureFormat,
   TextureFormat
-} from '../types/texture-formats';
+} from '../../gpu-type-utils/texture-formats';
 import type {Device} from '../device';
 import {Resource, ResourceProps} from './resource';
 import {Texture} from './texture';
@@ -42,17 +42,14 @@ export abstract class Framebuffer extends Resource<FramebufferProps> {
   /** Height of all attachments in this framebuffer */
   height: number;
   /** Color attachments */
-  colorAttachments: TextureView[] = [];
+  abstract colorAttachments: TextureView[];
   /** Depth-stencil attachment, if provided */
-  depthStencilAttachment: TextureView | null = null;
+  abstract depthStencilAttachment: TextureView | null;
 
   constructor(device: Device, props: FramebufferProps = {}) {
     super(device, props, Framebuffer.defaultProps);
     this.width = this.props.width;
     this.height = this.props.height;
-
-    // NOTE: call from subclass constructor as we cannot call overridden methods here (subclass not yet constructed)
-    // this.autoCreateAttachmentTextures();
   }
 
   /**
@@ -139,7 +136,7 @@ export abstract class Framebuffer extends Resource<FramebufferProps> {
     for (let i = 0; i < this.colorAttachments.length; ++i) {
       if (this.colorAttachments[i]) {
         const resizedTexture = this.device._createTexture({
-          ...this.colorAttachments[i].props,
+          ...this.colorAttachments[i].texture.props,
           width,
           height
         });
@@ -151,7 +148,7 @@ export abstract class Framebuffer extends Resource<FramebufferProps> {
 
     if (this.depthStencilAttachment) {
       const resizedTexture = this.device._createTexture({
-        ...this.depthStencilAttachment.props,
+        ...this.depthStencilAttachment.texture.props,
         width,
         height
       });
@@ -161,87 +158,3 @@ export abstract class Framebuffer extends Resource<FramebufferProps> {
     }
   }
 }
-
-// TODO - remove if not needed
-
-// Create a color attachment for WebGL *
-// protected override createColorTexture(colorAttachment: Required<ColorAttachment>): Required<ColorAttachment> {
-//   return this.device._createTexture({
-//     id: `${this.id}-color`,
-//     data: null, // reserves texture memory, but texels are undefined
-//     format,
-//     // type: GL.UNSIGNED_BYTE,
-//     width: this.width,
-//     height: this.height,
-//     // Note: Mipmapping can be disabled by texture resource when we resize the texture
-//     // to a non-power-of-two dimenstion (NPOT texture) under WebGL1. To have consistant
-//     // behavior we always disable mipmaps.
-//     mipmaps: false,
-//     // Set MIN and MAG filtering parameters so mipmaps are not used in sampling.
-//     // Use LINEAR so subpixel algos like fxaa work.
-//     // Set WRAP modes that support NPOT textures too.
-//     sampler: {
-//       minFilter: 'linear',
-//       magFilter: 'linear',
-//       addressModeU: 'clamp-to-edge',
-//       addressModeV: 'clamp-to-edge'
-//     }
-//     // parameters: {
-//     //   [GL.TEXTURE_MIN_FILTER]: GL.LINEAR,
-//     //   [GL.TEXTURE_MAG_FILTER]: GL.LINEAR,
-//     //   [GL.TEXTURE_WRAP_S]: GL.CLAMP_TO_EDGE,
-//     //   [GL.TEXTURE_WRAP_T]: GL.CLAMP_TO_EDGE
-//     // }
-//   });
-// }
-
-// /** Returns fully populated attachment object. */
-// protected normalizeColorAttachment(
-//   attachment: Texture | ColorTextureFormat
-// ): Required<ColorAttachment> {
-
-//   const COLOR_ATTACHMENT_DEFAULTS: Required<ColorAttachment> = {
-//     texture: undefined!,
-//     format: undefined!,
-//     clearValue: [0.0, 0.0, 0.0, 0.0],
-//     loadOp: 'clear',
-//     storeOp: 'store'
-//   };
-
-//   if (attachment instanceof Texture) {
-//     return {...COLOR_ATTACHMENT_DEFAULTS, texture: attachment};
-//   }
-//   if (typeof attachment === 'string') {
-//     return {...COLOR_ATTACHMENT_DEFAULTS, format: attachment};
-//   }
-//   return {...COLOR_ATTACHMENT_DEFAULTS, ...attachment};
-// }
-
-// /** Wraps texture inside fully populated attachment object. */
-// protected normalizeDepthStencilAttachment(
-//   attachment: DepthStencilAttachment | Texture | DepthStencilTextureFormat
-// ): Required<DepthStencilAttachment> {
-//   const DEPTH_STENCIL_ATTACHMENT_DEFAULTS: Required<DepthStencilAttachment> = {
-//     texture: undefined!,
-//     format: undefined!,
-
-//     depthClearValue: 1.0,
-//     depthLoadOp: 'clear',
-//     depthStoreOp: 'store',
-//     depthReadOnly: false,
-
-//     stencilClearValue: 0,
-//     stencilLoadOp: 'clear',
-//     stencilStoreOp: 'store',
-//     stencilReadOnly: false
-//   };
-
-//   if (typeof attachment === 'string') {
-//     return {...DEPTH_STENCIL_ATTACHMENT_DEFAULTS, format: attachment};
-//   }
-//   // @ts-expect-error attachment instanceof Texture doesn't cover Renderbuffer
-//   if (attachment.handle || attachment instanceof Texture) {
-//     return {...DEPTH_STENCIL_ATTACHMENT_DEFAULTS, texture: attachment as Texture};
-//   }
-//   return {...DEPTH_STENCIL_ATTACHMENT_DEFAULTS, ...attachment};
-// }

package/src/adapter/resources/query-set.ts

@@ -27,8 +27,8 @@ export type QuerySetProps = ResourceProps & {
 export abstract class QuerySet extends Resource<QuerySetProps> {
   static override defaultProps: Required<QuerySetProps> = {
     ...Resource.defaultProps,
-    type: undefined,
-    count: undefined
+    type: undefined!,
+    count: undefined!
   };
 
   get [Symbol.toStringTag](): string {

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

@@ -18,8 +18,14 @@ export type RenderPassProps = ResourceProps & {
   framebuffer?: Framebuffer | null;
   /** Control viewport, scissor rect, blend constant and stencil ref */
   parameters?: RenderPassParameters;
+
+  // TODO - API needs to be able to control multiple render targets
+
   /** Clear value for color attachment, or `load` to preserve the previous value */
   clearColor?: NumberArray | false;
+  /** Whether to disable / discard the output of the rasterizer */
+  discard?: boolean;
+
   /** Clear value for depth attachment, or `load` to preserve the previous value */
   clearDepth?: number | false;
   /** Clear value for stencil attachment, or `load` to preserve the previous value */
@@ -28,8 +34,6 @@ export type RenderPassProps = ResourceProps & {
   depthReadOnly?: boolean;
   /** Indicates that the stencil component is read only. */
   stencilReadOnly?: boolean;
-  /** Whether to disable / discard the output of the rasterizer */
-  discard?: boolean;
 
   /** QuerySet to write begin/end timestamps to */
   occlusionQuerySet?: QuerySet;
@@ -54,7 +58,7 @@ export abstract class RenderPass extends Resource<RenderPassProps> {
   static override defaultProps: Required<RenderPassProps> = {
     ...Resource.defaultProps,
     framebuffer: null,
-    parameters: undefined,
+    parameters: undefined!,
     clearColor: [0, 0, 0, 0],
     clearDepth: 1,
     clearStencil: 0,
@@ -62,10 +66,10 @@ export abstract class RenderPass extends Resource<RenderPassProps> {
     stencilReadOnly: false,
     discard: false,
 
-    occlusionQuerySet: undefined,
-    timestampQuerySet: undefined,
-    beginTimestampIndex: undefined,
-    endTimestampIndex: undefined
+    occlusionQuerySet: undefined!,
+    timestampQuerySet: undefined!,
+    beginTimestampIndex: undefined!,
+    endTimestampIndex: undefined!
   };
 
   override get [Symbol.toStringTag](): string {