@luma.gl/webgl 9.0.0-alpha.9 → 9.0.0-beta.10

package/src/adapter/helpers/webgl-topology-utils.ts

@@ -0,0 +1,110 @@
+// luma.gl
+// SPDX-License-Identifier: MIT
+// Copyright (c) vis.gl contributors
+
+import {GL, GLPrimitiveTopology, GLPrimitive} from '@luma.gl/constants';
+import {PrimitiveTopology} from '@luma.gl/core';
+
+// Counts the number of complete primitives given a number of vertices and a drawMode
+export function getPrimitiveDrawMode(drawMode: GLPrimitiveTopology): GLPrimitive {
+  switch (drawMode) {
+    case GL.POINTS:
+      return GL.POINTS;
+    case GL.LINES:
+      return GL.LINES;
+    case GL.LINE_STRIP:
+      return GL.LINES;
+    case GL.LINE_LOOP:
+      return GL.LINES;
+    case GL.TRIANGLES:
+      return GL.TRIANGLES;
+    case GL.TRIANGLE_STRIP:
+      return GL.TRIANGLES;
+    case GL.TRIANGLE_FAN:
+      return GL.TRIANGLES;
+    default:
+      throw new Error('drawMode');
+  }
+}
+
+// Counts the number of complete "primitives" given a number of vertices and a drawMode
+export function getPrimitiveCount(options: {
+  drawMode: GLPrimitiveTopology;
+  vertexCount: number;
+}): number {
+  const {drawMode, vertexCount} = options;
+  switch (drawMode) {
+    case GL.POINTS:
+    case GL.LINE_LOOP:
+      return vertexCount;
+    case GL.LINES:
+      return vertexCount / 2;
+    case GL.LINE_STRIP:
+      return vertexCount - 1;
+    case GL.TRIANGLES:
+      return vertexCount / 3;
+    case GL.TRIANGLE_STRIP:
+    case GL.TRIANGLE_FAN:
+      return vertexCount - 2;
+    default:
+      throw new Error('drawMode');
+  }
+}
+
+// Counts the number of vertices after splitting the vertex stream into separate "primitives"
+export function getVertexCount(options: {
+  drawMode: GLPrimitiveTopology;
+  vertexCount: number;
+}): number {
+  const {drawMode, vertexCount} = options;
+  const primitiveCount = getPrimitiveCount({drawMode, vertexCount});
+  switch (getPrimitiveDrawMode(drawMode)) {
+    case GL.POINTS:
+      return primitiveCount;
+    case GL.LINES:
+      return primitiveCount * 2;
+    case GL.TRIANGLES:
+      return primitiveCount * 3;
+    default:
+      throw new Error('drawMode');
+  }
+}
+
+/** Get the primitive type for draw */
+export function getGLDrawMode(
+  topology: PrimitiveTopology
+):
+  | GL.POINTS
+  | GL.LINES
+  | GL.LINE_STRIP
+  | GL.LINE_LOOP
+  | GL.TRIANGLES
+  | GL.TRIANGLE_STRIP
+  | GL.TRIANGLE_FAN {
+  // prettier-ignore
+  switch (topology) {
+    case 'point-list': return GL.POINTS;
+    case 'line-list': return GL.LINES;
+    case 'line-strip': return GL.LINE_STRIP;
+    case 'line-loop-webgl': return GL.LINE_LOOP;
+    case 'triangle-list': return GL.TRIANGLES;
+    case 'triangle-strip': return GL.TRIANGLE_STRIP;
+    case 'triangle-fan-webgl': return GL.TRIANGLE_FAN;
+    default: throw new Error(topology);
+  }
+}
+
+/** Get the primitive type for transform feedback */
+export function getGLPrimitive(topology: PrimitiveTopology): GL.POINTS | GL.LINES | GL.TRIANGLES {
+  // prettier-ignore
+  switch (topology) {
+    case 'point-list': return GL.POINTS;
+    case 'line-list': return GL.LINES;
+    case 'line-strip': return GL.LINES;
+    case 'line-loop-webgl': return GL.LINES;
+    case 'triangle-list': return GL.TRIANGLES;
+    case 'triangle-strip': return GL.TRIANGLES;
+    case 'triangle-fan-webgl': return GL.TRIANGLES;
+    default: throw new Error(topology);
+  }
+}

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

@@ -1,8 +1,12 @@
-import {assert} from '@luma.gl/api';
-import GL from '@luma.gl/constants';
+// luma.gl
+// SPDX-License-Identifier: MIT
+// Copyright (c) vis.gl contributors
+
+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;
@@ -16,30 +20,8 @@ export function getKeyValue(gl: WebGLRenderingContext, name: string | GL): GL {
 
   // Look up string, after removing any 'GL.' or 'gl.' prefix
   name = name.replace(/^.*\./, '');
+  // @ts-ignore expect-error depends on settings
   const value = gl[name];
   assert(value !== undefined, `Accessing undefined constant GL.${name}`);
   return value;
 }
