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

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

@@ -1,4 +1,5 @@
-// luma.gl, MIT license
+// luma.gl
+// SPDX-License-Identifier: MIT
 // Copyright (c) vis.gl contributors
 
 import {assert, ResourceProps, TextureFormat} from '@luma.gl/core';
@@ -6,7 +7,10 @@ import {GL} from '@luma.gl/constants';
 import {WebGLDevice} from '../webgl-device';
 import {WebGLResource} from './webgl-resource';
 import {isRenderbufferFormatSupported} from '../converters/texture-formats';
-import {convertTextureFormatToGL, getTextureFormatBytesPerPixel} from '../converters/texture-formats';
+import {
+  convertTextureFormatToGL,
+  getTextureFormatBytesPerPixel
+} from '../converters/texture-formats';
 
 export type RenderbufferProps = ResourceProps & {
   format: TextureFormat;
@@ -32,23 +36,35 @@ export class WEBGLRenderbuffer extends WebGLResource<RenderbufferProps> {
     userData: undefined,
     format: undefined, // 'depth16unorm'
     width: 1,
-    height: 1, 
+    height: 1,
     samples: 0
-  };  
+  };
 
-  override get [Symbol.toStringTag](): string { return 'Renderbuffer'; }
+  override get [Symbol.toStringTag](): string {
+    return 'Renderbuffer';
+  }
 
-  get width(): number { return this.props.width; }
-  get height(): number { return this.props.height; }
-  get format(): TextureFormat { return this.props.format; }
-  get samples(): number { return this.props.samples; }
-  get attachment() { return  }
+  get width(): number {
+    return this.props.width;
+  }
+  get height(): number {
+    return this.props.height;
+  }
+  get format(): TextureFormat {
+    return this.props.format;
+  }
+  get samples(): number {
+    return this.props.samples;
+  }
+  get attachment() {
+    return;
+  }
 
   /** WebGL format constant */
   glFormat: GL;
 
   static isTextureFormatSupported(device: WebGLDevice, format: TextureFormat): boolean {
-    return isRenderbufferFormatSupported(device.gl, format);
+    return isRenderbufferFormatSupported(device.gl, format, device._extensions);
   }
 
   constructor(device: WebGLDevice, props: RenderbufferProps) {
@@ -57,11 +73,11 @@ 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);
   }
 
