@luma.gl/webgl 9.0.0-alpha.3 → 9.0.0-alpha.31

package/src/classic/{buffer.ts → buffer-with-accessor.ts}

@@ -1,13 +1,15 @@
-import type {Device, BufferProps, TypedArray} from '@luma.gl/api';
-import {Buffer, log, assert, checkProps} from '@luma.gl/api';
-import GL from '@luma.gl/constants';
+// luma.gl, MIT license
+
+import type {Device, BufferProps, TypedArray} from '@luma.gl/core';
+import {assert, checkProps} from '@luma.gl/core';
+import {GL} from '@luma.gl/constants';
 import {assertWebGL2Context} from '../context/context/webgl-checks';
 import {AccessorObject} from '../types';
-import Accessor from './accessor';
+import {Accessor} from './accessor';
 import {getGLTypeFromTypedArray, getTypedArrayFromGLType} from './typed-array-utils';
 
-import WebGLDevice from '../adapter/webgl-device';
-import WEBGLBuffer from '../adapter/resources/webgl-buffer';
+import {WebGLDevice} from '../adapter/webgl-device';
+import {WEBGLBuffer} from '../adapter/resources/webgl-buffer';
 
 const DEBUG_DATA_LENGTH = 10;
 
@@ -40,7 +42,7 @@ const PROP_CHECKS_SET_PROPS = {
   removedProps: DEPRECATED_PROPS
 };
 
