@luma.gl/webgl 9.0.0-beta.3 → 9.0.0-beta.5

package/src/adapter/device-helpers/{device-limits.ts → webgl-device-limits.ts}

@@ -3,39 +3,37 @@
 
 import type {DeviceLimits} from '@luma.gl/core';
 import {GL} from '@luma.gl/constants';
-import {getWebGL2Context} from '../../context/context/webgl-checks';
 
 /** Populate a WebGPU style device limits */
-export function getDeviceLimits(gl: WebGLRenderingContext): DeviceLimits {
-  const gl2: WebGL2RenderingContext | null = getWebGL2Context(gl);
+export function getDeviceLimits(gl: WebGL2RenderingContext): DeviceLimits {
   return {
     maxTextureDimension1D: 0, // WebGL does not support 1D textures
     maxTextureDimension2D: gl.getParameter(GL.MAX_TEXTURE_SIZE),
-    maxTextureDimension3D: gl2 ? gl2.getParameter(GL.MAX_3D_TEXTURE_SIZE) : 0,
-    maxTextureArrayLayers: gl2 ? gl2.getParameter(GL.MAX_ARRAY_TEXTURE_LAYERS) : 0,
-    maxBindGroups: 1, // TBD
+    maxTextureDimension3D: gl.getParameter(GL.MAX_3D_TEXTURE_SIZE),
+    maxTextureArrayLayers: gl.getParameter(GL.MAX_ARRAY_TEXTURE_LAYERS),
+    maxBindGroups: 1, // TBD - if we emulate bind groups we could support any number...
     maxDynamicUniformBuffersPerPipelineLayout: 0, // TBD
     maxDynamicStorageBuffersPerPipelineLayout: 0, // TBD
     maxSampledTexturesPerShaderStage: gl.getParameter(GL.MAX_VERTEX_TEXTURE_IMAGE_UNITS), // TBD
     maxSamplersPerShaderStage: gl.getParameter(GL.MAX_COMBINED_TEXTURE_IMAGE_UNITS),
     maxStorageBuffersPerShaderStage: 0, // TBD
     maxStorageTexturesPerShaderStage: 0, // TBD
-    maxUniformBuffersPerShaderStage: gl2 ? gl2.getParameter(GL.MAX_UNIFORM_BUFFER_BINDINGS) : 0,
-    maxUniformBufferBindingSize: gl2 ? gl2.getParameter(GL.MAX_UNIFORM_BLOCK_SIZE) : 0,
+    maxUniformBuffersPerShaderStage: gl.getParameter(GL.MAX_UNIFORM_BUFFER_BINDINGS),
+    maxUniformBufferBindingSize: gl.getParameter(GL.MAX_UNIFORM_BLOCK_SIZE),
     maxStorageBufferBindingSize: 0,
-    minUniformBufferOffsetAlignment: gl2 ? gl2.getParameter(GL.UNIFORM_BUFFER_OFFSET_ALIGNMENT) : 0,
+    minUniformBufferOffsetAlignment: gl.getParameter(GL.UNIFORM_BUFFER_OFFSET_ALIGNMENT),
     minStorageBufferOffsetAlignment: 0, // TBD
     maxVertexBuffers: 0,
     maxVertexAttributes: gl.getParameter(GL.MAX_VERTEX_ATTRIBS),
     maxVertexBufferArrayStride: 2048, // TBD, this is just the default value from WebGPU
-    maxInterStageShaderComponents: gl2 ? gl2.getParameter(GL.MAX_VARYING_COMPONENTS) : 0,
+    maxInterStageShaderComponents: gl.getParameter(GL.MAX_VARYING_COMPONENTS),
     maxComputeWorkgroupStorageSize: 0, // WebGL does not support compute shaders
     maxComputeInvocationsPerWorkgroup: 0, // WebGL does not support compute shaders
     maxComputeWorkgroupSizeX: 0, // WebGL does not support compute shaders
     maxComputeWorkgroupSizeY: 0, // WebGL does not support compute shaders
     maxComputeWorkgroupSizeZ: 0, // WebGL does not support compute shaders
-    maxComputeWorkgroupsPerDimension: 0, // WebGL does not support compute shaders
-  }
+    maxComputeWorkgroupsPerDimension: 0 // WebGL does not support compute shaders
+  };
 }
 
 /** WebGL context limits */