-
-export function getKey(gl: WebGLRenderingContext, value: any): string {
-  // @ts-expect-error 
-  gl = gl.gl || gl;
-  value = Number(value);
-  for (const key in gl) {
-    if (gl[key] === value) {
-      return `GL.${key}`;
-    }
-  }
-  return String(value);
-}
-
-export function getKeyType(gl: WebGLRenderingContext, value: any): string {
-  assert(value !== undefined, 'undefined key');
-  value = Number(value);
-  for (const key in gl) {
-    if (gl[key] === value) {
-      return `GL.${key}`;
-    }
-  }
-  return String(value);
-}

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

@@ -1,29 +1,24 @@
-/* eslint-disable no-inline-comments */
-import {assert, ResourceProps} from '@luma.gl/api';
-import GL from '@luma.gl/constants';
-import WebGLDevice from '../webgl-device';
-import WebGLResource from './webgl-resource';
+// luma.gl
+// SPDX-License-Identifier: MIT
+// Copyright (c) vis.gl contributors
+
+import {assert, ResourceProps, TextureFormat} from '@luma.gl/core';
+import {GL} from '@luma.gl/constants';
+import {WebGLDevice} from '../webgl-device';
+import {WebGLResource} from './webgl-resource';
+import {isRenderbufferFormatSupported} from '../converters/texture-formats';
 import {
-  isRenderbufferFormatSupported, getRenderbufferFormatBytesPerPixel
-} from '../converters/renderbuffer-formats';
+  convertTextureFormatToGL,
+  getTextureFormatBytesPerPixel
+} from '../converters/texture-formats';
 
 export type RenderbufferProps = ResourceProps & {
-  format: number;
+  format: TextureFormat;
   width?: number;
   height?: number;
   samples?: number;
 };
 
-const DEFAULT_RENDERBUFFER_PROPS: Required<RenderbufferProps> = {
-  id: undefined,
-  handle: undefined,
-  userData: undefined,
-  format: 0,
-  width: 1, 
-  height: 1, 
-  samples: 0
-};
-
 /**
  * Renderbuffers are GPU objects that contain images.
  * In contrast to Textures they are optimized for use as render targets, with Framebuffers.
@@ -34,36 +29,66 @@ const DEFAULT_RENDERBUFFER_PROPS: Required<RenderbufferProps> = {
  * use Textures instead.
  * Renderbuffer objects also natively accommodate Multisampling (MSAA).
  */
-export default class WEBGLRenderbuffer extends WebGLResource<RenderbufferProps> {
-  get [Symbol.toStringTag](): string { return 'Renderbuffer'; }
+export class WEBGLRenderbuffer extends WebGLResource<RenderbufferProps> {
+  static override readonly defaultProps: Required<RenderbufferProps> = {
+    id: undefined,
+    handle: undefined,
+    userData: undefined,
+    format: undefined, // 'depth16unorm'
+    width: 1,
+    height: 1,
+    samples: 0
+  };
+
+  override get [Symbol.toStringTag](): string {
+    return 'Renderbuffer';
+  }
 
-  get width(): number { return this.props.width; }
-  get height(): number { return this.props.height; }
-  get format(): number  { return this.props.format; }
-  get samples(): number { return this.props.samples; }
+  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 isSupported(gl: WebGLRenderingContext, options?: {format?: number}): boolean {
-    return !options.format || isRenderbufferFormatSupported(gl, options.format);
+  static isTextureFormatSupported(device: WebGLDevice, format: TextureFormat): boolean {
+    return isRenderbufferFormatSupported(device.gl, format, device._extensions);
   }
 
   constructor(device: WebGLDevice, props: RenderbufferProps) {
-    super(device, props, DEFAULT_RENDERBUFFER_PROPS);
+    // TODO - remove temporary sanity check
+    if (typeof props.format === 'number') {
+      throw new Error('Renderbuffer');
+    }
+    super(device, props, WEBGLRenderbuffer.defaultProps);
+    this.glFormat = convertTextureFormatToGL(this.props.format);
     this._initialize(this.props);
   }
 
-  resize(size: {width: number, height: number}): this {
+  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});
       this._initialize(this.props);
     }
-    return this;
   }
 
   // PRIVATE METHODS
 
   /** Creates and initializes a renderbuffer object's data store */
