@luma.gl/webgl 9.0.0-alpha.35 → 9.0.0-alpha.36

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

@@ -0,0 +1,278 @@
+// luma.gl, MIT license
+
+import type {Device, Buffer, VertexArrayProps, TypedArray, NumberArray} from '@luma.gl/core';
+import {VertexArray, getScratchArray, fillArray} from '@luma.gl/core';
+import {GL} from '@luma.gl/constants';
+import {getBrowser} from '@probe.gl/env';
+
+import {WebGLDevice} from '../webgl-device';
+import {WEBGLBuffer} from '../resources/webgl-buffer';
+
+import {BufferWithAccessor} from '../../classic/buffer-with-accessor';
+import {getGLFromVertexType} from '../converters/vertex-formats';
+// import {AccessorObject} from '../..';
+// import {getGLFromVertexType} from '../converters/vertex-formats';
+
+/** VertexArrayObject wrapper */
+export class WEBGLVertexArray extends VertexArray {
+  override get [Symbol.toStringTag](): string {
+    return 'VertexArray';
+  }
+
+  readonly device: WebGLDevice;
+  readonly handle: WebGLVertexArrayObject;
+
+  /** Attribute 0 buffer constant */
+  private buffer: BufferWithAccessor | null = null;
+  private bufferValue = null;
+
+  /** * Attribute 0 can not be disable on most desktop OpenGL based browsers */
+  static isConstantAttributeZeroSupported(device: Device): boolean {
+    return device.info.type === 'webgl2' || getBrowser() === 'Chrome';
+  }
+
+  // Create a VertexArray
+  constructor(device: WebGLDevice, props?: VertexArrayProps) {
+    super(device, props);
+    this.device = device;
+    this.handle = this.device.gl2.createVertexArray();
+  }
+
+  override destroy(): void {
+    super.destroy();
+    if (this.buffer) {
+      this.buffer?.destroy();
+    }
+    if (this.handle) {
+      this.device.gl2.deleteVertexArray(this.handle);
+      // @ts-expect-error read-only/undefined
+      this.handle = undefined!;
+    }
+
+    // Auto-delete elements?
+    // return [this.elements];
+  }
+
+  /**
+  // Set (bind) an elements buffer, for indexed rendering.
+  // Must be a Buffer bound to GL.ELEMENT_ARRAY_BUFFER. Constants not supported
+   * 
+   * @param elementBuffer 
+   */
+  setIndexBuffer(indexBuffer: Buffer | null): void {
+    const buffer = indexBuffer as WEBGLBuffer;
+    if (buffer && (buffer.glTarget !== GL.ELEMENT_ARRAY_BUFFER)) {
+      throw new Error('Use .setBuffer()');
+    }
+    // In WebGL The GL.ELEMENT_ARRAY_BUFFER_BINDING is stored on the VertexArrayObject
+    this.device.gl2.bindVertexArray(this.handle);
+    // TODO - this initial binding does not seem to take effect? see bindBeforeRender()
+    this.device.gl2.bindBuffer(GL.ELEMENT_ARRAY_BUFFER, buffer ? buffer.handle : null);
+    // log.log(1, 'VertexArray.setIndexBuffer', indexBuffer)();
+    // log.log(1, `Binding vertex array ${this.id}`, buffer?.id)();
+
+    this.indexBuffer = buffer;
+  }
+
+  /** Set a location in vertex attributes array to a buffer, enables the location, sets divisor */
+  setBuffer(location: number, attributeBuffer: Buffer): void {
+    const buffer = attributeBuffer as WEBGLBuffer;
+    // Sanity check target
+    if (buffer.glTarget === GL.ELEMENT_ARRAY_BUFFER) {
+      throw new Error('Use .setIndexBuffer()');
+    }
+
+    const {size, type, stride, offset, normalized, integer, divisor} = this._getAccessor(location);
+
+    this.device.gl2.bindVertexArray(this.handle);
+    // A non-zero buffer object must be bound to the GL_ARRAY_BUFFER target
+    this.device.gl.bindBuffer(GL.ARRAY_BUFFER, buffer.handle);
+
+    // WebGL2 supports *integer* data formats, i.e. GPU will see integer values
+    if (integer) {
+      this.device.assertWebGL2();
+      this.device.gl2.vertexAttribIPointer(location, size, type, stride, offset);
+    } else {
+      // Attaches ARRAY_BUFFER with specified buffer format to location
+      this.device.gl.vertexAttribPointer(location, size, type, normalized, stride, offset);
+    }
+
+    // Mark as non-constant
+    this.device.gl.enableVertexAttribArray(location);
+    // Set the step mode 0=vertex, 1=instance
+    this.device.gl2.vertexAttribDivisor(location, divisor || 0);
+
+    this.attributes[location] = buffer;
+  }
+
+  /** Set a location in vertex attributes array to a constant value, disables the location */
+  override setConstant(location: number, value: TypedArray): void {
+    this._enable(location, false);
+    this.attributes[location] = value;
+  }
+
+  init = false;
+
+  override bindBeforeRender(): void {
+    this.device.gl2.bindVertexArray(this.handle);
+    // TODO - the initial bind does not seem to take effect. 
+    if (!this.init) {
+      // log.log(1, `Binding vertex array ${this.id}`, this.indexBuffer?.id)();
+      const webglBuffer = this.indexBuffer as WEBGLBuffer;
+      this.device.gl2.bindBuffer(GL.ELEMENT_ARRAY_BUFFER, webglBuffer?.handle || null);
+      this.init = true;
+    }
+    this._applyConstantAttributes();
+  }
+
+  override unbindAfterRender(): void {
+    // log.log(1, `Unbinding vertex array ${this.id}`)();
+    // TODO technically this is not necessary, but we might be interfacing 
+    // with code that does not use vertex array objects
+    this.device.gl2.bindVertexArray(null);
+    // this.device.gl2.bindBuffer(GL.ELEMENT_ARRAY_BUFFER, null);
+  }
+
+  // Internal methods
+
+  /**
+   * Constant attributes need to be reset before every draw call
+   * Any attribute that is disabled in the current vertex array object
+   * is read from the context's global constant value for that attribute location.
+   * @note Constant attributes are only supported in WebGL, not in WebGPU
+   */
+  protected _applyConstantAttributes(): void {
+    for (let location = 0; location < this.maxVertexAttributes; ++location) {
+      const constant = this.attributes[location];
+      // A typed array means this is a constant
+      if (ArrayBuffer.isView(constant)) {
+        this.device.setConstantAttribute(location, constant);
+      }
+    }
+  }
+
+  /**
+   * Set a location in vertex attributes array to a buffer, enables the location, sets divisor
+   * @note requires vertex array to be bound
+   */
+  // protected _setAttributeLayout(location: number): void {
+  //   const {size, type, stride, offset, normalized, integer, divisor} = this._getAccessor(location);
+
+  //   // WebGL2 supports *integer* data formats, i.e. GPU will see integer values
+  //   if (integer) {
+  //     this.device.assertWebGL2();
+  //     this.device.gl2.vertexAttribIPointer(location, size, type, stride, offset);
+  //   } else {
+  //     // Attaches ARRAY_BUFFER with specified buffer format to location
+  //     this.device.gl.vertexAttribPointer(location, size, type, normalized, stride, offset);
+  //   }
+  //   this.device.gl2.vertexAttribDivisor(location, divisor || 0);
+  // }
+
+  /** Get an accessor from the  */
+  protected _getAccessor(location: number) {
+    const attributeInfo = this.attributeInfos[location];
+    if (!attributeInfo) {
+      throw new Error(`Unknown attribute location ${location}`);
+    }
+    const glType = getGLFromVertexType(attributeInfo.bufferDataType);
+    return {
+      size: attributeInfo.bufferComponents,
+      type: glType,
+      stride: attributeInfo.byteStride,
+      offset: attributeInfo.byteOffset,
+      normalized: attributeInfo.normalized,
+      // it is the shader attribute declaration, not the vertex memory format,
+      // that determines if the data in the buffer will be treated as integers.
+      //
+      // Also note that WebGL supports assigning non-normalized integer data to floating point attributes,
+      // but as far as we can tell, WebGPU does not.
+      integer: attributeInfo.integer,
+      divisor: attributeInfo.stepMode === 'instance' ? 1 : 0
+    };
+  }
+
+  /**
+   * Enabling an attribute location makes it reference the currently bound buffer
+   * Disabling an attribute location makes it reference the global constant value
+   * TODO - handle single values for size 1 attributes?
+   * TODO - convert classic arrays based on known type?
+   */
+  protected _enable(location: number, enable = true): void {
+    // Attribute 0 cannot be disabled in most desktop OpenGL based browsers...
+    const canDisableAttributeZero = WEBGLVertexArray.isConstantAttributeZeroSupported(this.device);
+    const canDisableAttribute = canDisableAttributeZero || location !== 0;
+
+    if (enable || canDisableAttribute) {
+      location = Number(location);
+      this.device.gl2.bindVertexArray(this.handle);
+      if (enable) {
+        this.device.gl.enableVertexAttribArray(location);
+      } else {
+        this.device.gl.disableVertexAttribArray(location);
+      }
+      this.device.gl2.bindVertexArray(null);
+    }
+  }
+
+  /**
+   * Provide a means to create a buffer that is equivalent to a constant.
+   * NOTE: Desktop OpenGL cannot disable attribute 0.
+   * https://stackoverflow.com/questions/20305231/webgl-warning-attribute-0-is-disabled-
+   * this-has-significant-performance-penalty
+   */
+  getConstantBuffer(elementCount: number, value: TypedArray): Buffer {
+    // Create buffer only when needed, and reuse it (avoids inflating buffer creation statistics)
+
+    const constantValue = normalizeConstantArrayValue(value);
+
+    const byteLength = constantValue.byteLength * elementCount;
+    const length = constantValue.length * elementCount;
+
+    let updateNeeded = !this.buffer;
+
+    this.buffer = this.buffer || (this.device.createBuffer({byteLength}) as BufferWithAccessor);
+    updateNeeded = updateNeeded || this.buffer.reallocate(byteLength);
+
+    // Reallocate and update contents if needed
+    updateNeeded = updateNeeded || !compareConstantArrayValues(constantValue, this.bufferValue);
+
+    if (updateNeeded) {
+      // Create a typed array that is big enough, and fill it with the required data
+      const typedArray = getScratchArray(value.constructor, length);
+      fillArray({target: typedArray, source: constantValue, start: 0, count: length});
+      this.buffer.subData(typedArray);
+      this.bufferValue = value;
+    }
+
+    return this.buffer;
+  }
+}
+
+// HELPER FUNCTIONS
+
+/**
+ * TODO - convert Arrays based on known type? (read type from accessor, don't assume Float32Array)
+ * TODO - handle single values for size 1 attributes?
+ */
+function normalizeConstantArrayValue(arrayValue: NumberArray) {
+  if (Array.isArray(arrayValue)) {
+    return new Float32Array(arrayValue);
+  }
+  return arrayValue;
+}
+
+/**
+ *
+ */
+function compareConstantArrayValues(v1: NumberArray, v2: NumberArray): boolean {
+  if (!v1 || !v2 || v1.length !== v2.length || v1.constructor !== v2.constructor) {
+    return false;
+  }
+  for (let i = 0; i < v1.length; ++i) {
+    if (v1[i] !== v2[i]) {
+      return false;
+    }
+  }
+  return true;
+}