-function getWEBGLBufferProps(props: ClassicBufferProps | ArrayBufferView | number): BufferProps {
+function getWEBGLBufferProps(props: BufferWithAccessorProps | ArrayBufferView | number): BufferProps {
   // Signature `new Buffer(gl, new Float32Array(...)`
   if (ArrayBuffer.isView(props)) {
     return {data: props};
@@ -48,42 +50,41 @@ function getWEBGLBufferProps(props: ClassicBufferProps | ArrayBufferView | numbe
 
   // Signature: `new Buffer(gl, 100)`
   else if (typeof props === 'number') {
-    return {byteLength: props as number};
+    return {byteLength: props };
   }
 
   props = checkProps('Buffer', props, PROP_CHECKS_INITIALIZE);
-  const bufferProps = {...props as ClassicBufferProps};
-  if (bufferProps.offset) {
-    bufferProps.byteOffset = bufferProps.offset;
-  }
+  const bufferProps = {...props };
+  // if (bufferProps.offset) {
+  //   bufferProps.byteOffset = bufferProps.offset;
+  // }
   return bufferProps;
 }
 
 /** WebGL Buffer interface */
-export type ClassicBufferProps = BufferProps & {
+export type BufferWithAccessorProps = BufferProps & {
   handle?: WebGLBuffer;
 
-  target?: number;
-  webglUsage?: number;
-
   accessor?: AccessorObject;
 
-  /** @deprecated */
-  index?: number;
-  /** @deprecated */
-  offset?: number;
-  /** @deprecated */
-  size?: number;
-  /** @deprecated */
-  type?: number
+  // target?: number;
+  // glUsage?: number;
+  // /** @deprecated */
+  // index?: number;
+  // /** @deprecated */
+  // offset?: number;
+  // /** @deprecated */
+  // size?: number;
+  // /** @deprecated */
+  // type?: number
 }
 
 /** WebGL Buffer interface */
-export default class ClassicBuffer extends WEBGLBuffer {
+export class BufferWithAccessor extends WEBGLBuffer {
   usage: number;
   accessor: Accessor;
 
-  constructor(device: Device | WebGLRenderingContext, props?: ClassicBufferProps);
+  constructor(device: Device | WebGLRenderingContext, props?: BufferWithAccessorProps);
   constructor(device: Device | WebGLRenderingContext, data: ArrayBufferView | number[]);
   constructor(device: Device | WebGLRenderingContext, byteLength: number);
 
@@ -94,7 +95,7 @@ export default class ClassicBuffer extends WEBGLBuffer {
     // this.initialize(props);
 
     // Deprecated: Merge main props and accessor
-    this.setAccessor(Object.assign({}, props, (props as ClassicBufferProps).accessor));
+    this.setAccessor(Object.assign({}, props, (props as BufferWithAccessorProps).accessor));
 
     // infer GL type from supplied typed array
     if (this.props.data) {
@@ -106,19 +107,10 @@ export default class ClassicBuffer extends WEBGLBuffer {
     Object.seal(this);
   }
 
-  destroy(): void {
-    if (this.handle) {
-      this.removeStats();
-      this.trackDeallocatedMemory();
-      this.gl.deleteBuffer(this.handle);
-      // @ts-expect-error
-      this.handle = null;
-    }
-  }
+  // override write(data: TypedArray, byteOffset: number = 0): void {
+  //   this.subData({data, offset: byteOffset});
+  // }
 
-  write(data: TypedArray, byteOffset?: number): void {
-    this.subData({data, offset: byteOffset});
-  }
   // returns number of elements in the buffer (assuming that the full buffer is used)
   getElementCount(accessor: AccessorObject = this.accessor): number {
     return Math.round(this.byteLength / Accessor.getBytesPerElement(accessor));
@@ -133,7 +125,7 @@ export default class ClassicBuffer extends WEBGLBuffer {
   // Signature: `new Buffer(gl, {data: new Float32Array(...)})`
   // Signature: `new Buffer(gl, new Float32Array(...))`
   // Signature: `new Buffer(gl, 100)`
-  initialize(props: ClassicBufferProps = {}): this {
+  initialize(props: BufferWithAccessorProps = {}): this {
     // Signature `new Buffer(gl, new Float32Array(...)`
     if (ArrayBuffer.isView(props)) {
       props = {data: props};
@@ -148,7 +140,8 @@ export default class ClassicBuffer extends WEBGLBuffer {
     props = checkProps('Buffer', props, PROP_CHECKS_INITIALIZE);
 
     // Initialize member fields
-    this.webglUsage = props.webglUsage || GL.STATIC_DRAW;
+    // @ts-expect-error readonly field
+    this.glUsage = props.glUsage || GL.STATIC_DRAW;
     this.debugData = null;
 
     // Deprecated: Merge main props and accessor
@@ -156,7 +149,7 @@ export default class ClassicBuffer extends WEBGLBuffer {
 
     // Set data: (re)initializes the buffer
     if (props.data) {
-      this._setData(props.data, props.offset, props.byteLength);
+      this._setData(props.data, props.byteOffset, props.byteLength);
     } else {
       this._setByteLength(props.byteLength || 0);
     }
@@ -164,7 +157,7 @@ export default class ClassicBuffer extends WEBGLBuffer {
     return this;
   }
 
-  setProps(props: ClassicBufferProps): this {
+  setProps(props: BufferWithAccessorProps): this {
     props = checkProps('Buffer', props, PROP_CHECKS_SET_PROPS);
 
     if ('accessor' in props) {
@@ -204,7 +197,7 @@ export default class ClassicBuffer extends WEBGLBuffer {
   }
 
   // Update with new data. Reinitializes the buffer
-  setData(props: ClassicBufferProps) {
+  setData(props: BufferWithAccessorProps) {
     return this.initialize(props);
   }
 
@@ -227,17 +220,17 @@ export default class ClassicBuffer extends WEBGLBuffer {
     // 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
     // @ts-expect-error
-    const target = this.gl.webgl2 ? GL.COPY_WRITE_BUFFER : this.target;
-    this.gl.bindBuffer(target, this.handle);
+    const glTarget = this.gl.webgl2 ? GL.COPY_WRITE_BUFFER : this.glTarget;
+    this.gl.bindBuffer(glTarget, this.handle);
     // WebGL2: subData supports additional srcOffset and length parameters
     if (srcOffset !== 0 || byteLength !== undefined) {
       assertWebGL2Context(this.gl);
       // @ts-expect-error
-      this.gl.bufferSubData(this.target, offset, data, srcOffset, byteLength);
+      this.gl.bufferSubData(this.glTarget, offset, data, srcOffset, byteLength);
     } else {
-      this.gl.bufferSubData(target, offset, data);
+      this.gl.bufferSubData(glTarget, offset, data);
     }
-    this.gl.bindBuffer(target, null);
+    this.gl.bindBuffer(glTarget, null);
 
     // TODO - update local `data` if offsets are right
     this.debugData = null;
@@ -264,7 +257,7 @@ export default class ClassicBuffer extends WEBGLBuffer {
     // Use GL.COPY_READ_BUFFER+GL.COPY_WRITE_BUFFER avoid disturbing other targets and locking type
     gl.bindBuffer(GL.COPY_READ_BUFFER, sourceBuffer.handle);
     gl.bindBuffer(GL.COPY_WRITE_BUFFER, this.handle);
-    gl2.copyBufferSubData(GL.COPY_READ_BUFFER, GL.COPY_WRITE_BUFFER, readOffset, writeOffset, size);
+    gl2?.copyBufferSubData(GL.COPY_READ_BUFFER, GL.COPY_WRITE_BUFFER, readOffset, writeOffset, size);
     gl.bindBuffer(GL.COPY_READ_BUFFER, null);
     gl.bindBuffer(GL.COPY_WRITE_BUFFER, null);
 
@@ -278,7 +271,7 @@ export default class ClassicBuffer extends WEBGLBuffer {
    * Reads data from buffer into an ArrayBufferView or SharedArrayBuffer.
    * @note WEBGL2 ONLY
    */
-  getData(options?: {
+  override getData(options?: {
     dstData?: any;
     srcByteOffset?: number;
     dstOffset?: number;
@@ -314,7 +307,7 @@ export default class ClassicBuffer extends WEBGLBuffer {
 
     // 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, srcByteOffset, dstData, dstOffset, length);
+    this.gl2?.getBufferSubData(GL.COPY_READ_BUFFER, srcByteOffset, dstData, dstOffset, length);
     this.gl.bindBuffer(GL.COPY_READ_BUFFER, null);
 
     // TODO - update local `data` if offsets are 0
@@ -328,9 +321,9 @@ export default class ClassicBuffer extends WEBGLBuffer {
    *   - GL.UNIFORM_BUFFER: `offset` must be aligned to GL.UNIFORM_BUFFER_OFFSET_ALIGNMENT.
    *   - GL.UNIFORM_BUFFER: `size` must be a minimum of GL.UNIFORM_BLOCK_SIZE_DATA.
    */
-  bind(options?: {target?: number; index?: any; offset?: number; size: any}): this {
+  bind(options?: {glTarget?: number; index?: any; offset?: number; size?: any}): this {
     const {
-      target = this.target, // target for the bind operation
+      glTarget = this.glTarget, // target for the bind operation
       index = this.accessor && this.accessor.index, // index = index of target (indexed bind point)
       offset = 0,
       size
@@ -338,27 +331,27 @@ export default class ClassicBuffer extends WEBGLBuffer {
     // NOTE: While GL.TRANSFORM_FEEDBACK_BUFFER and GL.UNIFORM_BUFFER could
     // be used as direct binding points, they will not affect transform feedback or
     // uniform buffer state. Instead indexed bindings need to be made.
-    if (target === GL.UNIFORM_BUFFER || target === GL.TRANSFORM_FEEDBACK_BUFFER) {
+    if (glTarget === GL.UNIFORM_BUFFER || glTarget === GL.TRANSFORM_FEEDBACK_BUFFER) {
       if (size !== undefined) {
-        this.gl2.bindBufferRange(target, index, this.handle, offset, size);
+        this.gl2?.bindBufferRange(glTarget, index, this.handle, offset, size);
       } else {
         assert(offset === 0); // Make sure offset wasn't supplied
-        this.gl2.bindBufferBase(target, index, this.handle);
+        this.gl2?.bindBufferBase(glTarget, index, this.handle);
       }
     } else {
-      this.gl.bindBuffer(target, this.handle);
+      this.gl.bindBuffer(glTarget, this.handle);
     }
 
     return this;
   }
 
-  unbind(options?: {target?: any; index?: any}): this {
-    const {target = this.target, index = this.accessor && this.accessor.index} = options || {};
-    const isIndexedBuffer = target === GL.UNIFORM_BUFFER || target === GL.TRANSFORM_FEEDBACK_BUFFER;
+  unbind(options?: {glTarget?: any; index?: any}): this {
+    const {glTarget = this.glTarget, index = this.accessor && this.accessor.index} = options || {};
+    const isIndexedBuffer = glTarget === GL.UNIFORM_BUFFER || glTarget === GL.TRANSFORM_FEEDBACK_BUFFER;
     if (isIndexedBuffer) {
-      this.gl2.bindBufferBase(target, index, null);
+      this.gl2?.bindBufferBase(glTarget, index, null);
     } else {
-      this.gl.bindBuffer(target, null);
+      this.gl.bindBuffer(glTarget, null);
     }
     return this;
   }
@@ -369,7 +362,7 @@ export default class ClassicBuffer extends WEBGLBuffer {
   getDebugData(): {
     data: any;
     changed: boolean;
-  } {
+    } {
     if (!this.debugData) {
       this.debugData = this.getData({length: Math.min(DEBUG_DATA_LENGTH, this.byteLength)});
       return {data: this.debugData, changed: true};
@@ -391,7 +384,7 @@ export default class ClassicBuffer extends WEBGLBuffer {
 
     const target = this._getTarget();
     this.gl.bindBuffer(target, this.handle);
-    this.gl.bufferData(target, byteLength, this.webglUsage);
+    this.gl.bufferData(target, byteLength, this.glUsage);
     this.gl.bufferSubData(target, offset, data);
     this.gl.bindBuffer(target, null);
 
@@ -408,7 +401,7 @@ export default class ClassicBuffer extends WEBGLBuffer {
   }
 
   // Allocate a GPU buffer of specified size.
-  _setByteLength(byteLength: number, webglUsage = this.webglUsage): this {
+  _setByteLength(byteLength: number): this {
     assert(byteLength >= 0);
 
     this.trackDeallocatedMemory();
@@ -421,12 +414,11 @@ export default class ClassicBuffer extends WEBGLBuffer {
       data = new Float32Array(0);
     }
 
-    const target = this._getTarget();
-    this.gl.bindBuffer(target, this.handle);
-    this.gl.bufferData(target, data, webglUsage);
-    this.gl.bindBuffer(target, null);
+    const glTarget = this._getTarget();
+    this.gl.bindBuffer(glTarget, this.handle);
+    this.gl.bufferData(glTarget, data, this.glUsage);
+    this.gl.bindBuffer(glTarget, null);
 
-    this.webglUsage = webglUsage;
     this.debugData = null;
     this.bytesUsed = byteLength;
     this.byteLength = byteLength;
@@ -440,7 +432,7 @@ export default class ClassicBuffer extends WEBGLBuffer {
   // In WebGL2, use GL.COPY_WRITE_BUFFER to avoid locking the type
   _getTarget() {
     // @ts-expect-error
-    return this.gl.webgl2 ? GL.COPY_WRITE_BUFFER : this.target;
+    return this.gl.webgl2 ? GL.COPY_WRITE_BUFFER : this.glTarget;
   }
 
   _getAvailableElementCount(srcByteOffset: number) {
@@ -460,9 +452,9 @@ export default class ClassicBuffer extends WEBGLBuffer {
   // RESOURCE METHODS
 
   getParameter(pname: GL): any {
-    this.gl.bindBuffer(this.target, this.handle);
-    const value = this.gl.getBufferParameter(this.target, pname);
-    this.gl.bindBuffer(this.target, null);
+    this.gl.bindBuffer(this.glTarget, this.handle);
+    const value = this.gl.getBufferParameter(this.glTarget, pname);
+    this.gl.bindBuffer(this.glTarget, null);
     return value;
   }
 

package/src/classic/clear.ts

@@ -0,0 +1,110 @@
+import {Device, Framebuffer, assert} from '@luma.gl/core';
+import {WebGLDevice} from '../adapter/webgl-device';
+import {withParameters} from '../context/state-tracker/with-parameters';
+
+// Should collapse during minification
+const GL_DEPTH_BUFFER_BIT = 0x00000100;
+const GL_STENCIL_BUFFER_BIT = 0x00000400;
+const GL_COLOR_BUFFER_BIT = 0x00004000;
+
+const GL_COLOR = 0x1800;
+const GL_DEPTH = 0x1801;
+const GL_STENCIL = 0x1802;
+const GL_DEPTH_STENCIL = 0x84f9;
+
+// Should disappear if asserts are removed
+const ERR_ARGUMENTS = 'clear: bad arguments';
+
+/** 
+ * Optionally clears depth, color and stencil buffers 
+ * @deprecated Set clear color when creating a RenderPass.
+ */
+export function clear(
+  gl: Device | WebGLRenderingContext,
+  options?: {framebuffer?: Framebuffer; color?: any; depth?: any; stencil?: any}
+): void {
+  const device = WebGLDevice.attach(gl);
+  const {framebuffer = null, color = null, depth = null, stencil = null} = options || {};
+  const parameters: any = {};
+
+  if (framebuffer) {
+    parameters.framebuffer = framebuffer;
+  }
+
+  let clearFlags = 0;
+
+  if (color) {
+    clearFlags |= GL_COLOR_BUFFER_BIT;
+    if (color !== true) {
+      parameters.clearColor = color;
+    }
+  }
+
+  if (depth) {
+    clearFlags |= GL_DEPTH_BUFFER_BIT;
+    if (depth !== true) {
+      parameters.clearDepth = depth;
+    }
+  }
+
+  if (stencil) {
+    clearFlags |= GL_STENCIL_BUFFER_BIT;
+    if (depth !== true) {
+      parameters.clearStencil = depth;
+    }
+  }
+
+  assert(clearFlags !== 0, ERR_ARGUMENTS);
+
+  // Temporarily set any clear "colors" and call clear
+  withParameters(device.gl, parameters, () => {
+    device.gl.clear(clearFlags);
+  });
+}
+
+/** 
+ * WebGL2 - clear a specific drawing buffer 
+ * @deprecated Set clear color when creating a RenderPass
+ */
+export function clearBuffer(
+  gl: Device | WebGLRenderingContext,
+  options?: {framebuffer?: Framebuffer; buffer?: any; drawBuffer?: any; value?: any}
+) {
+  const device = WebGLDevice.attach(gl);
+
+  const {framebuffer = null, buffer = GL_COLOR, drawBuffer = 0, value = [0, 0, 0, 0]} = options || {};
+  withParameters(device.gl2, {framebuffer}, () => {
+    // Method selection per OpenGL ES 3 docs
+    switch (buffer) {
+      case GL_COLOR:
+        switch (value.constructor) {
+          case Int32Array:
+            device.gl2.clearBufferiv(buffer, drawBuffer, value);
+            break;
+          case Uint32Array:
+            device.gl2.clearBufferuiv(buffer, drawBuffer, value);
+            break;
+          case Float32Array:
+          default:
+            device.gl2.clearBufferfv(buffer, drawBuffer, value);
+        }
+        break;
+
+      case GL_DEPTH:
+        device.gl2.clearBufferfv(GL_DEPTH, 0, [value]);
+        break;
+
+      case GL_STENCIL:
+        device.gl2.clearBufferiv(GL_STENCIL, 0, [value]);
+        break;
+
+      case GL_DEPTH_STENCIL:
+        const [depth, stencil] = value;
+        device.gl2.clearBufferfi(GL_DEPTH_STENCIL, 0, depth, stencil);
+        break;
+
+      default:
+        assert(false, ERR_ARGUMENTS);
+    }
+  });
+}