-  resize(size: {width: number, height: number}): void {
+  resize(size: {width: number; height: number}): void {
     // Don't resize if width/height haven't changed
     if (size.width !== this.width || size.height !== this.height) {
       Object.assign(this.props, {...size, format: this.format, samples: this.samples});
@@ -80,8 +96,14 @@ 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 +111,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

@@ -1,15 +1,12 @@
-// luma.gl, MIT license
+// luma.gl
+// SPDX-License-Identifier: MIT
 // Copyright (c) vis.gl contributors
 
-import {Resource, assert, uid, stubRemovedMethods} from '@luma.gl/core';
 import type {Device, ResourceProps} from '@luma.gl/core';
+import {Resource, uid, stubRemovedMethods} 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)?
-import {getKeyValue} from './constants-to-keys';
-
 const ERR_RESOURCE_METHOD_UNDEFINED = 'Resource subclass must define virtual methods';
 
 /**
@@ -17,7 +14,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 +28,10 @@ export abstract class WebGLResource<Props extends ResourceProps> extends Resourc
     this.device = WebGLDevice.attach(device);
     const gl = this.device.gl;
 
-    assertWebGLContext(gl);
-
-    // extends 
+    // 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
@@ -84,7 +79,7 @@ export abstract class WebGLResource<Props extends ResourceProps> extends Resourc
     // @ts-expect-error
     if (children && deleteChildren) {
       // @ts-expect-error
-      children.filter(Boolean).forEach((child) => child.destroy());
+      children.filter(Boolean).forEach(child => child.destroy());
     }
 
     return this;
@@ -117,134 +112,6 @@ export abstract class WebGLResource<Props extends ResourceProps> extends Resourc
     this.bind(null);
   }
 
-  /**
-   * Query a Resource parameter
-   *
-   * @param name
-   * @return param
-   */
-  getParameter(pname: number, props: any = {}): any {
-    pname = getKeyValue(this.gl, pname);
-    assert(pname);
-
-    // @ts-expect-error
-    const parameters = this.constructor.PARAMETERS || {};
-
-    // 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;
-      }
-    }
-
-    // If unknown parameter - Could be a valid parameter not covered by PARAMS
-    // Attempt to query for it and let WebGL report errors
-    return this._getParameter(pname, props);
-  }
-
-  // Many resources support a getParameter call -
-  // getParameters will get all parameters - slow but useful for debugging
-  // eslint-disable-next-line complexity
-  getParameters(options: {parameters?: any, keys?: any} = {}) {
-    const {parameters, keys} = options;
-
-    // Get parameter definitions for this Resource
-    // @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
-    const parameterKeys = parameters || Object.keys(PARAMETERS);
-
-    // WEBGL limits
-    for (const pname of parameterKeys) {
-      const parameter = PARAMETERS[pname];
-
-      // 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) {
-        const key = keys ? this.device.getGLKey(pname) : pname;
-        values[key] = this.getParameter(pname, options);
-        if (keys && parameter.type === 'GLenum') {
-          values[key] = this.device.getGLKey(values[key]);
-        }
-      }
-    }
-
-    return values;
-  }
-
-  /**
-   * Update a Resource setting
-   *
-   * @todo - cache parameter to avoid issuing WebGL calls?
-   *
-   * @param pname - parameter (GL constant, value or key)
-   * @param value {GLint|GLfloat|GLenum} 
-   * @return returns self to enable chaining
-   */
-  setParameter(pname: GL | string, value: any): this {
-    pname = getKeyValue(this.gl, pname);
-    assert(pname);
-
-    // @ts-expect-error
-    const parameters = this.constructor.PARAMETERS || {};
-
-    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) {
-        throw new Error('Parameter not available on this platform');
-      }
-
-      // Handle string keys
-      if (parameter.type === 'GLenum') {
-        // @ts-expect-error
-        value = getKeyValue(value);
-      }
-    }
-
-    // If unknown parameter - Could be a valid parameter not covered by PARAMS
-    // attempt to set it and let WebGL report errors
-    this._setParameter(pname, value);
-    return this;
-  }
-
-  /*
-   * Batch update resource parameters
-   * Assumes the subclass supports a setParameter call
-   */
-  setParameters(parameters: Record<GL, any>) {
-    for (const pname in parameters) {
-      this.setParameter(pname, parameters[pname]);
-    }
-    return this;
-  }
-
   // Install stubs for removed methods
   stubRemovedMethods(className: string, version: string, methodNames: string[]) {
     return stubRemovedMethods(this, className, version, methodNames);

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

@@ -1,4 +1,5 @@
-// luma.gl, MIT license
+// luma.gl
+// SPDX-License-Identifier: MIT
 // Copyright (c) vis.gl contributors
 
 import type {BufferProps} from '@luma.gl/core';
@@ -9,8 +10,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 +30,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 +117,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 +132,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
@@ -171,9 +167,9 @@ export class WEBGLBuffer extends Buffer {
  * static STORAGE = 0x0080;
  * static INDIRECT = 0x0100;
  * static QUERY_RESOLVE = 0x0200;
- * 
+ *
  * @returns WebGL buffer targe
- * 
+ *
  * Buffer bind points in WebGL2
  * gl.COPY_READ_BUFFER: Buffer for copying from one buffer object to another.
  * gl.COPY_WRITE_BUFFER: Buffer for copying from one buffer object to another.

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

@@ -1,4 +1,5 @@
-// luma.gl, MIT license
+// luma.gl
+// SPDX-License-Identifier: MIT
 // Copyright (c) vis.gl contributors
 
 import type {
@@ -79,26 +80,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 +152,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.props.format);
     const sourceFormat = sourceParams.dataFormat;
     const sourceType = sourceParams.type;
 
@@ -177,10 +169,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 +182,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();
@@ -234,19 +226,18 @@ function _copyTextureToTexture(device: WebGLDevice, options: CopyTextureToTextur
     origin = [0, 0],
 
     /** Texture to copy to/from. */
-    destination,
+    destination
     /**  Mip-map level of the texture to copy to/from. (Default 0) */
     // destinationMipLevel = options.mipLevel,
     /** Defines the origin of the copy - the minimum corner of the texture sub-region to copy to/from. */
     // destinationOrigin = [0, 0],
     /** Defines which aspects of the texture to copy to/from. */
     // destinationAspect = options.aspect,
-
   } = options;
 
   let {
     width = options.destination.width,
-    height = options.destination.width,
+    height = options.destination.width
     // depthOrArrayLayers = 0
   } = options;
 
@@ -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-command-encoder.ts

@@ -1,4 +1,5 @@
-// luma.gl, MIT license
+// luma.gl
+// SPDX-License-Identifier: MIT
 // Copyright (c) vis.gl contributors
 
 import {CommandEncoder, CommandEncoderProps} from '@luma.gl/core';
@@ -6,7 +7,9 @@ import type {
   CopyBufferToBufferOptions,
   CopyBufferToTextureOptions,
   CopyTextureToBufferOptions,
-  CopyTextureToTextureOptions
+  CopyTextureToTextureOptions,
+  QuerySet,
+  Buffer
 } from '@luma.gl/core';
 
 import {WEBGLCommandBuffer} from './webgl-command-buffer';
@@ -54,13 +57,13 @@ export class WEBGLCommandEncoder extends CommandEncoder {
 
   override insertDebugMarker(markerLabel: string): void {}
 
-  // writeTimestamp(querySet: Query, queryIndex: number): void {}
-
-  // resolveQuerySet(options: {
-  //   querySet: GPUQuerySet,
-  //   firstQuery: number,
-  //   queryCount: number,
-  //   destination: Buffer,
-  //   destinationOffset?: number;
-  // }): void;
+  override resolveQuerySet(
+    querySet: QuerySet,
+    destination: Buffer,
+    options?: {
+      firstQuery?: number;
+      queryCount?: number;
+      destinationOffset?: number;
+    }
+  ): void {}
 }

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

@@ -1,11 +1,11 @@
-// luma.gl, MIT license
+// luma.gl
+// SPDX-License-Identifier: MIT
 // Copyright (c) vis.gl contributors
 
 /*
 export class WEBGLExternalTexture extends WEBGLTexture {
   readonly device: WebGLDevice;
-  readonly gl: WebGLRenderingContext;
-  readonly gl2: WebGL2RenderingContext | null;
+  readonly gl: WebGL2RenderingContext;
   readonly handle: WebGLTexture;
 
   data;
@@ -53,7 +53,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);
@@ -92,4 +92,4 @@ export class WEBGLExternalTexture extends WEBGLTexture {
   }
 
 
-*/
+*/