package/src/adapter/webgl-device.ts

@@ -5,12 +5,19 @@ import type {
   DeviceLimits,
   DeviceFeature,
   CanvasContextProps,
-  TextureFormat
+  TextureFormat,
+  VertexArray,
+  VertexArrayProps,
+  TypedArray
 } from '@luma.gl/core';
-import {Device, CanvasContext, log, uid} from '@luma.gl/core';
+import {Device, CanvasContext, log, uid, assert} from '@luma.gl/core';
 import {isBrowser} from '@probe.gl/env';
 import {polyfillContext} from '../context/polyfill/polyfill-context';
-import {popContextState, pushContextState, trackContextState} from '../context/state-tracker/track-context-state';
+import {
+  popContextState,
+  pushContextState,
+  trackContextState
+} from '../context/state-tracker/track-context-state';
 import {createBrowserContext} from '../context/context/create-browser-context';
 import {
   createHeadlessContext,
@@ -59,6 +66,7 @@ import {WEBGLFramebuffer} from './resources/webgl-framebuffer';
 import {WEBGLRenderPass} from './resources/webgl-render-pass';
 import {WEBGLRenderPipeline} from './resources/webgl-render-pipeline';
 import {WEBGLCommandEncoder} from './resources/webgl-command-encoder';
+import {WEBGLVertexArray} from './resources/webgl-vertex-array';
 
 const LOG_LEVEL = 1;
 
@@ -133,7 +141,7 @@ export class WebGLDevice extends Device {
     if (log.get('debug') || props.debug) {
       await loadWebGLDeveloperTools();
     }
-    
+
     // @ts-expect-error spector not on props
     const {spector} = props;
     if (log.get('spector') || spector) {
@@ -167,7 +175,7 @@ export class WebGLDevice extends Device {
     // Create and instrument context
     this.canvasContext = new WebGLCanvasContext(this, props);
 
-    this.lost = new Promise<{reason: 'destroyed'; message: string}>((resolve) => {
+    this.lost = new Promise<{reason: 'destroyed'; message: string}>(resolve => {
       this._resolveContextLost = resolve;
     });
 
@@ -180,7 +188,9 @@ export class WebGLDevice extends Device {
     let gl: WebGLRenderingContext | WebGL2RenderingContext | null = props.gl || null;
     gl =
       gl ||
-      (isBrowser() ? createBrowserContext(this.canvasContext.canvas, {...props, onContextLost}) : null);
+      (isBrowser()
+        ? createBrowserContext(this.canvasContext.canvas, {...props, onContextLost})
+        : null);
     gl = gl || (!isBrowser() ? createHeadlessContext({...props, onContextLost}) : null);
 
     if (!gl) {
@@ -313,6 +323,10 @@ ${this.info.vendor}, ${this.info.renderer} for canvas: ${this.canvasContext.id}`
     return new WEBGLRenderPipeline(this, props);
   }
 
+  override createVertexArray(props: VertexArrayProps): VertexArray {
+    return new WEBGLVertexArray(this, props);
+  }
+
   beginRenderPass(props: RenderPassProps): WEBGLRenderPass {
     return new WEBGLRenderPass(this, props);
   }
@@ -379,7 +393,7 @@ ${this.info.vendor}, ${this.info.renderer} for canvas: ${this.canvasContext.id}`
   private _webglLimits?: WebGLLimits;
 
   /** Return WebGL specific limits */
-  get webglLimits() : WebGLLimits {
+  get webglLimits(): WebGLLimits {
     this._webglLimits = this._webglLimits || getWebGLLimits(this.gl);
     return this._webglLimits;
   }
@@ -413,8 +427,8 @@ ${this.info.vendor}, ${this.info.renderer} for canvas: ${this.canvasContext.id}`
     popContextState(this.gl);
   }
 
-  /** 
-   * Storing data on a special field on WebGLObjects makes that data visible in SPECTOR chrome debug extension 
+  /**
+   * Storing data on a special field on WebGLObjects makes that data visible in SPECTOR chrome debug extension
    * luma.gl ids and props can be inspected
    */
   setSpectorMetadata(handle: unknown, props: Record<string, unknown>) {
@@ -423,13 +437,13 @@ ${this.info.vendor}, ${this.info.renderer} for canvas: ${this.canvasContext.id}`
     handle.__SPECTOR_Metadata = props;
   }
 
-  /** 
+  /**
    * Returns the GL.<KEY> constant that corresponds to a numeric value of a GL constant
    * Be aware that there are some duplicates especially for constants that are 0,
    * so this isn't guaranteed to return the right key in all cases.
    */
   getGLKey(value: unknown, gl?: WebGLRenderingContext): string {
-    // @ts-ignore expect-error depends on settings 
+    // @ts-ignore expect-error depends on settings
     gl = gl || this.gl2 || this.gl;
     const number = Number(value);
     for (const key in gl) {
@@ -441,6 +455,38 @@ ${this.info.vendor}, ${this.info.renderer} for canvas: ${this.canvasContext.id}`
     // No constant found. Stringify the value and return it.
     return String(value);
   }
+
+  /** Store constants */
+  _constants: (TypedArray | null)[];
+
+  /**
+   * Set a constant value for a location. Disabled attributes at that location will read from this value
+   * @note WebGL constants are stored globally on the WebGL context, not the VertexArray
+   * so they need to be updated before every render
+   * @todo - remember/cache values to avoid setting them unnecessarily?
+   */
+  setConstantAttribute(location: number, constant: TypedArray): void {
+    this._constants = this._constants || new Array(this.limits.maxVertexAttributes).fill(null);
+    const currentConstant = this._constants[location];
+    if (currentConstant && compareConstantArrayValues(currentConstant, constant)) {
+      log.info(1, `setConstantAttribute(${location}) could have been skipped, value unchanged`)();
+    }
+    this._constants[location] = constant;
+
+    switch (constant.constructor) {
+      case Float32Array:
+        setConstantFloatArray(this, location, constant as Float32Array);
+        break;
+      case Int32Array:
+        setConstantIntArray(this, location, constant as Int32Array);
+        break;
+      case Uint32Array:
+        setConstantUintArray(this, location, constant as Uint32Array);
+        break;
+      default:
+        assert(false);
+    }
+  }
 }
 
 /** Check if supplied parameter is a WebGLRenderingContext */
@@ -463,3 +509,83 @@ function isWebGL2(gl: any): boolean {
   // Look for debug contexts, headless gl etc
   return Boolean(gl && gl._version === 2);
 }
+
+/** Set constant float array attribute */
+function setConstantFloatArray(device: WebGLDevice, location: number, array: Float32Array): void {
+  switch (array.length) {
+    case 1:
+      device.gl.vertexAttrib1fv(location, array);
+      break;
+    case 2:
+      device.gl.vertexAttrib2fv(location, array);
+      break;
+    case 3:
+      device.gl.vertexAttrib3fv(location, array);
+      break;
+    case 4:
+      device.gl.vertexAttrib4fv(location, array);
+      break;
+    default:
+      assert(false);
+  }
+}
+
+/** Set constant signed int array attribute */
+function setConstantIntArray(device: WebGLDevice, location: number, array: Int32Array): void {
+  device.assertWebGL2();
+  device.gl2?.vertexAttribI4iv(location, array);
+  // TODO - not clear if we need to use the special forms, more testing needed
+  // switch (array.length) {
+  //   case 1:
+  //     gl.vertexAttribI1iv(location, array);
+  //     break;
+  //   case 2:
+  //     gl.vertexAttribI2iv(location, array);
+  //     break;
+  //   case 3:
+  //     gl.vertexAttribI3iv(location, array);
+  //     break;
+  //   case 4:
+  //     break;
+  //   default:
+  //     assert(false);
+  // }
+}
+
+/** Set constant unsigned int array attribute */
+function setConstantUintArray(device: WebGLDevice, location: number, array: Uint32Array) {
+  device.assertWebGL2();
+  device.gl2?.vertexAttribI4uiv(location, array);
+  // TODO - not clear if we need to use the special forms, more testing needed
+  // switch (array.length) {
+  //   case 1:
+  //     gl.vertexAttribI1uiv(location, array);
+  //     break;
+  //   case 2:
+  //     gl.vertexAttribI2uiv(location, array);
+  //     break;
+  //   case 3:
+  //     gl.vertexAttribI3uiv(location, array);
+  //     break;
+  //   case 4:
+  //     gl.vertexAttribI4uiv(location, array);
+  //     break;
+  //   default:
+  //     assert(false);
+  // }
+}
+
+/**
+ *
+ */
+function compareConstantArrayValues(v1: TypedArray, v2: TypedArray): boolean {
+  if (!v1 || !v2 || v1.length !== v2.length || v1.constructor !== v2.constructor) {
+    return false;
+  }
+  for (let i = 0; i < v1.length; ++i) {
+    if (v1[i] !== v2[i]) {
+      return false;
+    }
+  }
+  return true;
+}

package/src/classic/clear.ts

@@ -1,6 +1,6 @@
 import {Device, Framebuffer, assert} from '@luma.gl/core';
 import {WebGLDevice} from '../adapter/webgl-device';
-import {withParameters} from '../context/state-tracker/with-parameters';
+import {withGLParameters} from '../context/state-tracker/with-parameters';
 
 // Should collapse during minification
 const GL_DEPTH_BUFFER_BIT = 0x00000100;
@@ -57,7 +57,7 @@ export function clear(
   assert(clearFlags !== 0, ERR_ARGUMENTS);
 
   // Temporarily set any clear "colors" and call clear
-  withParameters(device.gl, parameters, () => {
+  withGLParameters(device.gl, parameters, () => {
     device.gl.clear(clearFlags);
   });
 }
@@ -73,7 +73,7 @@ export function clearBuffer(
   const device = WebGLDevice.attach(gl);
 
   const {framebuffer = null, buffer = GL_COLOR, drawBuffer = 0, value = [0, 0, 0, 0]} = options || {};
-  withParameters(device.gl2, {framebuffer}, () => {
+  withGLParameters(device.gl2, {framebuffer}, () => {
     // Method selection per OpenGL ES 3 docs
     switch (buffer) {
       case GL_COLOR:

package/src/classic/copy-and-blit.ts

@@ -3,9 +3,9 @@ import {assert, Texture, Framebuffer, FramebufferProps} from '@luma.gl/core';
 import {GL} from '@luma.gl/constants';
 
 import {BufferWithAccessor as Buffer} from './buffer-with-accessor';
-import {WEBGLTexture}  from  '../adapter/resources/webgl-texture';
+import {WEBGLTexture} from '../adapter/resources/webgl-texture';
 import {WEBGLFramebuffer} from '../adapter/resources/webgl-framebuffer';
-import {withParameters} from '../context/state-tracker/with-parameters';
+import {withGLParameters} from '../context/state-tracker/with-parameters';
 import {getGLTypeFromTypedArray, getTypedArrayFromGLType} from './typed-array-utils';
 import {glFormatToComponents, glTypeToBytes} from './format-utils';
 
@@ -34,9 +34,13 @@ export function readPixelsToArray(
     sourceType?: number;
   }
 ): Uint8Array | Uint16Array | Float32Array {
-  const {sourceX = 0, sourceY = 0, sourceFormat = GL.RGBA} = options || {};
+  const {
+    sourceX = 0,
+    sourceY = 0,
+    sourceFormat = GL.RGBA,
+    sourceAttachment = GL.COLOR_ATTACHMENT0 // TODO - support gl.readBuffer
+  } = options || {};
   let {
-    sourceAttachment = GL.COLOR_ATTACHMENT0, // TODO - support gl.readBuffer
     target = null,
     // following parameters are auto deduced if not provided
     sourceWidth,
@@ -51,15 +55,18 @@ export function readPixelsToArray(
   sourceHeight = sourceHeight || framebuffer.height;
 
   // TODO - Set and unset gl.readBuffer
-  if (sourceAttachment === GL.COLOR_ATTACHMENT0 && handle === null) {
-    sourceAttachment = GL.FRONT;
-  }
+  // if (sourceAttachment === GL.COLOR_ATTACHMENT0 && handle === null) {
+  //   sourceAttachment = GL.FRONT;
+  // }
 
   const attachment = sourceAttachment - GL.COLOR_ATTACHMENT0;
   // assert(attachments[sourceAttachment]);
 
   // Deduce the type from color attachment if not provided.
-  sourceType = sourceType || (framebuffer.colorAttachments[attachment] as WEBGLTexture).type;
+  sourceType =
+    sourceType ||
+    (framebuffer.colorAttachments[attachment] as WEBGLTexture)?.type ||
+    GL.UNSIGNED_BYTE;
 
   // Deduce type and allocated pixelArray if needed
   target = getPixelArray(target, sourceType, sourceFormat, sourceWidth, sourceHeight);
@@ -122,7 +129,7 @@ export function readPixelsToBuffer(
   }
 
   target.bind({glTarget: GL.PIXEL_PACK_BUFFER});
-  withParameters(gl2, {framebuffer}, () => {
+  withGLParameters(gl2, {framebuffer}, () => {
     gl2.readPixels(
       sourceX,
       sourceY,
@@ -253,7 +260,7 @@ export function copyToTexture(
     texture.unbind();
   }
   // @ts-expect-error
-  gl.bindFramebuffer(GL.FRAMEBUFFER, prevHandle || null);
+  device.gl.bindFramebuffer(GL.FRAMEBUFFER, prevHandle || null);
   if (deleteFramebuffer) {
     framebuffer.destroy();
   }
@@ -281,11 +288,8 @@ export function toFramebuffer(texture: Texture, props?: FramebufferProps): Frame
     id: `framebuffer-for-${id}`,
     width,
     height,
-    colorAttachments: [
-      texture
-    ]
-  }
-  );
+    colorAttachments: [texture]
+  });
   return framebuffer;
 }
 

package/src/context/context/create-browser-context.ts

@@ -69,6 +69,8 @@ export function createBrowserContext(
     props = {...props, webgl2: false};
   }
 
+  // props.failIfMajorPerformanceCaveat = true;
+
   // Prefer webgl2 over webgl1 if both are acceptable
   if (!gl && props.webgl2) {
     gl = canvas.getContext('webgl2', props) as WebGL2RenderingContext;
@@ -77,6 +79,16 @@ export function createBrowserContext(
     gl = canvas.getContext('webgl', props) as WebGLRenderingContext;
   }
 
+  // Software GPU
+
+  // props.failIfMajorPerformanceCaveat = false;
+  // if (!gl && props.webgl2) {
+  //   gl = canvas.getContext('webgl2', props);
+  // }
+  // if (!gl && props.webgl1) {
+  //   gl = canvas.getContext('webgl', props);
+  // }
+
   // TODO are we removing this listener before giving it a chance to fire?
   canvas.removeEventListener('webglcontextcreationerror', onCreateError, false);
 

package/src/context/parameters/unified-parameter-api.ts

@@ -20,7 +20,7 @@ export type {GLParameters};
  * @note requires a `cache` object to be set on the context (gl.state.cache)
  * This object is used to fill in any missing values for composite setter functions
  */
-export function setParameters(
+export function setGLParameters(
   device: Device | WebGLRenderingContext,
   parameters: GLParameters
 ): void {
@@ -88,7 +88,7 @@ export function setParameters(
  * considered a very slow operation, to be used only if/when a context already manipulated
  * by external code needs to be synchronized for the first time
  */
-export function getParameters(
+export function getGLParameters(
   device: Device | WebGLRenderingContext,
   parameters: keyof GLParameters | (keyof GLParameters)[] | GLParameters = GL_PARAMETER_DEFAULTS
 ): GLParameters {
@@ -120,8 +120,8 @@ export function getParameters(
  * NOT the canvas size dimensions, so they will have to be properly set after
  * calling this function.
  */
-export function resetParameters(device: Device | WebGLRenderingContext): void {
-  setParameters(device, GL_PARAMETER_DEFAULTS);
+export function resetGLParameters(device: Device | WebGLRenderingContext): void {
+  setGLParameters(device, GL_PARAMETER_DEFAULTS);
 }
 
 // Helpers