@luma.gl/webgl 9.0.0-beta.4 → 9.0.0-beta.6

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

@@ -1,4 +1,5 @@
-// luma.gl, MIT license
+// luma.gl
+// SPDX-License-Identifier: MIT
 // Copyright (c) vis.gl contributors
 
 // Texture class.
@@ -14,7 +15,7 @@ import {
   SamplerParameters,
   TypedArray
 } from '@luma.gl/core';
-import {Texture, log, assert, isPowerOfTwo, loadImage, isObjectEmpty} from '@luma.gl/core';
+import {Texture, log, assert, loadImage, isObjectEmpty} from '@luma.gl/core';
 import {GL, GLSamplerParameters} from '@luma.gl/constants';
 import {withGLParameters} from '../../context/state-tracker/with-parameters';
 import {
@@ -22,13 +23,11 @@ import {
   getWebGLTextureParameters,
   getTextureFormatBytesPerPixel
 } from '../converters/texture-formats';
-import {
-  convertSamplerParametersToWebGL,
-  updateSamplerParametersForNPOT
-} from '../converters/sampler-parameters';
+import {convertSamplerParametersToWebGL} from '../converters/sampler-parameters';
 import {WebGLDevice} from '../webgl-device';
 import {WEBGLBuffer} from './webgl-buffer';
 import {WEBGLSampler} from './webgl-sampler';
+import {WEBGLTextureView} from './webgl-texture-view';
 
 export type WEBGLTextureProps = TextureProps & {
   /** @deprecated use props.sampler */
@@ -151,13 +150,14 @@ export class WEBGLTexture extends Texture<WEBGLTextureProps> {
 
   readonly MAX_ATTRIBUTES: number;
   readonly device: WebGLDevice;
-  readonly gl: WebGLRenderingContext;
-  readonly gl2: WebGL2RenderingContext | null;
+  readonly gl: WebGL2RenderingContext;
   readonly handle: WebGLTexture;
 
-  /** Sampler object (currently unused) */
+  // (TODO - currently unused in WebGL, but WebGL 2 does support sampler objects) */
   sampler: WEBGLSampler = undefined;
 
+  view: WEBGLTextureView = undefined;
+
   // data;
 
   glFormat: GL = undefined;
@@ -194,7 +194,6 @@ export class WEBGLTexture extends Texture<WEBGLTextureProps> {
 
     this.device = device as WebGLDevice;
     this.gl = this.device.gl;
-    this.gl2 = this.device.gl2;
     this.handle = this.props.handle || this.gl.createTexture();
     this.device.setSpectorMetadata(this.handle, {...this.props, data: typeof this.props.data}); // {name: this.props.id};
 
@@ -260,7 +259,7 @@ export class WEBGLTexture extends Texture<WEBGLTextureProps> {
 
     const {parameters = {} as Record<GL, any>} = props;
 
-    const {pixels = null, pixelStore = {}, textureUnit = undefined} = props;
+    const {pixels = null, pixelStore = {}, textureUnit = undefined, mipmaps = true} = props;
 
     // pixels variable is for API compatibility purpose
     if (!data) {
@@ -270,10 +269,10 @@ export class WEBGLTexture extends Texture<WEBGLTextureProps> {
       data = pixels;
     }
 
-    let {width, height, dataFormat, type, compressed = false, mipmaps = true} = props;
+    let {width, height, dataFormat, type, compressed = false} = props;
     const {depth = 0} = props;
 
-    const glFormat = convertTextureFormatToGL(props.format, this.device.isWebGL2);
+    const glFormat = convertTextureFormatToGL(props.format);
 
     // Deduce width and height
     ({width, height, compressed, dataFormat, type} = this._deduceParameters({
@@ -300,11 +299,6 @@ export class WEBGLTexture extends Texture<WEBGLTextureProps> {
       this.gl.bindTexture(this.target, this.handle);
     }
 
-    if (mipmaps && this.device.isWebGL1 && isNPOT(this.width, this.height)) {
-      log.warn(`texture: ${this} is Non-Power-Of-Two, disabling mipmaps`)();
-      mipmaps = false;
-    }
-
     this.mipmaps = mipmaps;
 
     this.setImageData({
@@ -324,6 +318,9 @@ export class WEBGLTexture extends Texture<WEBGLTextureProps> {
     this.setSampler(props.sampler);
     this._setSamplerParameters(parameters);
 
+    // @ts-ignore
+    this.view = new WEBGLTextureView(this.device, {...this.props, texture: this});
+
     if (mipmaps) {
       this.generateMipmap();
     }
@@ -372,7 +369,6 @@ export class WEBGLTexture extends Texture<WEBGLTextureProps> {
       samplerProps = sampler as SamplerProps;
     }
 
-    // TODO - technically, this is only needed in WebGL1. In WebGL2 we could always use the sampler.
     const parameters = convertSamplerParametersToWebGL(samplerProps);
     this._setSamplerParameters(parameters);
     return this;
@@ -418,11 +414,6 @@ export class WEBGLTexture extends Texture<WEBGLTextureProps> {
 
   // Call to regenerate mipmaps after modifying texture(s)
   generateMipmap(params = {}): this {
-    if (this.device.isWebGL1 && isNPOT(this.width, this.height)) {
-      log.warn(`texture: ${this} is Non-Power-Of-Two, disabling mipmaping`)();
-      return this;
-    }
-
     this.mipmaps = true;
 
     this.gl.bindTexture(this.target, this.handle);
@@ -500,8 +491,6 @@ export class WEBGLTexture extends Texture<WEBGLTextureProps> {
     let dataType = null;
     ({data, dataType} = this._getDataType({data, compressed}));
 
-    let gl2;
-
     withGLParameters(this.gl, parameters, () => {
       switch (dataType) {
         case 'null':
@@ -518,8 +507,6 @@ export class WEBGLTexture extends Texture<WEBGLTextureProps> {
           );
           break;
         case 'typed-array':
-          // Looks like this assert is not necessary, as offset is ignored under WebGL1
-          // assert((offset === 0 || this.device.isWebGL2), 'offset supported in WebGL2 only');
           gl.texImage2D(
             target,
             level,
@@ -530,15 +517,13 @@ export class WEBGLTexture extends Texture<WEBGLTextureProps> {
             dataFormat,
             type,
             data,
-            // @ts-expect-error
             offset
           );
           break;
         case 'buffer':
           // WebGL2 enables creating textures directly from a WebGL buffer
-          gl2 = this.device.assertWebGL2();
-          gl2.bindBuffer(GL.PIXEL_UNPACK_BUFFER, data.handle || data);
-          gl2.texImage2D(
+          this.device.gl.bindBuffer(GL.PIXEL_UNPACK_BUFFER, data.handle || data);
+          this.device.gl.texImage2D(
             target,
             level,
             glFormat,
@@ -549,24 +534,20 @@ export class WEBGLTexture extends Texture<WEBGLTextureProps> {
             type,
             offset
           );
-          gl2.bindBuffer(GL.PIXEL_UNPACK_BUFFER, null);
+          this.device.gl.bindBuffer(GL.PIXEL_UNPACK_BUFFER, null);
           break;
         case 'browser-object':
-          if (this.device.isWebGL2) {
-            gl.texImage2D(
-              target,
-              level,
-              glFormat,
-              width,
-              height,
-              0 /* border*/,
-              dataFormat,
-              type,
-              data
-            );
-          } else {
-            gl.texImage2D(target, level, glFormat, dataFormat, type, data);
-          }
+          gl.texImage2D(
+            target,
+            level,
+            glFormat,
+            width,
+            height,
+            0 /* border*/,
+            dataFormat,
+            type,
+            data
+          );
           break;
         case 'compressed':
           for (const [levelIndex, levelData] of data.entries()) {
@@ -590,7 +571,7 @@ export class WEBGLTexture extends Texture<WEBGLTextureProps> {
     if (data && data.byteLength) {
       this.trackAllocatedMemory(data.byteLength, 'Texture');
     } else {
-      const bytesPerPixel = getTextureFormatBytesPerPixel(this.props.format, this.device.isWebGL2);
+      const bytesPerPixel = getTextureFormatBytesPerPixel(this.props.format);
       this.trackAllocatedMemory(this.width * this.height * bytesPerPixel, 'Texture');
     }
 
@@ -659,22 +640,16 @@ export class WEBGLTexture extends Texture<WEBGLTextureProps> {
       } else if (data === null) {
         this.gl.texSubImage2D(target, level, x, y, width, height, dataFormat, type, null);
       } else if (ArrayBuffer.isView(data)) {
-        // const gl2 = this.device.assertWebGL2();
-        // @ts-expect-error last offset parameter is ignored under WebGL1
         this.gl.texSubImage2D(target, level, x, y, width, height, dataFormat, type, data, offset);
       } else if (typeof WebGLBuffer !== 'undefined' && data instanceof WebGLBuffer) {
         // WebGL2 allows us to create texture directly from a WebGL buffer
-        const gl2 = this.device.assertWebGL2();
         // This texImage2D signature uses currently bound GL.PIXEL_UNPACK_BUFFER
-        gl2.bindBuffer(GL.PIXEL_UNPACK_BUFFER, data);
-        gl2.texSubImage2D(target, level, x, y, width, height, dataFormat, type, offset);
-        gl2.bindBuffer(GL.PIXEL_UNPACK_BUFFER, null);
-      } else if (this.device.isWebGL2) {
-        // Assume data is a browser supported object (ImageData, Canvas, ...)
-        const gl2 = this.device.assertWebGL2();
-        gl2.texSubImage2D(target, level, x, y, width, height, dataFormat, type, data);
+        this.device.gl.bindBuffer(GL.PIXEL_UNPACK_BUFFER, data);
+        this.device.gl.texSubImage2D(target, level, x, y, width, height, dataFormat, type, offset);
+        this.device.gl.bindBuffer(GL.PIXEL_UNPACK_BUFFER, null);
       } else {
-        this.gl.texSubImage2D(target, level, x, y, dataFormat, type, data);
+        // Assume data is a browser supported object (ImageData, Canvas, ...)
+        this.device.gl.texSubImage2D(target, level, x, y, width, height, dataFormat, type, data);
       }
     });
 
@@ -754,7 +729,7 @@ export class WEBGLTexture extends Texture<WEBGLTextureProps> {
     let {width, height, dataFormat, type, compressed} = opts;
 
     // Deduce format and type from format
-    const parameters = getWebGLTextureParameters(format, this.device.isWebGL2);
+    const parameters = getWebGLTextureParameters(format);
     dataFormat = dataFormat || parameters.dataFormat;
     type = type || parameters.type;
     compressed = compressed || parameters.compressed;
@@ -910,11 +885,10 @@ export class WEBGLTexture extends Texture<WEBGLTextureProps> {
 
     this.gl.bindTexture(this.target, this.handle);
 
-    const webglTextureFormat = getWebGLTextureParameters(format, this.device.isWebGL2);
+    const webglTextureFormat = getWebGLTextureParameters(format);
 
     withGLParameters(this.gl, parameters, () => {
       if (ArrayBuffer.isView(data)) {
-        // @ts-expect-error
         this.gl.texImage3D(
           this.target,
           level,
@@ -931,7 +905,6 @@ export class WEBGLTexture extends Texture<WEBGLTextureProps> {
 
       if (data instanceof WEBGLBuffer) {
         this.gl.bindBuffer(GL.PIXEL_UNPACK_BUFFER, data.handle);
-        // @ts-expect-error
         this.gl.texImage3D(
           this.target,
           level,
@@ -950,7 +923,7 @@ export class WEBGLTexture extends Texture<WEBGLTextureProps> {
     if (data && data.byteLength) {
       this.trackAllocatedMemory(data.byteLength, 'Texture');
     } else {
-      const bytesPerPixel = getTextureFormatBytesPerPixel(this.props.format, this.device.isWebGL2);
+      const bytesPerPixel = getTextureFormatBytesPerPixel(this.props.format);
       this.trackAllocatedMemory(this.width * this.height * this.depth * bytesPerPixel, 'Texture');
     }
 
@@ -963,14 +936,8 @@ export class WEBGLTexture extends Texture<WEBGLTextureProps> {
 
   /**
    * Sets sampler parameters on texture
-   * @note: Applies NPOT workaround if appropriate
    */
   _setSamplerParameters(parameters: GLSamplerParameters): void {
-    // Work around WebGL1 sampling restrictions on NPOT textures
-    if (this.device.isWebGL1 && isNPOT(this.width, this.height)) {
-      parameters = updateSamplerParametersForNPOT(parameters);
-    }
-
     // NPOT parameters may populate an empty object
     if (isObjectEmpty(parameters)) {
       return;
@@ -999,32 +966,6 @@ export class WEBGLTexture extends Texture<WEBGLTextureProps> {
     this.gl.bindTexture(this.target, null);
     return;
   }
-
-  /** @deprecated For LegacyTexture subclass */
-  protected _getWebGL1NPOTParameterOverride(
-    pname: GL.TEXTURE_MIN_FILTER | GL.TEXTURE_WRAP_S | GL.TEXTURE_WRAP_T,
-    value: GL.LINEAR | GL.NEAREST
-  ): number {
-    // NOTE: Apply NPOT workaround
-    const npot = this.device.isWebGL1 && isNPOT(this.width, this.height);
-    if (npot) {
-      switch (pname) {
-        case GL.TEXTURE_MIN_FILTER:
-          if (value !== GL.LINEAR && value !== GL.NEAREST) {
-            // log.warn(`texture: ${this} is Non-Power-Of-Two, forcing TEXTURE_MIN_FILTER to LINEAR`)();
-            return GL.LINEAR;
-          }
-          break;
-        case GL.TEXTURE_WRAP_S:
-        case GL.TEXTURE_WRAP_T:
-          // if (value !== GL.CLAMP_TO_EDGE) { log.warn(`texture: ${this} is Non-Power-Of-Two, ${getKey(this.gl, pname)} to CLAMP_TO_EDGE`)(); }
-          return GL.CLAMP_TO_EDGE;
-        default:
-          break;
-      }
-    }
-    return value;
-  }
 }
 
 // HELPERS
@@ -1049,14 +990,6 @@ function getWebGLTextureTarget(props: TextureProps) {
   }
 }
 
-function isNPOT(width: number, height: number): boolean {
-  // Width and height not available, avoid classifying as NPOT texture
-  if (!width || !height) {
-    return false;
-  }
-  return !isPowerOfTwo(width) || !isPowerOfTwo(height);
-}
-
 function logParameters(parameters: Record<number, GL | number>) {
   log.log(1, 'texture sampler parameters', parameters)();
 }

package/src/adapter/resources/webgl-transform-feedback.ts

@@ -2,12 +2,12 @@ import type {PrimitiveTopology, ShaderLayout, TransformFeedbackProps} from '@lum
 import {log, TransformFeedback, Buffer, BufferRange} from '@luma.gl/core';
 import {GL} from '@luma.gl/constants';
 import {WebGLDevice} from '../webgl-device';
-import {WEBGLBuffer} from '../..';
+import {WEBGLBuffer} from '../../index';
 import {getGLPrimitive} from '../helpers/webgl-topology-utils';
 
 export class WEBGLTransformFeedback extends TransformFeedback {
   readonly device: WebGLDevice;
-  readonly gl2: WebGL2RenderingContext;
+  readonly gl: WebGL2RenderingContext;
   readonly handle: WebGLTransformFeedback;
 
   /**
@@ -29,10 +29,9 @@ export class WEBGLTransformFeedback extends TransformFeedback {
   constructor(device: WebGLDevice, props: TransformFeedbackProps) {
     super(device, props);
 
-    device.assertWebGL2();
     this.device = device;
-    this.gl2 = device.gl2;
-    this.handle = this.props.handle || this.gl2.createTransformFeedback();
+    this.gl = device.gl;
+    this.handle = this.props.handle || this.gl.createTransformFeedback();
     this.layout = this.props.layout;
 
     if (props.buffers) {
@@ -43,24 +42,24 @@ export class WEBGLTransformFeedback extends TransformFeedback {
   }
 
   override destroy(): void {
-    this.gl2.deleteTransformFeedback(this.handle);
+    this.gl.deleteTransformFeedback(this.handle);
     super.destroy();
   }
 
   begin(topology: PrimitiveTopology = 'point-list'): void {
-    this.gl2.bindTransformFeedback(GL.TRANSFORM_FEEDBACK, this.handle);
+    this.gl.bindTransformFeedback(GL.TRANSFORM_FEEDBACK, this.handle);
     if (this.bindOnUse) {
       this._bindBuffers();
     }
-    this.gl2.beginTransformFeedback(getGLPrimitive(topology));
+    this.gl.beginTransformFeedback(getGLPrimitive(topology));
   }
 
   end(): void {
-    this.gl2.endTransformFeedback();
+    this.gl.endTransformFeedback();
     if (!this.bindOnUse) {
       this._unbindBuffers();
     }
-    this.gl2.bindTransformFeedback(GL.TRANSFORM_FEEDBACK, null);
+    this.gl.bindTransformFeedback(GL.TRANSFORM_FEEDBACK, null);
   }
 
   // SUBCLASS
@@ -105,18 +104,18 @@ export class WEBGLTransformFeedback extends TransformFeedback {
 
   bind(funcOrHandle = this.handle) {
     if (typeof funcOrHandle !== 'function') {
-      this.gl2.bindTransformFeedback(GL.TRANSFORM_FEEDBACK, funcOrHandle);
+      this.gl.bindTransformFeedback(GL.TRANSFORM_FEEDBACK, funcOrHandle);
       return this;
     }
 
     let value: unknown;
 
     if (!this._bound) {
-      this.gl2.bindTransformFeedback(GL.TRANSFORM_FEEDBACK, this.handle);
+      this.gl.bindTransformFeedback(GL.TRANSFORM_FEEDBACK, this.handle);
       this._bound = true;
       value = funcOrHandle();
       this._bound = false;
-      this.gl2.bindTransformFeedback(GL.TRANSFORM_FEEDBACK, null);
+      this.gl.bindTransformFeedback(GL.TRANSFORM_FEEDBACK, null);
     } else {
       value = funcOrHandle();
     }
@@ -171,21 +170,16 @@ export class WEBGLTransformFeedback extends TransformFeedback {
 
   protected _unbindBuffers(): void {
     for (const bufferIndex in this.buffers) {
-      this.gl2.bindBufferBase(GL.TRANSFORM_FEEDBACK_BUFFER, Number(bufferIndex), null);
+      this.gl.bindBufferBase(GL.TRANSFORM_FEEDBACK_BUFFER, Number(bufferIndex), null);
     }
   }
 
-  protected _bindBuffer(
-    index: number,
-    buffer: Buffer,
-    byteOffset = 0,
-    byteLength?: number
-  ): void {
+  protected _bindBuffer(index: number, buffer: Buffer, byteOffset = 0, byteLength?: number): void {
     const handle = buffer && (buffer as WEBGLBuffer).handle;
     if (!handle || byteLength === undefined) {
-      this.gl2.bindBufferBase(GL.TRANSFORM_FEEDBACK_BUFFER, index, handle);
+      this.gl.bindBufferBase(GL.TRANSFORM_FEEDBACK_BUFFER, index, handle);
     } else {
-      this.gl2.bindBufferRange(GL.TRANSFORM_FEEDBACK_BUFFER, index, handle, byteOffset, byteLength);
+      this.gl.bindBufferRange(GL.TRANSFORM_FEEDBACK_BUFFER, index, handle, byteOffset, byteLength);
     }
   }
 }

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

@@ -1,4 +1,5 @@
-// luma.gl, MIT license
+// luma.gl
+// SPDX-License-Identifier: MIT
 // Copyright (c) vis.gl contributors
 
 import type {Device, Buffer, VertexArrayProps, TypedArray, NumberArray} from '@luma.gl/core';
@@ -28,14 +29,14 @@ export class WEBGLVertexArray extends VertexArray {
 
   /** * Attribute 0 can not be disable on most desktop OpenGL based browsers */
   static isConstantAttributeZeroSupported(device: Device): boolean {
-    return device.info.type === 'webgl2' || getBrowser() === 'Chrome';
+    return getBrowser() === 'Chrome';
   }
 
   // Create a VertexArray
   constructor(device: WebGLDevice, props?: VertexArrayProps) {
     super(device, props);
     this.device = device;
-    this.handle = this.device.gl2.createVertexArray();
+    this.handle = this.device.gl.createVertexArray();
   }
 
   override destroy(): void {
@@ -44,7 +45,7 @@ export class WEBGLVertexArray extends VertexArray {
       this.buffer?.destroy();
     }
     if (this.handle) {
-      this.device.gl2.deleteVertexArray(this.handle);
+      this.device.gl.deleteVertexArray(this.handle);
       // @ts-expect-error read-only/undefined
       this.handle = undefined!;
     }
@@ -66,9 +67,9 @@ export class WEBGLVertexArray extends VertexArray {
       throw new Error('Use .setBuffer()');
     }
     // In WebGL The GL.ELEMENT_ARRAY_BUFFER_BINDING is stored on the VertexArrayObject
-    this.device.gl2.bindVertexArray(this.handle);
+    this.device.gl.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);
+    this.device.gl.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)();
 
@@ -85,14 +86,13 @@ export class WEBGLVertexArray extends VertexArray {
 
     const {size, type, stride, offset, normalized, integer, divisor} = this._getAccessor(location);
 
-    this.device.gl2.bindVertexArray(this.handle);
+    this.device.gl.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);
+      this.device.gl.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);
@@ -101,13 +101,13 @@ export class WEBGLVertexArray extends VertexArray {
     // 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.device.gl.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 {
+  override setConstantWebGL(location: number, value: TypedArray): void {
     this._enable(location, false);
     this.attributes[location] = value;
   }
@@ -115,12 +115,12 @@ export class WEBGLVertexArray extends VertexArray {
   init = false;
 
   override bindBeforeRender(): void {
-    this.device.gl2.bindVertexArray(this.handle);
+    this.device.gl.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.device.gl.bindBuffer(GL.ELEMENT_ARRAY_BUFFER, webglBuffer?.handle || null);
       this.init = true;
     }
     this._applyConstantAttributes();
@@ -130,8 +130,8 @@ export class WEBGLVertexArray extends VertexArray {
     // 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);
+    this.device.gl.bindVertexArray(null);
+    // this.device.gl.bindBuffer(GL.ELEMENT_ARRAY_BUFFER, null);
   }
 
   // Internal methods
@@ -147,7 +147,7 @@ export class WEBGLVertexArray extends VertexArray {
       const constant = this.attributes[location];
       // A typed array means this is a constant
       if (ArrayBuffer.isView(constant)) {
-        this.device.setConstantAttribute(location, constant);
+        this.device.setConstantAttributeWebGL(location, constant);
       }
     }
   }
@@ -161,13 +161,12 @@ export class WEBGLVertexArray extends VertexArray {
 
   //   // 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);
+  //     this.device.gl.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);
+  //   this.device.gl.vertexAttribDivisor(location, divisor || 0);
   // }
 
   /** Get an accessor from the  */
@@ -206,13 +205,13 @@ export class WEBGLVertexArray extends VertexArray {
 
     if (enable || canDisableAttribute) {
       location = Number(location);
-      this.device.gl2.bindVertexArray(this.handle);
+      this.device.gl.bindVertexArray(this.handle);
       if (enable) {
         this.device.gl.enableVertexAttribArray(location);
       } else {
         this.device.gl.disableVertexAttribArray(location);
       }
-      this.device.gl2.bindVertexArray(null);
+      this.device.gl.bindVertexArray(null);
     }
   }
 

package/src/adapter/webgl-canvas-context.ts

@@ -1,4 +1,5 @@
-// luma.gl, MIT license
+// luma.gl
+// SPDX-License-Identifier: MIT
 // Copyright (c) vis.gl contributors
 
 import type {CanvasContextProps} from '@luma.gl/core';
@@ -6,8 +7,8 @@ import {CanvasContext} from '@luma.gl/core';
 import {WebGLDevice} from './webgl-device';
 import {WEBGLFramebuffer} from './resources/webgl-framebuffer';
 
-/** 
- * A WebGL Canvas Context which manages the canvas and handles drawing buffer resizing etc 
+/**
+ * A WebGL Canvas Context which manages the canvas and handles drawing buffer resizing etc
  */
 export class WebGLCanvasContext extends CanvasContext {
   readonly device: WebGLDevice;
@@ -33,7 +34,8 @@ export class WebGLCanvasContext extends CanvasContext {
   /** Resizes and updates render targets if necessary */
   update() {
     const size = this.getPixelSize();
-    const sizeChanged = size[0] !== this.presentationSize[0] || size[1] !== this.presentationSize[1];
+    const sizeChanged =
+      size[0] !== this.presentationSize[0] || size[1] !== this.presentationSize[1];
     if (sizeChanged) {
       this.presentationSize = size;
       this.resize();
@@ -61,18 +63,12 @@ export class WebGLCanvasContext extends CanvasContext {
       this.setDevicePixelRatio(devicePixelRatio, options);
       return;
     }
-
-    // Resize headless gl context
-    const ext = this.device.gl.getExtension('STACKGL_resize_drawingbuffer');
-    if (ext && options && 'width' in options && 'height' in options) {
-      ext.resize(options.width, options.height);
-    }
   }
 
   commit() {
     // gl.commit was ultimately removed from the WebGL standard??
     // if (this.offScreen && this.gl.commit) {
-    //   // @ts-expect-error gl.commit is not officially part of WebGLRenderingContext
+    //   // @ts-expect-error gl.commit is not officially part of WebGL2RenderingContext
     //   this.gl.commit();
     // }
   }