-  protected _initialize(props: Required<RenderbufferProps>) {
+  protected _initialize(props: Required<RenderbufferProps>): void {
     const {format, width, height, samples} = props;
     assert(format, 'Needs format');
 
@@ -71,34 +96,37 @@ export default class WEBGLRenderbuffer extends WebGLResource<RenderbufferProps>
 
     this.gl.bindRenderbuffer(GL.RENDERBUFFER, this.handle);
 
-    if (samples !== 0 && this.device.isWebGL2) {
-      // @ts-expect-error
-      this.gl.renderbufferStorageMultisample(GL.RENDERBUFFER, samples, format, width, height);
+    if (samples !== 0) {
+      this.gl.renderbufferStorageMultisample(
+        GL.RENDERBUFFER,
+        samples,
+        this.glFormat,
+        width,
+        height
+      );
     } else {
-      this.gl.renderbufferStorage(GL.RENDERBUFFER, format, width, height);
+      this.gl.renderbufferStorage(GL.RENDERBUFFER, this.glFormat, width, height);
     }
 
     this.gl.bindRenderbuffer(GL.RENDERBUFFER, null);
 
     this.trackAllocatedMemory(
-      width * height * (samples || 1) * getRenderbufferFormatBytesPerPixel(format)
+      width * height * (samples || 1) * getTextureFormatBytesPerPixel(this.format)
     );
-
-    return this;
   }
 
   // RESOURCE IMPLEMENTATION
 
-  _createHandle() {
+  override _createHandle() {
     return this.gl.createRenderbuffer();
   }
 
-  _deleteHandle(): void {
+  override _deleteHandle(): void {
     this.gl.deleteRenderbuffer(this.handle);
     this.trackDeallocatedMemory();
   }
 
-  _bindHandle(handle: WEBGLRenderbuffer): void {
+  override _bindHandle(handle: WEBGLRenderbuffer): void {
     this.gl.bindRenderbuffer(GL.RENDERBUFFER, handle);
   }
 }

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

@@ -1,23 +1,20 @@
-// luma.gl, MIT license
-import {Resource, assert, uid, stubRemovedMethods} from '@luma.gl/api';
-import type {Device, ResourceProps} from '@luma.gl/api';
-import GL from '@luma.gl/constants';
-import {isWebGL2, assertWebGLContext} from '../../context/context/webgl-checks';
-import WebGLDevice from '../webgl-device';
+// luma.gl
+// SPDX-License-Identifier: MIT
+// Copyright (c) vis.gl contributors
 
-// Requires full GL enum to be bundled... Make these bindings dependent on dynamic import (debug)?
-import {getKey, getKeyValue} from './constants-to-keys';
+import type {Device, ResourceProps} from '@luma.gl/core';
+import {Resource, uid, stubRemovedMethods} from '@luma.gl/core';
+import {GL} from '@luma.gl/constants';
+import {WebGLDevice} from '../webgl-device';
 
 const ERR_RESOURCE_METHOD_UNDEFINED = 'Resource subclass must define virtual methods';
 
 /**
  * Base class for WebGL object wrappers
  */
- export default abstract class WebGLResource<Props> extends Resource<Props> {
-  id: string;
-  userData: any;
+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;
 
@@ -28,18 +25,14 @@ const ERR_RESOURCE_METHOD_UNDEFINED = 'Resource subclass must define virtual met
   constructor(device: Device, props: Props, defaultProps: Required<Props>) {
     super(device, props, defaultProps);
 
-    this.device = WebGLDevice.attach(device);
+    this.device = device as WebGLDevice;
     const gl = this.device.gl;
 
-    assertWebGLContext(gl);
-
-    // extends 
-    // @ts-expect-error
-    const {id, userData = {}} = props || {};
+    // extends
+    const {id} = props || {};
     this.gl = gl;
-    this.gl2 = gl as WebGL2RenderingContext;
+    this.gl2 = gl;
     this.id = id || uid(this.constructor.name);
-    this.userData = userData;
 
     // Set the handle
     // If handle was provided, use it, otherwise create a new handle
@@ -48,7 +41,6 @@ const ERR_RESOURCE_METHOD_UNDEFINED = 'Resource subclass must define virtual met
     // this.glCount = glGetContextLossCount(this.gl);
 
     // Default VertexArray needs to be created with null handle, so compare against undefined
-    // @ts-expect-error
     this._handle = props?.handle;
     if (this._handle === undefined) {
       this._handle = this._createHandle();
@@ -57,7 +49,7 @@ const ERR_RESOURCE_METHOD_UNDEFINED = 'Resource subclass must define virtual met
     this.byteLength = 0;
   }
 
-  toString(): string {
+  override toString(): string {
     return `${this.constructor.name}(${this.id})`;
   }
 
@@ -74,11 +66,7 @@ const ERR_RESOURCE_METHOD_UNDEFINED = 'Resource subclass must define virtual met
     return this._handle;
   }
 
-  destroy(): void {
-    this.delete();
-  }
-
-  delete({deleteChildren = false} = {}) {
+  override delete({deleteChildren = false} = {}) {
     // Delete this object, and get refs to any children
     // @ts-expect-error
     const children = this._handle && this._deleteHandle(this._handle);
@@ -91,7 +79,7 @@ const ERR_RESOURCE_METHOD_UNDEFINED = 'Resource subclass must define virtual met
     // @ts-expect-error
     if (children && deleteChildren) {
       // @ts-expect-error
-      children.filter(Boolean).forEach((child) => child.delete());
+      children.filter(Boolean).forEach(child => child.destroy());
     }
 
     return this;
@@ -124,134 +112,6 @@ const ERR_RESOURCE_METHOD_UNDEFINED = 'Resource subclass must define virtual met
     this.bind(null);
   }
 
-  /**
-   * Query a Resource parameter
-   *
-   * @param name
-   * @return param
-   */
-  getParameter(pname: number, props = {}): 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?, keys?} = {}) {
-    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 ? getKey(this.gl, pname) : pname;
-        values[key] = this.getParameter(pname, options);
-        if (keys && parameter.type === 'GLenum') {
-          values[key] = getKey(this.gl, 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);