@@ -60,7 +58,7 @@ export type WebGLLimits = {
   // WebGL2 Limits
   [GL.MAX_3D_TEXTURE_SIZE]: number;
   [GL.MAX_ARRAY_TEXTURE_LAYERS]: number;
-  [GL.MAX_CLIENT_WAIT_TIMEOUT_WEBGL]: number;
+  // [GL.MAX_CLIENT_WAIT_TIMEOUT_WEBGL]: number;
   [GL.MAX_COLOR_ATTACHMENTS]: number;
   [GL.MAX_COMBINED_FRAGMENT_UNIFORM_COMPONENTS]: number;
   [GL.MAX_COMBINED_UNIFORM_BLOCKS]: number;
@@ -73,7 +71,7 @@ export type WebGLLimits = {
   [GL.MAX_FRAGMENT_UNIFORM_BLOCKS]: number;
   [GL.MAX_FRAGMENT_UNIFORM_COMPONENTS]: number;
   [GL.MAX_SAMPLES]: number;
-  [GL.MAX_SERVER_WAIT_TIMEOUT]: number;
+  // [GL.MAX_SERVER_WAIT_TIMEOUT]: number;
   [GL.MAX_TEXTURE_LOD_BIAS]: number;
   [GL.MAX_TRANSFORM_FEEDBACK_INTERLEAVED_COMPONENTS]: number;
   [GL.MAX_TRANSFORM_FEEDBACK_SEPARATE_ATTRIBS]: number;
@@ -89,16 +87,14 @@ export type WebGLLimits = {
   [GL.UNIFORM_BUFFER_OFFSET_ALIGNMENT]: number;
 };
 
-
-export function getWebGLLimits(gl: WebGLRenderingContext): WebGLLimits {
-  const gl2 = getWebGL2Context(gl);
+export function getWebGLLimits(gl: WebGL2RenderingContext): WebGLLimits {
   function get<T = number>(pname: number): T {
     return gl.getParameter(pname) as T;
   }
   function get2(pname: number, defaultValue?: number): number;
   function get2<T>(pname: number, defaultValue: T): T;
   function get2<T>(pname: number, defaultValue: T): T {
-    return gl2 ? gl2.getParameter(pname) as T : (defaultValue || 0) as T;
+    return (gl.getParameter(pname) as T) || defaultValue;
   }
   // function getMaxAnistropy() {
   //   const extension = gl.getExtension('EXT_texture_filter_anisotropic');
@@ -124,9 +120,11 @@ export function getWebGLLimits(gl: WebGLRenderingContext): WebGLLimits {
     // WebGL2 Limits
     [GL.MAX_3D_TEXTURE_SIZE]: get2(GL.MAX_3D_TEXTURE_SIZE), //  GLint
     [GL.MAX_ARRAY_TEXTURE_LAYERS]: get2(GL.MAX_ARRAY_TEXTURE_LAYERS), // GLint
-    [GL.MAX_CLIENT_WAIT_TIMEOUT_WEBGL]: get2(GL.MAX_CLIENT_WAIT_TIMEOUT_WEBGL), //  GLint64
+    // [GL.MAX_CLIENT_WAIT_TIMEOUT_WEBGL]: get2(GL.MAX_CLIENT_WAIT_TIMEOUT_WEBGL), //  GLint64
     [GL.MAX_COLOR_ATTACHMENTS]: get2(GL.MAX_COLOR_ATTACHMENTS), //  GLint
-    [GL.MAX_COMBINED_FRAGMENT_UNIFORM_COMPONENTS]: get2(GL.MAX_COMBINED_FRAGMENT_UNIFORM_COMPONENTS), // GLint64
+    [GL.MAX_COMBINED_FRAGMENT_UNIFORM_COMPONENTS]: get2(
+      GL.MAX_COMBINED_FRAGMENT_UNIFORM_COMPONENTS
+    ), // GLint64
     [GL.MAX_COMBINED_UNIFORM_BLOCKS]: get2(GL.MAX_COMBINED_UNIFORM_BLOCKS), //  GLint
     [GL.MAX_COMBINED_VERTEX_UNIFORM_COMPONENTS]: get2(GL.MAX_COMBINED_VERTEX_UNIFORM_COMPONENTS), // GLint64
     [GL.MAX_DRAW_BUFFERS]: get2(GL.MAX_DRAW_BUFFERS), // GLint
@@ -137,11 +135,15 @@ export function getWebGLLimits(gl: WebGLRenderingContext): WebGLLimits {
     [GL.MAX_FRAGMENT_UNIFORM_BLOCKS]: get2(GL.MAX_FRAGMENT_UNIFORM_BLOCKS), //  GLint
     [GL.MAX_FRAGMENT_UNIFORM_COMPONENTS]: get2(GL.MAX_FRAGMENT_UNIFORM_COMPONENTS), //  GLint
     [GL.MAX_SAMPLES]: get2(GL.MAX_SAMPLES), //  GLint
-    [GL.MAX_SERVER_WAIT_TIMEOUT]: get2(GL.MAX_SERVER_WAIT_TIMEOUT), //  GLint64
+    // [GL.MAX_SERVER_WAIT_TIMEOUT]: get2(GL.MAX_SERVER_WAIT_TIMEOUT), //  GLint64
     [GL.MAX_TEXTURE_LOD_BIAS]: get2(GL.MAX_TEXTURE_LOD_BIAS), // GLfloat
-    [GL.MAX_TRANSFORM_FEEDBACK_INTERLEAVED_COMPONENTS]: get2(GL.MAX_TRANSFORM_FEEDBACK_INTERLEAVED_COMPONENTS), //  GLint
+    [GL.MAX_TRANSFORM_FEEDBACK_INTERLEAVED_COMPONENTS]: get2(
+      GL.MAX_TRANSFORM_FEEDBACK_INTERLEAVED_COMPONENTS
+    ), //  GLint
     [GL.MAX_TRANSFORM_FEEDBACK_SEPARATE_ATTRIBS]: get2(GL.MAX_TRANSFORM_FEEDBACK_SEPARATE_ATTRIBS), //  GLint
-    [GL.MAX_TRANSFORM_FEEDBACK_SEPARATE_COMPONENTS]: get2(GL.MAX_TRANSFORM_FEEDBACK_SEPARATE_COMPONENTS), // GLint
+    [GL.MAX_TRANSFORM_FEEDBACK_SEPARATE_COMPONENTS]: get2(
+      GL.MAX_TRANSFORM_FEEDBACK_SEPARATE_COMPONENTS
+    ), // GLint
     [GL.MAX_UNIFORM_BLOCK_SIZE]: get2(GL.MAX_UNIFORM_BLOCK_SIZE), // GLint64
     [GL.MAX_UNIFORM_BUFFER_BINDINGS]: get2(GL.MAX_UNIFORM_BUFFER_BINDINGS), //  GLint
     [GL.MAX_VARYING_COMPONENTS]: get2(GL.MAX_VARYING_COMPONENTS), // GLint

package/src/adapter/helpers/get-shader-layout.ts

@@ -10,7 +10,6 @@ import type {
 } from '@luma.gl/core';
 
 import {GL} from '@luma.gl/constants';
-import {isWebGL2} from '../../context/context/webgl-checks';
 import {Accessor} from '../../classic/accessor'; // TODO - should NOT depend on classic API
 import {decodeGLUniformType, decodeGLAttributeType, isSamplerUniform} from './decode-webgl-types';
 
@@ -19,7 +18,7 @@ import {decodeGLUniformType, decodeGLAttributeType, isSamplerUniform} from './de
  * Note: `linkProgram()` needs to have been called
  * (although linking does not need to have been successful).
  */
-export function getShaderLayout(gl: WebGLRenderingContext, program: WebGLProgram): ShaderLayout {
+export function getShaderLayout(gl: WebGL2RenderingContext, program: WebGLProgram): ShaderLayout {
   const shaderLayout: ShaderLayout = {
     attributes: [],
     bindings: []
@@ -88,7 +87,7 @@ export function getShaderLayout(gl: WebGLRenderingContext, program: WebGLProgram
  * linkProgram needs to have been called, although linking does not need to have been successful
  */
 function readAttributeDeclarations(
-  gl: WebGLRenderingContext,
+  gl: WebGL2RenderingContext,
   program: WebGLProgram
 ): AttributeDeclaration[] {
   const attributes: AttributeDeclaration[] = [];
@@ -132,17 +131,12 @@ function readAttributeDeclarations(
  *
  * linkProgram needs to have been called, although linking does not need to have been successful
  */
-function readVaryings(gl: WebGLRenderingContext, program: WebGLProgram): VaryingBinding[] {
-  if (!isWebGL2(gl)) {
-    return [];
-  }
-  const gl2 = gl as WebGL2RenderingContext;
-
+function readVaryings(gl: WebGL2RenderingContext, program: WebGLProgram): VaryingBinding[] {
   const varyings: VaryingBinding[] = [];
 
   const count = gl.getProgramParameter(program, GL.TRANSFORM_FEEDBACK_VARYINGS);
   for (let location = 0; location < count; location++) {
-    const activeInfo = gl2.getTransformFeedbackVarying(program, location);
+    const activeInfo = gl.getTransformFeedbackVarying(program, location);
     if (!activeInfo) {
       throw new Error('activeInfo');
     }
@@ -162,7 +156,7 @@ function readVaryings(gl: WebGLRenderingContext, program: WebGLProgram): Varying
  *
  * Query uniform locations and build name to setter map.
  */
-function readUniformBindings(gl: WebGLRenderingContext, program: WebGLProgram): UniformBinding[] {
+function readUniformBindings(gl: WebGL2RenderingContext, program: WebGLProgram): UniformBinding[] {
   const uniforms: UniformBinding[] = [];
 
   const uniformCount = gl.getProgramParameter(program, GL.ACTIVE_UNIFORMS);
@@ -209,23 +203,18 @@ function readUniformBindings(gl: WebGLRenderingContext, program: WebGLProgram):
  * @note In WebGL, "active" just means that unused (inactive) blocks may have been optimized away during linking)
  */
 function readUniformBlocks(
-  gl: WebGLRenderingContext,
+  gl: WebGL2RenderingContext,
   program: WebGLProgram
 ): UniformBlockBinding[] {
-  if (!isWebGL2(gl)) {
-    return [];
-  }
-  const gl2 = gl as WebGL2RenderingContext;
-
   const getBlockParameter = (blockIndex: number, pname: GL): any =>
-    gl2.getActiveUniformBlockParameter(program, blockIndex, pname);
+    gl.getActiveUniformBlockParameter(program, blockIndex, pname);
 
   const uniformBlocks: UniformBlockBinding[] = [];
 
-  const blockCount = gl2.getProgramParameter(program, GL.ACTIVE_UNIFORM_BLOCKS);
+  const blockCount = gl.getProgramParameter(program, GL.ACTIVE_UNIFORM_BLOCKS);
   for (let blockIndex = 0; blockIndex < blockCount; blockIndex++) {
     const blockInfo: UniformBlockBinding = {
-      name: gl2.getActiveUniformBlockName(program, blockIndex) || '',
+      name: gl.getActiveUniformBlockName(program, blockIndex) || '',
       location: getBlockParameter(blockIndex, GL.UNIFORM_BLOCK_BINDING),
       byteLength: getBlockParameter(blockIndex, GL.UNIFORM_BLOCK_DATA_SIZE),
       vertex: getBlockParameter(blockIndex, GL.UNIFORM_BLOCK_REFERENCED_BY_VERTEX_SHADER),
@@ -237,23 +226,23 @@ function readUniformBlocks(
     const uniformIndices =
       (getBlockParameter(blockIndex, GL.UNIFORM_BLOCK_ACTIVE_UNIFORM_INDICES) as number[]) || [];
 
-    const uniformType = gl2.getActiveUniforms(program, uniformIndices, GL.UNIFORM_TYPE); // Array of GLenum indicating the types of the uniforms.
-    const uniformArrayLength = gl2.getActiveUniforms(program, uniformIndices, GL.UNIFORM_SIZE); // Array of GLuint indicating the sizes of the uniforms.
-    // const uniformBlockIndex = gl2.getActiveUniforms(
+    const uniformType = gl.getActiveUniforms(program, uniformIndices, GL.UNIFORM_TYPE); // Array of GLenum indicating the types of the uniforms.
+    const uniformArrayLength = gl.getActiveUniforms(program, uniformIndices, GL.UNIFORM_SIZE); // Array of GLuint indicating the sizes of the uniforms.
+    // const uniformBlockIndex = gl.getActiveUniforms(
     //   program,
     //   uniformIndices,
     //   GL.UNIFORM_BLOCK_INDEX
     // ); // Array of GLint indicating the block indices of the uniforms.
-    const uniformOffset = gl2.getActiveUniforms(program, uniformIndices, GL.UNIFORM_OFFSET); // Array of GLint indicating the uniform buffer offsets.
-    const uniformStride = gl2.getActiveUniforms(program, uniformIndices, GL.UNIFORM_ARRAY_STRIDE); // Array of GLint indicating the strides between the elements.
-    // const uniformMatrixStride = gl2.getActiveUniforms(
+    const uniformOffset = gl.getActiveUniforms(program, uniformIndices, GL.UNIFORM_OFFSET); // Array of GLint indicating the uniform buffer offsets.
+    const uniformStride = gl.getActiveUniforms(program, uniformIndices, GL.UNIFORM_ARRAY_STRIDE); // Array of GLint indicating the strides between the elements.
+    // const uniformMatrixStride = gl.getActiveUniforms(
     //   program,
     //   uniformIndices,
     //   GL.UNIFORM_MATRIX_STRIDE
     // ); // Array of GLint indicating the strides between columns of a column-major matrix or a row-major matrix.
-    // const uniformRowMajor = gl2.getActiveUniforms(program, uniformIndices, GL.UNIFORM_IS_ROW_MAJOR);
+    // const uniformRowMajor = gl.getActiveUniforms(program, uniformIndices, GL.UNIFORM_IS_ROW_MAJOR);
     for (let i = 0; i < blockInfo.uniformCount; ++i) {
-      const activeInfo = gl2.getActiveUniform(program, uniformIndices[i]);
+      const activeInfo = gl.getActiveUniform(program, uniformIndices[i]);
       if (!activeInfo) {
         throw new Error('activeInfo');
       }

package/src/adapter/helpers/set-uniform.ts

@@ -10,7 +10,7 @@ import {GL, GLCompositeType, GLSamplerType} from '@luma.gl/constants';
 /** Set a raw uniform (without type conversion and caching) */
 /* eslint-disable max-len */
 export function setUniform(
-  gl: WebGLRenderingContext,
+  gl: WebGL2RenderingContext,
   location: WebGLUniformLocation,
   type: GLCompositeType | GLSamplerType,
   value: UniformValue
@@ -29,10 +29,8 @@ export function setUniform(
 
   // prettier-ignore
   switch (type) {
-    // WebGL1 samplers
     case GL.SAMPLER_2D:
     case GL.SAMPLER_CUBE:
-    // WebGL2 samplers
     case GL.SAMPLER_3D:
     case GL.SAMPLER_2D_SHADOW:
     case GL.SAMPLER_2D_ARRAY:

package/src/adapter/objects/constants-to-keys.ts

@@ -5,7 +5,7 @@ import {assert} from '@luma.gl/core';
 import {GL} from '@luma.gl/constants';
 
 // Resolve a WebGL enumeration name (returns itself if already a number)
-export function getKeyValue(gl: WebGLRenderingContext, name: string | GL): GL {
+export function getKeyValue(gl: WebGL2RenderingContext, name: string | GL): GL {
   // If not a string, return (assume number)
   if (typeof name !== 'string') {
     return name;

package/src/adapter/objects/webgl-renderbuffer.ts

@@ -57,7 +57,7 @@ export class WEBGLRenderbuffer extends WebGLResource<RenderbufferProps> {
       throw new Error('Renderbuffer');
     }
     super(device, props, WEBGLRenderbuffer.defaultProps);
-    this.glFormat = convertTextureFormatToGL(this.props.format, device.isWebGL2);
+    this.glFormat = convertTextureFormatToGL(this.props.format);
     this._initialize(this.props);
   }
 
@@ -80,8 +80,8 @@ export class WEBGLRenderbuffer extends WebGLResource<RenderbufferProps> {
 
     this.gl.bindRenderbuffer(GL.RENDERBUFFER, this.handle);
 
-    if (samples !== 0 && this.device.isWebGL2) {
-      this.gl2.renderbufferStorageMultisample(GL.RENDERBUFFER, samples, this.glFormat, width, height);
+    if (samples !== 0) {
+      this.gl.renderbufferStorageMultisample(GL.RENDERBUFFER, samples, this.glFormat, width, height);
     } else {
       this.gl.renderbufferStorage(GL.RENDERBUFFER, this.glFormat, width, height);
     }
@@ -89,7 +89,7 @@ export class WEBGLRenderbuffer extends WebGLResource<RenderbufferProps> {
     this.gl.bindRenderbuffer(GL.RENDERBUFFER, null);
 
     this.trackAllocatedMemory(
-      width * height * (samples || 1) * getTextureFormatBytesPerPixel(this.glFormat, this.device.isWebGL2)
+      width * height * (samples || 1) * getTextureFormatBytesPerPixel(this.glFormat)
     );
   }
 

package/src/adapter/objects/webgl-resource.ts

@@ -4,7 +4,6 @@
 import {Resource, assert, uid, stubRemovedMethods} from '@luma.gl/core';
 import type {Device, ResourceProps} from '@luma.gl/core';
 import {GL} from '@luma.gl/constants';
-import {isWebGL2, assertWebGLContext} from '../../context/context/webgl-checks';
 import {WebGLDevice} from '../webgl-device';
 
 // Requires full GL enum to be bundled... Make these bindings dependent on dynamic import (debug)?
@@ -17,7 +16,7 @@ const ERR_RESOURCE_METHOD_UNDEFINED = 'Resource subclass must define virtual met
  */
 export abstract class WebGLResource<Props extends ResourceProps> extends Resource<Props> {
   readonly device: WebGLDevice;
-  readonly gl: WebGLRenderingContext;
+  readonly gl: WebGL2RenderingContext;
   readonly gl2: WebGL2RenderingContext;
   private _handle: any;
 
@@ -31,12 +30,10 @@ export abstract class WebGLResource<Props extends ResourceProps> extends Resourc
     this.device = WebGLDevice.attach(device);
     const gl = this.device.gl;
 
-    assertWebGLContext(gl);
-
     // extends 
     const {id} = props || {};
     this.gl = gl;
-    this.gl2 = gl as WebGL2RenderingContext;
+    this.gl2 = gl ;
     this.id = id || uid(this.constructor.name);
 
     // Set the handle
@@ -133,18 +130,12 @@ export abstract class WebGLResource<Props extends ResourceProps> extends Resourc
     // Use parameter definitions to handle unsupported parameters
     const parameter = parameters[pname];
     if (parameter) {
-      const isWebgl2 = isWebGL2(this.gl);
-
       // Check if we can query for this parameter
       const parameterAvailable =
-        (!('webgl2' in parameter) || isWebgl2) &&
         (!('extension' in parameter) || this.gl.getExtension(parameter.extension));
 
       if (!parameterAvailable) {
-        const webgl1Default = parameter.webgl1;
-        const webgl2Default = 'webgl2' in parameter ? parameter.webgl2 : parameter.webgl1;
-        const defaultValue = isWebgl2 ? webgl2Default : webgl1Default;
-        return defaultValue;
+        return parameter.webgl2;
       }
     }
 
@@ -163,8 +154,6 @@ export abstract class WebGLResource<Props extends ResourceProps> extends Resourc
     // @ts-expect-error
     const PARAMETERS = this.constructor.PARAMETERS || {};
 
-    const isWebgl2 = isWebGL2(this.gl);
-
     const values: Record<string, any> = {};
 
     // Query all parameters if no list provided
@@ -177,7 +166,6 @@ export abstract class WebGLResource<Props extends ResourceProps> extends Resourc
       // Check if this parameter is available on this platform
       const parameterAvailable =
         parameter &&
-        (!('webgl2' in parameter) || isWebgl2) &&
         (!('extension' in parameter) || this.gl.getExtension(parameter.extension));
 
       if (parameterAvailable) {
@@ -210,11 +198,8 @@ export abstract class WebGLResource<Props extends ResourceProps> extends Resourc
 
     const parameter = parameters[pname];
     if (parameter) {
-      const isWebgl2 = isWebGL2(this.gl);
-
       // Check if this parameter is available on this platform
       const parameterAvailable =
-        (!('webgl2' in parameter) || isWebgl2) &&
         (!('extension' in parameter) || this.gl.getExtension(parameter.extension));
 
       if (!parameterAvailable) {

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

@@ -9,8 +9,7 @@ import {WebGLDevice} from '../webgl-device';
 /** WebGL Buffer interface */
 export class WEBGLBuffer extends Buffer {
   readonly device: WebGLDevice;
-  readonly gl: WebGLRenderingContext;
-  readonly gl2: WebGL2RenderingContext | null;
+  readonly gl: WebGL2RenderingContext;
   readonly handle: WebGLBuffer;
 
   /** Target in OpenGL defines the type of buffer */
@@ -30,7 +29,6 @@ export class WEBGLBuffer extends Buffer {
 
     this.device = device;
     this.gl = this.device.gl;
-    this.gl2 = this.device.gl2;
 
     const handle = typeof props === 'object' ? props.handle : undefined;
     this.handle = handle || this.gl.createBuffer();
@@ -118,12 +116,11 @@ export class WEBGLBuffer extends Buffer {
 
     // Create the buffer - binding it here for the first time locks the type
     // In WebGL2, use GL.COPY_WRITE_BUFFER to avoid locking the type
-    const glTarget = this.device.isWebGL2 ? GL.COPY_WRITE_BUFFER : this.glTarget;
+    const glTarget = GL.COPY_WRITE_BUFFER;
     this.gl.bindBuffer(glTarget, this.handle);
     // WebGL2: subData supports additional srcOffset and length parameters
     if (srcOffset !== 0 || byteLength !== undefined) {
-      this.device.assertWebGL2();
-      this.gl2.bufferSubData(glTarget, byteOffset, data, srcOffset, byteLength);
+      this.gl.bufferSubData(glTarget, byteOffset, data, srcOffset, byteLength);
     } else {
       this.gl.bufferSubData(glTarget, byteOffset, data);
     }
@@ -134,20 +131,18 @@ export class WEBGLBuffer extends Buffer {
 
   /** Asynchronously read data from the buffer */
   override async readAsync(byteOffset = 0, byteLength?: number): Promise<Uint8Array> {
-    return this.readSyncWebGL2(byteOffset, byteLength);
+    return this.readSyncWebGL(byteOffset, byteLength);
   }
 
   /** Synchronously read data from the buffer. WebGL only. */
-  override readSyncWebGL2(byteOffset = 0, byteLength?: number): Uint8Array {
-    this.device.assertWebGL2();
-
+  override readSyncWebGL(byteOffset = 0, byteLength?: number): Uint8Array {
     byteLength = byteLength ?? this.byteLength - byteOffset;
     const data = new Uint8Array(byteLength);
     const dstOffset = 0;
 
     // Use GL.COPY_READ_BUFFER to avoid disturbing other targets and locking type
     this.gl.bindBuffer(GL.COPY_READ_BUFFER, this.handle);
-    this.gl2.getBufferSubData(GL.COPY_READ_BUFFER, byteOffset, data, dstOffset, byteLength);
+    this.gl.getBufferSubData(GL.COPY_READ_BUFFER, byteOffset, data, dstOffset, byteLength);
     this.gl.bindBuffer(GL.COPY_READ_BUFFER, null);
 
     // Update local `data` if offsets are 0

package/src/adapter/resources/webgl-command-buffer.ts

@@ -79,26 +79,19 @@ function _copyBufferToBuffer(device: WebGLDevice, options: CopyBufferToBufferOpt
   const source = cast<WEBGLBuffer>(options.source);
   const destination = cast<WEBGLBuffer>(options.destination);
 
-  const gl2 = device.assertWebGL2();
-  if (gl2) {
-    // In WebGL2 we can perform the copy on the GPU
-    // Use GL.COPY_READ_BUFFER+GL.COPY_WRITE_BUFFER avoid disturbing other targets and locking type
-    gl2.bindBuffer(GL.COPY_READ_BUFFER, source.handle);
-    gl2.bindBuffer(GL.COPY_WRITE_BUFFER, destination.handle);
-    gl2.copyBufferSubData(
-      GL.COPY_READ_BUFFER,
-      GL.COPY_WRITE_BUFFER,
-      options.sourceOffset ?? 0,
-      options.destinationOffset ?? 0,
-      options.size
-    );
-    gl2.bindBuffer(GL.COPY_READ_BUFFER, null);
-    gl2.bindBuffer(GL.COPY_WRITE_BUFFER, null);
-  } else {
-    // TODO - in WebGL1 we would have to read back to CPU
-    // read / write buffer from / to CPU
-    throw new Error('copyBufferToBuffer not implemented in WebGL1');
-  }
+  // {In WebGL2 we can p}erform the copy on the GPU
+  // Use GL.COPY_READ_BUFFER+GL.COPY_WRITE_BUFFER avoid disturbing other targets and locking type
+  device.gl.bindBuffer(GL.COPY_READ_BUFFER, source.handle);
+  device.gl.bindBuffer(GL.COPY_WRITE_BUFFER, destination.handle);
+  device.gl.copyBufferSubData(
+    GL.COPY_READ_BUFFER,
+    GL.COPY_WRITE_BUFFER,
+    options.sourceOffset ?? 0,
+    options.destinationOffset ?? 0,
+    options.size
+  );
+  device.gl.bindBuffer(GL.COPY_READ_BUFFER, null);
+  device.gl.bindBuffer(GL.COPY_WRITE_BUFFER, null);
 }
 
 /**
@@ -158,14 +151,12 @@ function _copyTextureToBuffer(device: WebGLDevice, options: CopyTextureToBufferO
   }
 
   // Asynchronous read (PIXEL_PACK_BUFFER) is WebGL2 only feature
-  const gl2 = device.assertWebGL2();
-
   const {framebuffer, destroyFramebuffer} = getFramebuffer(source);
   try {
     const webglBuffer = destination as WEBGLBuffer;
     const sourceWidth = width || framebuffer.width;
     const sourceHeight = height || framebuffer.height;
-    const sourceParams = getWebGLTextureParameters(framebuffer.texture.format, true);
+    const sourceParams = getWebGLTextureParameters(framebuffer.texture.format);
     const sourceFormat = sourceParams.dataFormat;
     const sourceType = sourceParams.type;
 
@@ -177,10 +168,10 @@ function _copyTextureToBuffer(device: WebGLDevice, options: CopyTextureToBufferO
     //   target = device.createBuffer({byteLength});
     // }
 
-    gl2.bindBuffer(GL.PIXEL_PACK_BUFFER, webglBuffer.handle);
-    gl2.bindFramebuffer(GL.FRAMEBUFFER, framebuffer.handle);
+    device.gl.bindBuffer(GL.PIXEL_PACK_BUFFER, webglBuffer.handle);
+    device.gl.bindFramebuffer(GL.FRAMEBUFFER, framebuffer.handle);
 
-    gl2.readPixels(
+    device.gl.readPixels(
       origin[0],
       origin[1],
       sourceWidth,
@@ -190,8 +181,8 @@ function _copyTextureToBuffer(device: WebGLDevice, options: CopyTextureToBufferO
       byteOffset
     );
   } finally {
-    gl2.bindBuffer(GL.PIXEL_PACK_BUFFER, null);
-    gl2.bindFramebuffer(GL.FRAMEBUFFER, null);
+    device.gl.bindBuffer(GL.PIXEL_PACK_BUFFER, null);
+    device.gl.bindFramebuffer(GL.FRAMEBUFFER, null);
 
     if (destroyFramebuffer) {
       framebuffer.destroy();
@@ -309,8 +300,7 @@ function _copyTextureToTexture(device: WebGLDevice, options: CopyTextureToTextur
     //     break;
     //   case GL.TEXTURE_2D_ARRAY:
     //   case GL.TEXTURE_3D:
-    //     const gl2 = device.assertWebGL2();
-    //     gl2.copyTexSubImage3D(
+    //     device.gl.copyTexSubImage3D(
     //       textureTarget,
     //       destinationMipmaplevel,
     //       destinationX,

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

@@ -4,8 +4,7 @@
 /*
 export class WEBGLExternalTexture extends WEBGLTexture {
   readonly device: WebGLDevice;
-  readonly gl: WebGLRenderingContext;
-  readonly gl2: WebGL2RenderingContext | null;
+  readonly gl: WebGL2RenderingContext;
   readonly handle: WebGLTexture;
 
   data;
@@ -53,7 +52,7 @@ export class WEBGLExternalTexture extends WEBGLTexture {
   }
 
   // eslint-disable-next-line max-statements
-  constructor(device: Device | WebGLRenderingContext, props: TextureProps) {
+  constructor(device: Device | WebGL2RenderingContext, props: TextureProps) {
     super(WebGLDevice.attach(device), {id: uid('texture'), ...props});
 
     this.glTarget = getWebGLTextureTarget(props);

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

@@ -15,7 +15,7 @@ export type Attachment = WEBGLTexture | WEBGLRenderbuffer | TextureAttachment;
 /** luma.gl Framebuffer, WebGL implementation  */
 export class WEBGLFramebuffer extends Framebuffer {
   device: WebGLDevice;
-  gl: WebGLRenderingContext;
+  gl: WebGL2RenderingContext;
   handle: WebGLFramebuffer;
 
   get texture() {
@@ -165,7 +165,7 @@ export class WEBGLFramebuffer extends Framebuffer {
    * @param attachment
    * @param texture
    * @param layer = 0 - index into WEBGLTextureArray and Texture3D or face for `TextureCubeMap`
-   * @param level  = 0 - mipmapLevel (must be 0 in WebGL1)
+   * @param level = 0 - mipmapLevel
    */
   protected _attachTexture(
     attachment: GL,
@@ -173,14 +173,13 @@ export class WEBGLFramebuffer extends Framebuffer {
     layer: number,
     level: number
   ): void {
-    const {gl, gl2} = this.device;
+    const {gl} = this.device;
     gl.bindTexture(texture.target, texture.handle);
 
     switch (texture.target) {
       case GL.TEXTURE_2D_ARRAY:
       case GL.TEXTURE_3D:
-        this.device.assertWebGL2();
-        gl2?.framebufferTextureLayer(GL.FRAMEBUFFER, attachment, texture.target, level, layer);
+        gl.framebufferTextureLayer(GL.FRAMEBUFFER, attachment, texture.target, level, layer);
         break;
 
       case GL.TEXTURE_CUBE_MAP:

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

@@ -142,18 +142,18 @@ export class WEBGLRenderPass extends RenderPass {
    * WebGL2 - clear a specific color buffer 
    */
   protected clearColorBuffer(drawBuffer: number = 0, value: NumberArray = [0, 0, 0, 0]) {
-    withGLParameters(this.device.gl2, {framebuffer: this.props.framebuffer}, () => {
+    withGLParameters(this.device.gl, {framebuffer: this.props.framebuffer}, () => {
       // Method selection per OpenGL ES 3 docs
       switch (value.constructor) {
         case Int32Array:
-          this.device.gl2.clearBufferiv(GL_COLOR, drawBuffer, value);
+          this.device.gl.clearBufferiv(GL_COLOR, drawBuffer, value);
           break;
         case Uint32Array:
-          this.device.gl2.clearBufferuiv(GL_COLOR, drawBuffer, value);
+          this.device.gl.clearBufferuiv(GL_COLOR, drawBuffer, value);
           break;
         case Float32Array:
         default:
-          this.device.gl2.clearBufferfv(GL_COLOR, drawBuffer, value);
+          this.device.gl.clearBufferfv(GL_COLOR, drawBuffer, value);
           break;
       }
     });
@@ -165,16 +165,16 @@ export class WEBGLRenderPass extends RenderPass {
   // const GL_DEPTH_STENCIL = 0x84f9;
 
   //     case GL_DEPTH:
-  //       this.device.gl2.clearBufferfv(GL_DEPTH, 0, [value]);
+  //       this.device.gl.clearBufferfv(GL_DEPTH, 0, [value]);
   //       break;
 
   //     case GL_STENCIL:
-  //       this.device.gl2.clearBufferiv(GL_STENCIL, 0, [value]);
+  //       this.device.gl.clearBufferiv(GL_STENCIL, 0, [value]);
   //       break;
 
   //     case GL_DEPTH_STENCIL:
   //       const [depth, stencil] = value;
-  //       this.device.gl2.clearBufferfi(GL_DEPTH_STENCIL, 0, depth, stencil);
+  //       this.device.gl.clearBufferfi(GL_DEPTH_STENCIL, 0, depth, stencil);
   //       break;
 
   //     default: