@luma.gl/webgl 8.5.10 → 8.6.0-alpha.1

package/src/classes/{vertex-array.js → vertex-array.ts}

@@ -1,10 +1,11 @@
 import GL from '@luma.gl/constants';
 import {log} from '@luma.gl/gltools';
 import Accessor from './accessor';
-import Buffer from './buffer';
-import VertexArrayObject from './vertex-array-object';
-import {assert} from '../utils/assert';
-import {stubRemovedMethods} from '../utils/stub-methods';
+import Buffer from './webgl-buffer';
+import Program from './program'; 
+import ProgramConfiguration from './program-configuration';
+import VertexArrayObject, {VertexArrayObjectProps} from './vertex-array-object';
+import {assert, stubRemovedMethods} from '../utils';
 
 const ERR_ATTRIBUTE_TYPE =
   'VertexArray: attributes must be Buffers or constants (i.e. typed array)';
@@ -14,48 +15,61 @@ const ERR_ATTRIBUTE_TYPE =
 // in vertex-array.md
 const MULTI_LOCATION_ATTRIBUTE_REGEXP = /^(.+)__LOCATION_([0-9]+)$/;
 
-const DEPRECATIONS_V6 = [
-  'setBuffers',
-  'setGeneric',
-  'clearBindings',
-  'setLocations',
-  'setGenericValues',
-  'setDivisor',
-  'enable',
-  'disable'
-];
+export type VertexArrayProps = {
+  id?: string;
+  program?: Program;
+  configuration?: ProgramConfiguration;
+  attributes?: any[];
+  elements?: any;
+  bindOnUse?: boolean;
+};
+
+export type DrawParams = {
+  elementCount: number;
+  indexType: Uint16ArrayConstructor | Uint32ArrayConstructor;
+  indexOffset: number;
+  isIndexed: boolean;
+  isInstanced: boolean;
+  indexCount: number;
+  vertexCount: number;
+  instanceCount: number;
+};
 
 export default class VertexArray {
-  constructor(gl, opts = {}) {
+  id: string;
+  gl: WebGLRenderingContext;
+  readonly attributes: object = {};
+
+  vertexArrayObject: VertexArrayObject;
+  accessors: Accessor[] = [];
+  configuration: ProgramConfiguration | null = null;
+
+  // Extracted information
+  elements = null;
+  elementsAccessor = null;
+  values = null;
+  unused = null;
+  drawParams = null;
+  buffer = null; // For attribute 0 on desktops, and created when unbinding buffers
+  
+  bindOnUse = false;
+
+  constructor(gl: WebGLRenderingContext, props?: VertexArrayProps) {
     // Use program's id if program is supplied but no id is supplied
-    const id = opts.id || (opts.program && opts.program.id);
-    // super(gl, Object.assign({}, opts, {id}));
+    const id = props?.id || (props?.program && props?.program.id);
+    // super(gl, Object.assign({}, props, {id}));
+
+    this.vertexArrayObject = new VertexArrayObject(gl);
 
     this.id = id;
     this.gl = gl;
     this.configuration = null;
 
-    // Extracted information
-    this.elements = null;
-    this.elementsAccessor = null;
-    this.values = null;
-    this.accessors = null;
-    this.unused = null;
-    this.drawParams = null;
-    this.buffer = null; // For attribute 0 on desktops, and created when unbinding buffers
-
-    this.attributes = {};
-
-    this.vertexArrayObject = new VertexArrayObject(gl);
-
-    // Issue errors when using removed methods
-    stubRemovedMethods(this, 'VertexArray', 'v6.0', DEPRECATIONS_V6);
-
-    this.initialize(opts);
+    this.initialize(props);
     Object.seal(this);
   }
 
-  delete() {
+  delete(): void {
     if (this.buffer) {
       this.buffer.delete();
     }
@@ -63,11 +77,11 @@ export default class VertexArray {
     this.vertexArrayObject.delete();
   }
 
-  initialize(props = {}) {
+  initialize(props?: VertexArrayProps) {
     this.reset();
     this.configuration = null;
     this.bindOnUse = false;
-    return this.setProps(props);
+    return this.setProps(props || {});
   }
 
   // Resets all attributes (to default valued constants)
@@ -87,7 +101,7 @@ export default class VertexArray {
     return this;
   }
 
-  setProps(props) {
+  setProps(props: VertexArrayProps) {
     if ('program' in props) {
       this.configuration = props.program && props.program.configuration;
     }
@@ -101,17 +115,18 @@ export default class VertexArray {
       this.setElementBuffer(props.elements);
     }
     if ('bindOnUse' in props) {
+      // @ts-expect-error
       props = props.bindOnUse;
     }
     return this;
   }
 
   // Automatically called if buffers changed through VertexArray API
-  clearDrawParams() {
+  clearDrawParams(): void {
     this.drawParams = null;
   }
 
-  getDrawParams() {
+  getDrawParams(): DrawParams {
     // Auto deduced draw parameters
     this.drawParams = this.drawParams || this._updateDrawParams();
 
@@ -125,7 +140,7 @@ export default class VertexArray {
   //     {attributeName: buffer}
   //     {attributeName: [buffer, accessor]}
   //     {attributeName: (typed) array} => constant
-  setAttributes(attributes) {
+  setAttributes(attributes): this {
     Object.assign(this.attributes, attributes);
     this.vertexArrayObject.bind(() => {
       for (const locationOrName in attributes) {
@@ -141,7 +156,7 @@ export default class VertexArray {
 
   // Set (bind) an elements buffer, for indexed rendering.
   // Must be a Buffer bound to GL.ELEMENT_ARRAY_BUFFER. Constants not supported
-  setElementBuffer(elementBuffer = null, accessor = {}) {
+  setElementBuffer(elementBuffer: Buffer | null = null, accessor = {}): this {
     this.elements = elementBuffer; // Save value for debugging
     this.elementsAccessor = accessor;
     this.clearDrawParams();
@@ -151,10 +166,11 @@ export default class VertexArray {
   }
 
   // Set a location in vertex attributes array to a buffer
-  setBuffer(locationOrName, buffer, appAccessor = {}) {
+  setBuffer(locationOrName, buffer: Buffer, appAccessor = {}): this {
     // Check target
     if (buffer.target === GL.ELEMENT_ARRAY_BUFFER) {
-      return this.setElementBuffer(buffer, appAccessor);
+      this.setElementBuffer(buffer, appAccessor);
+      return this;
     }
 
     const {location, accessor} = this._resolveLocationAndAccessor(
@@ -175,13 +191,14 @@ export default class VertexArray {
   }
 
   // Set attribute to constant value (small typed array corresponding to one vertex' worth of data)
-  setConstant(locationOrName, arrayValue, appAccessor = {}) {
+  setConstant(locationOrName, arrayValue, appAccessor = {}): this {
+    // @ts-expect-error
     const {location, accessor} = this._resolveLocationAndAccessor(
       locationOrName,
       arrayValue,
       // Ensure that size isn't taken from program for multi-column
       // attributes
-      Object.assign({size: arrayValue.length}, appAccessor)
+      {size: arrayValue.length, ...appAccessor}
     );
 
     if (location >= 0) {
@@ -203,7 +220,7 @@ export default class VertexArray {
 
   // Workaround for Chrome TransformFeedback binding issue
   // If required, unbind temporarily to avoid conflicting with TransformFeedback
-  unbindBuffers() {
+  unbindBuffers(): this {
     this.vertexArrayObject.bind(() => {
       if (this.elements) {
         this.vertexArrayObject.setElementBuffer(null);
@@ -228,7 +245,7 @@ export default class VertexArray {
 
   // Workaround for Chrome TransformFeedback binding issue
   // If required, rebind rebind after temporary unbind
-  bindBuffers() {
+  bindBuffers(): this {
     this.vertexArrayObject.bind(() => {
       if (this.elements) {
         this.setElementBuffer(this.elements);
@@ -325,7 +342,7 @@ export default class VertexArray {
     return {location: -1};
   }
 
-  _setAttribute(locationOrName, value) {
+  _setAttribute(locationOrName, value): void {
     if (value instanceof Buffer) {
       //  Signature: {attributeName: Buffer}
       this.setBuffer(locationOrName, value);
@@ -352,7 +369,7 @@ export default class VertexArray {
   // Updates all constant attribute values (constants are used when vertex attributes are disabled).
   // This needs to be done repeatedly since in contrast to buffer bindings,
   // constants are stored on the WebGL context, not the VAO
-  _setConstantAttributes(vertexCount, instanceCount) {
+  _setConstantAttributes(vertexCount, instanceCount): void {
     // TODO - use accessor to determine what length to use
     const elementCount = Math.max(vertexCount | 0, instanceCount | 0);
     let constant = this.values[0];
@@ -368,7 +385,7 @@ export default class VertexArray {
     }
   }
 
-  _setConstantAttributeZero(constant, elementCount) {
+  _setConstantAttributeZero(constant, elementCount: number): void {
     if (VertexArrayObject.isSupported(this.gl, {constantAttributeZero: true})) {
       this._setConstantAttribute(0, constant);
       return;
@@ -381,13 +398,16 @@ export default class VertexArray {
     this.vertexArrayObject.setBuffer(0, buffer, this.accessors[0]);
   }
 
-  _setConstantAttribute(location, constant) {
+  _setConstantAttribute(location, constant): void {
     VertexArrayObject.setConstant(this.gl, location, constant);
   }
 
   // Walks the buffers and updates draw parameters
-  _updateDrawParams() {
+  _updateDrawParams(): DrawParams {
     const drawParams = {
+      elementCount: 0,
+      indexType: Uint16Array,
+      indexOffset: 0,
       isIndexed: false,
       isInstanced: false,
       indexCount: Infinity,
@@ -422,7 +442,7 @@ export default class VertexArray {
     return drawParams;
   }
 
-  _updateDrawParamsForLocation(drawParams, location) {
+  _updateDrawParamsForLocation(drawParams: DrawParams, location): void {
     const value = this.values[location];
     const accessor = this.accessors[location];
 

package/src/classes/{buffer.js → webgl-buffer.ts}

@@ -1,10 +1,10 @@
 import GL from '@luma.gl/constants';
-import Resource from './resource';
+import {getWebGL2Context, assertWebGL2Context, log} from '@luma.gl/gltools';
+import {Buffer, BufferProps} from '@luma.gl/api';
+import {AccessorObject} from '../types';
 import Accessor from './accessor';
-import {getGLTypeFromTypedArray, getTypedArrayFromGLType} from '../webgl-utils/typed-array-utils';
-import {assertWebGL2Context, log} from '@luma.gl/gltools';
-import {assert} from '../utils/assert';
-import {checkProps} from '../utils/check-props';
+import {getGLTypeFromTypedArray, getTypedArrayFromGLType} from '../webgl-utils';
+import {assert, checkProps} from '../utils';
 
 const DEBUG_DATA_LENGTH = 10;
 
@@ -37,16 +37,57 @@ const PROP_CHECKS_SET_PROPS = {
   removedProps: DEPRECATED_PROPS
 };
 
-export default class Buffer extends Resource {
-  constructor(gl, props = {}) {
-    super(gl, props);
+/** WebGL Buffer interface */
+export type WebGLBufferProps = BufferProps & {
+  handle?: WebGLBuffer;
+  data?: any; // ArrayBufferView;
+  byteLength?: number;
+  target?: number;
+  usage?: number;
+  accessor?: AccessorObject;
+
+  /** @deprecated */
+  index?: number;
+  /** @deprecated */
+  offset?: number;
+  /** @deprecated */
+  size?: number;
+  /** @deprecated */
+  type?: number
+}
+
+/** WebGL Buffer interface */
+export default class WEBGLBuffer extends Buffer {
+  readonly gl: WebGLRenderingContext;
+  readonly gl2: WebGL2RenderingContext | null;
+  readonly handle: WebGLBuffer;
+
+  target: number;
+  usage: number;
+
+  byteLength: number;
+  bytesUsed: number;
+
+  accessor: Accessor;
 
-    this.stubRemovedMethods('Buffer', 'v6.0', ['layout', 'setLayout', 'getIndexedParameter']);
-    // this.stubRemovedMethods('Buffer', 'v7.0', ['updateAccessor']);
+  debugData;
+
+  constructor(gl: WebGLRenderingContext, props?: BufferProps);
+  constructor(gl: WebGLRenderingContext, data: ArrayBufferView | number[]);
+  constructor(gl: WebGLRenderingContext, byteLength: number);
+
+  constructor(gl: WebGLRenderingContext, props = {}) {
+    super(gl as any, props);
+
+    this.gl = gl;
+    this.gl2 = getWebGL2Context(gl);
+    const handle = typeof props === 'object' ? (props as BufferProps).handle : undefined;
+    this.handle = handle || this.gl.createBuffer();
 
     // In WebGL1, need to make sure we use GL.ELEMENT_ARRAY_BUFFER when initializing element buffers
     // otherwise buffer type will lock to generic (non-element) buffer
     // In WebGL2, we can use GL.COPY_READ_BUFFER which avoids locking the type here
+    // @ts-expect-error
     this.target = props.target || (this.gl.webgl2 ? GL.COPY_READ_BUFFER : GL.ARRAY_BUFFER);
 
     this.initialize(props);
@@ -54,13 +95,23 @@ export default class Buffer extends Resource {
     Object.seal(this);
   }
 
+  destroy(): void {
+    if (this.handle) {
+      this.removeStats();
+      this.trackDeallocatedMemory();
+      this.gl.deleteBuffer(this.handle);
+      // @ts-expect-error
+      this.handle = null;
+    }
+  }
+
   // returns number of elements in the buffer (assuming that the full buffer is used)
-  getElementCount(accessor = this.accessor) {
+  getElementCount(accessor = this.accessor): number {
     return Math.round(this.byteLength / Accessor.getBytesPerElement(accessor));
   }
 
   // returns number of vertices in the buffer (assuming that the full buffer is used)
-  getVertexCount(accessor = this.accessor) {
+  getVertexCount(accessor = this.accessor): number {
     return Math.round(this.byteLength / Accessor.getBytesPerVertex(accessor));
   }
 
@@ -68,7 +119,7 @@ export default class Buffer extends Resource {
   // Signature: `new Buffer(gl, {data: new Float32Array(...)})`
   // Signature: `new Buffer(gl, new Float32Array(...))`
   // Signature: `new Buffer(gl, 100)`
-  initialize(props = {}) {
+  initialize(props: BufferProps = {}): this {
     // Signature `new Buffer(gl, new Float32Array(...)`
     if (ArrayBuffer.isView(props)) {
       props = {data: props};
@@ -76,6 +127,7 @@ export default class Buffer extends Resource {
 
     // Signature: `new Buffer(gl, 100)`
     if (Number.isFinite(props)) {
+      // @ts-expect-error
       props = {byteLength: props};
     }
 
@@ -98,7 +150,7 @@ export default class Buffer extends Resource {
     return this;
   }
 
-  setProps(props) {
+  setProps(props: BufferProps): this {
     props = checkProps('Buffer', props, PROP_CHECKS_SET_PROPS);
 
     if ('accessor' in props) {
@@ -110,7 +162,7 @@ export default class Buffer extends Resource {
 
   // Optionally stores an accessor with the buffer, makes it easier to use it as an attribute later
   // {type, size = 1, offset = 0, stride = 0, normalized = false, integer = false, divisor = 0}
-  setAccessor(accessor) {
+  setAccessor(accessor): this {
     // NOTE: From luma.gl v7.0, Accessors have an optional `buffer `field
     // (mainly to support "interleaving")
     // To avoid confusion, ensure `buffer.accessor` does not have a `buffer.accessor.buffer` field:
@@ -159,11 +211,13 @@ export default class Buffer extends Resource {
 
     // 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);
     // 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);
     } else {
       this.gl.bufferSubData(target, offset, data);
@@ -178,15 +232,24 @@ export default class Buffer extends Resource {
     return this;
   }
 
-  // WEBGL2 ONLY: Copies part of the data of another buffer into this buffer
-  copyData({sourceBuffer, readOffset = 0, writeOffset = 0, size}) {
-    const {gl} = this;
+  /**
+   * Copies part of the data of another buffer into this buffer 
+   * @note WEBGL2 ONLY
+   */
+  copyData(options: {
+    sourceBuffer: any;
+    readOffset?: number;
+    writeOffset?: number;
+    size: any;
+  }): this {
+    const {sourceBuffer, readOffset = 0, writeOffset = 0, size} = options;
+    const {gl, gl2} = this;
     assertWebGL2Context(gl);
 
     // 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);
-    gl.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);
 
@@ -196,8 +259,18 @@ export default class Buffer extends Resource {
     return this;
   }
 
-  // WEBGL2 ONLY: Reads data from buffer into an ArrayBufferView or SharedArrayBuffer.
-  getData({dstData = null, srcByteOffset = 0, dstOffset = 0, length = 0} = {}) {
+  /**
+   * Reads data from buffer into an ArrayBufferView or SharedArrayBuffer.
+   * @note WEBGL2 ONLY
+   */
+  getData(options?: {
+    dstData?: any;
+    srcByteOffset?: number;
+    dstOffset?: number;
+    length?: number;
+  }): any {
+    let {dstData = null, length = 0} = options || {};
+    const {srcByteOffset = 0, dstOffset = 0} = options || {};
     assertWebGL2Context(this.gl);
 
     const ArrayType = getTypedArrayFromGLType(this.accessor.type || GL.FLOAT, {clamped: false});
@@ -226,7 +299,7 @@ export default class Buffer extends Resource {
 
     // Use GL.COPY_READ_BUFFER to avoid disturbing other targets and locking type
     this.gl.bindBuffer(GL.COPY_READ_BUFFER, this.handle);
-    this.gl.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
@@ -240,21 +313,23 @@ export default class Buffer extends Resource {
    *   - 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({
-    target = this.target, // target for the bind operation
-    index = this.accessor && this.accessor.index, // index = index of target (indexed bind point)
-    offset = 0,
-    size
-  } = {}) {
+  bind(options?: {target?: number; index?: any; offset?: number; size: any}): this {
+    const {
+      target = this.target, // target for the bind operation
+      // @ts-expect-error
+      index = this.accessor && this.accessor.index, // index = index of target (indexed bind point)
+      offset = 0,
+      size
+    } = options || {};
     // 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 (size !== undefined) {
-        this.gl.bindBufferRange(target, index, this.handle, offset, size);
+        this.gl2.bindBufferRange(target, index, this.handle, offset, size);
       } else {
         assert(offset === 0); // Make sure offset wasn't supplied
-        this.gl.bindBufferBase(target, index, this.handle);
+        this.gl2.bindBufferBase(target, index, this.handle);
       }
     } else {
       this.gl.bindBuffer(target, this.handle);
@@ -263,10 +338,12 @@ export default class Buffer extends Resource {
     return this;
   }
 
-  unbind({target = this.target, index = this.accessor && this.accessor.index} = {}) {
+  unbind(options?: {target?: any; index?: any}): this {
+    // @ts-expect-error
+    const {target = this.target, index = this.accessor && this.accessor.index} = options || {};
     const isIndexedBuffer = target === GL.UNIFORM_BUFFER || target === GL.TRANSFORM_FEEDBACK_BUFFER;
     if (isIndexedBuffer) {
-      this.gl.bindBufferBase(target, index, null);
+      this.gl2.bindBufferBase(target, index, null);
     } else {
       this.gl.bindBuffer(target, null);
     }
@@ -276,7 +353,10 @@ export default class Buffer extends Resource {
   // PROTECTED METHODS (INTENDED FOR USE BY OTHER FRAMEWORK CODE ONLY)
 
   // Returns a short initial data array
-  getDebugData() {
+  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};
@@ -291,10 +371,10 @@ export default class Buffer extends Resource {
   // PRIVATE METHODS
 
   // Allocate a new buffer and initialize to contents of typed array
-  _setData(data, offset = 0, byteLength = data.byteLength + offset) {
+  _setData(data, offset: number = 0, byteLength: number = data.byteLength + offset): this {
     assert(ArrayBuffer.isView(data));
 
-    this._trackDeallocatedMemory();
+    this.trackDeallocatedMemory();
 
     const target = this._getTarget();
     this.gl.bindBuffer(target, this.handle);
@@ -304,8 +384,8 @@ export default class Buffer extends Resource {
 
     this.debugData = data.slice(0, DEBUG_DATA_LENGTH);
     this.bytesUsed = byteLength;
-
-    this._trackAllocatedMemory(byteLength);
+    this.byteLength = byteLength;
+    this.trackAllocatedMemory(byteLength);
 
     // infer GL type from supplied typed array
     const type = getGLTypeFromTypedArray(data);
@@ -315,15 +395,16 @@ export default class Buffer extends Resource {
   }
 
   // Allocate a GPU buffer of specified size.
-  _setByteLength(byteLength, usage = this.usage) {
+  _setByteLength(byteLength: number, usage = this.usage): this {
     assert(byteLength >= 0);
 
-    this._trackDeallocatedMemory();
+    this.trackDeallocatedMemory();
 
     // Workaround needed for Safari (#291):
     // gl.bufferData with size equal to 0 crashes. Instead create zero sized array.
     let data = byteLength;
     if (byteLength === 0) {
+      // @ts-expect-error
       data = new Float32Array(0);
     }
 
@@ -335,8 +416,9 @@ export default class Buffer extends Resource {
     this.usage = usage;
     this.debugData = null;
     this.bytesUsed = byteLength;
+    this.byteLength = byteLength;
 
-    this._trackAllocatedMemory(byteLength);
+    this.trackAllocatedMemory(byteLength);
 
     return this;
   }
@@ -344,6 +426,7 @@ export default class Buffer extends Resource {
   // Binding a buffer for the first time locks the type
   // 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;
   }
 
@@ -363,16 +446,7 @@ export default class Buffer extends Resource {
 
   // RESOURCE METHODS
 
-  _createHandle() {
-    return this.gl.createBuffer();
-  }
-
-  _deleteHandle() {
-    this.gl.deleteBuffer(this.handle);
-    this._trackDeallocatedMemory();
-  }
-
-  _getParameter(pname) {
+  getParameter(pname) {
     this.gl.bindBuffer(this.target, this.handle);
     const value = this.gl.getBufferParameter(this.target, pname);
     this.gl.bindBuffer(this.target, null);
@@ -380,8 +454,8 @@ export default class Buffer extends Resource {
   }
 
   // DEPRECATIONS - v7.0
+  /** @deprecated Use Buffer.accessor.type */
   get type() {
-    log.deprecated('Buffer.type', 'Buffer.accessor.type')();
     return this.accessor.type;
   }