@luma.gl/webgl 9.0.0-alpha.16 → 9.0.0-alpha.19

package/dist/classic/buffer.js

@@ -1,352 +1,327 @@
-// luma.gl, MIT license
+import _defineProperty from "@babel/runtime/helpers/esm/defineProperty";
 import { assert, checkProps } from '@luma.gl/api';
 import GL from '@luma.gl/constants';
-import { assertWebGL2Context } from '../context/context/webgl-checks.js';
-import Accessor from './accessor.js';
-import { getGLTypeFromTypedArray, getTypedArrayFromGLType } from './typed-array-utils.js';
-import WebGLDevice from '../adapter/webgl-device.js';
-import WEBGLBuffer from '../adapter/resources/webgl-buffer.js';
+import { assertWebGL2Context } from "../context/context/webgl-checks.js";
+import Accessor from "./accessor.js";
+import { getGLTypeFromTypedArray, getTypedArrayFromGLType } from "./typed-array-utils.js";
+import WebGLDevice from "../adapter/webgl-device.js";
+import WEBGLBuffer from "../adapter/resources/webgl-buffer.js";
 const DEBUG_DATA_LENGTH = 10;
-// Shared prop checks for constructor and setProps
 const DEPRECATED_PROPS = {
-    offset: 'accessor.offset',
-    stride: 'accessor.stride',
-    type: 'accessor.type',
-    size: 'accessor.size',
-    divisor: 'accessor.divisor',
-    normalized: 'accessor.normalized',
-    integer: 'accessor.integer',
-    instanced: 'accessor.divisor',
-    isInstanced: 'accessor.divisor'
+  offset: 'accessor.offset',
+  stride: 'accessor.stride',
+  type: 'accessor.type',
+  size: 'accessor.size',
+  divisor: 'accessor.divisor',
+  normalized: 'accessor.normalized',
+  integer: 'accessor.integer',
+  instanced: 'accessor.divisor',
+  isInstanced: 'accessor.divisor'
 };
-// Prop checks for constructor
 const PROP_CHECKS_INITIALIZE = {
-    removedProps: {},
-    replacedProps: {
-        bytes: 'byteLength'
-    },
-    // new Buffer() with individual accessor props is still used in apps, emit warnings
-    deprecatedProps: DEPRECATED_PROPS
+  removedProps: {},
+  replacedProps: {
+    bytes: 'byteLength'
+  },
+  deprecatedProps: DEPRECATED_PROPS
 };
-// Prop checks for setProps
 const PROP_CHECKS_SET_PROPS = {
-    // Buffer.setProps() with individual accessor props is rare => emit errors
-    removedProps: DEPRECATED_PROPS
+  removedProps: DEPRECATED_PROPS
 };
 function getWEBGLBufferProps(props) {
-    // Signature `new Buffer(gl, new Float32Array(...)`
-    if (ArrayBuffer.isView(props)) {
-        return { data: props };
-    }
-    // Signature: `new Buffer(gl, 100)`
-    else if (typeof props === 'number') {
-        return { byteLength: props };
-    }
-    props = checkProps('Buffer', props, PROP_CHECKS_INITIALIZE);
-    const bufferProps = { ...props };
-    if (bufferProps.offset) {
-        bufferProps.byteOffset = bufferProps.offset;
-    }
-    return bufferProps;
+  if (ArrayBuffer.isView(props)) {
+    return {
+      data: props
+    };
+  } else if (typeof props === 'number') {
+    return {
+      byteLength: props
+    };
+  }
+  props = checkProps('Buffer', props, PROP_CHECKS_INITIALIZE);
+  const bufferProps = {
+    ...props
+  };
+  if (bufferProps.offset) {
+    bufferProps.byteOffset = bufferProps.offset;
+  }
+  return bufferProps;
 }
-/** WebGL Buffer interface */
 export default class ClassicBuffer extends WEBGLBuffer {
-    constructor(device, props = {}) {
-        super(WebGLDevice.attach(device), getWEBGLBufferProps(props));
-        // Base class initializes
-        // this.initialize(props);
-        // Deprecated: Merge main props and accessor
-        this.setAccessor(Object.assign({}, props, props.accessor));
-        // infer GL type from supplied typed array
-        if (this.props.data) {
-            const type = getGLTypeFromTypedArray(this.props.data);
-            assert(type);
-            this.setAccessor(new Accessor(this.accessor, { type }));
-        }
-        Object.seal(this);
-    }
-    write(data, byteOffset) {
-        this.subData({ data, offset: byteOffset });
-    }
-    // returns number of elements in the buffer (assuming that the full buffer is used)
-    getElementCount(accessor = this.accessor) {
-        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) {
-        return Math.round(this.byteLength / Accessor.getBytesPerVertex(accessor));
+  constructor(device) {
+    let props = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
+    super(WebGLDevice.attach(device), getWEBGLBufferProps(props));
+    _defineProperty(this, "usage", void 0);
+    _defineProperty(this, "accessor", void 0);
+    this.setAccessor(Object.assign({}, props, props.accessor));
+    if (this.props.data) {
+      const type = getGLTypeFromTypedArray(this.props.data);
+      assert(type);
+      this.setAccessor(new Accessor(this.accessor, {
+        type
+      }));
     }
-    // Creates and initializes the buffer object's data store.
-    // Signature: `new Buffer(gl, {data: new Float32Array(...)})`
-    // Signature: `new Buffer(gl, new Float32Array(...))`
-    // Signature: `new Buffer(gl, 100)`
-    initialize(props = {}) {
-        // Signature `new Buffer(gl, new Float32Array(...)`
-        if (ArrayBuffer.isView(props)) {
-            props = { data: props };
-        }
-        // Signature: `new Buffer(gl, 100)`
-        if (Number.isFinite(props)) {
-            // @ts-expect-error
-            props = { byteLength: props };
-        }
-        props = checkProps('Buffer', props, PROP_CHECKS_INITIALIZE);
-        // Initialize member fields
-        this.webglUsage = props.webglUsage || GL.STATIC_DRAW;
-        this.debugData = null;
-        // Deprecated: Merge main props and accessor
-        this.setAccessor(Object.assign({}, props, props.accessor));
-        // Set data: (re)initializes the buffer
-        if (props.data) {
-            this._setData(props.data, props.offset, props.byteLength);
-        }
-        else {
-            this._setByteLength(props.byteLength || 0);
-        }
-        return this;
-    }
-    setProps(props) {
-        props = checkProps('Buffer', props, PROP_CHECKS_SET_PROPS);
-        if ('accessor' in props) {
-            this.setAccessor(props.accessor);
-        }
-        return this;
-    }
-    // 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) {
-        // 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:
-        accessor = Object.assign({}, accessor);
-        // @ts-expect-error
-        delete accessor.buffer;
-        // This new statement ensures that an "accessor object" is re-packaged as an Accessor instance
-        this.accessor = new Accessor(accessor);
-        return this;
-    }
-    // Allocate a bigger GPU buffer (if the current buffer is not big enough).
-    // If a reallocation is triggered it clears the buffer
-    // Returns:
-    //  `true`: buffer was reallocated, data was cleared
-    //  `false`: buffer was big enough, data is intact
-    reallocate(byteLength) {
-        if (byteLength > this.byteLength) {
-            this._setByteLength(byteLength);
-            return true;
-        }
-        this.bytesUsed = byteLength;
-        return false;
-    }
-    // Update with new data. Reinitializes the buffer
-    setData(props) {
-        return this.initialize(props);
-    }
-    // Updates a subset of a buffer object's data store.
-    // Data (Typed Array or ArrayBuffer), length is inferred unless provided
-    // Offset into buffer
-    // WebGL2 only: Offset into srcData
-    // WebGL2 only: Number of bytes to be copied
-    subData(options) {
-        // Signature: buffer.subData(new Float32Array([...]))
-        if (ArrayBuffer.isView(options)) {
-            options = { data: options };
-        }
-        const { data, offset = 0, srcOffset = 0 } = options;
-        const byteLength = options.byteLength || options.length;
-        assert(data);
-        // 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);
-        }
-        this.gl.bindBuffer(target, null);
-        // TODO - update local `data` if offsets are right
-        this.debugData = null;
-        this._inferType(data);
-        return this;
-    }
-    /**
-     * Copies part of the data of another buffer into this buffer
-     * @note WEBGL2 ONLY
-     */
-    copyData(options) {
-        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);
-        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);
-        // TODO - update local `data` if offsets are 0
-        this.debugData = null;
-        return this;
+    Object.seal(this);
+  }
+  write(data, byteOffset) {
+    this.subData({
+      data,
+      offset: byteOffset
+    });
+  }
+  getElementCount() {
+    let accessor = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : this.accessor;
+    return Math.round(this.byteLength / Accessor.getBytesPerElement(accessor));
+  }
+  getVertexCount() {
+    let accessor = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : this.accessor;
+    return Math.round(this.byteLength / Accessor.getBytesPerVertex(accessor));
+  }
+  initialize() {
+    let props = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
+    if (ArrayBuffer.isView(props)) {
+      props = {
+        data: props
+      };
     }
-    /**
-     * Reads data from buffer into an ArrayBufferView or SharedArrayBuffer.
-     * @note WEBGL2 ONLY
-     */
-    getData(options) {
-        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 });
-        const sourceAvailableElementCount = this._getAvailableElementCount(srcByteOffset);
-        const dstElementOffset = dstOffset;
-        let dstAvailableElementCount;
-        let dstElementCount;
-        if (dstData) {
-            dstElementCount = dstData.length;
-            dstAvailableElementCount = dstElementCount - dstElementOffset;
-        }
-        else {
-            // Allocate ArrayBufferView with enough size to copy all eligible data.
-            dstAvailableElementCount = Math.min(sourceAvailableElementCount, length || sourceAvailableElementCount);
-            dstElementCount = dstElementOffset + dstAvailableElementCount;
-        }
-        const copyElementCount = Math.min(sourceAvailableElementCount, dstAvailableElementCount);
-        length = length || copyElementCount;
-        assert(length <= copyElementCount);
-        dstData = dstData || new ArrayType(dstElementCount);
-        // 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.gl.bindBuffer(GL.COPY_READ_BUFFER, null);
-        // TODO - update local `data` if offsets are 0
-        return dstData;
+    if (Number.isFinite(props)) {
+      props = {
+        byteLength: props
+      };
     }
-    /**
-     * Binds a buffer to a given binding point (target).
-     *   GL.TRANSFORM_FEEDBACK_BUFFER and GL.UNIFORM_BUFFER take an index, and optionally a range.
-     *   - GL.TRANSFORM_FEEDBACK_BUFFER and GL.UNIFORM_BUFFER need an index to affect state
-     *   - 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) {
-        const { target = this.target, // target for the bind operation
-        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.gl2?.bindBufferRange(target, index, this.handle, offset, size);
-            }
-            else {
-                assert(offset === 0); // Make sure offset wasn't supplied
-                this.gl2?.bindBufferBase(target, index, this.handle);
-            }
-        }
-        else {
-            this.gl.bindBuffer(target, this.handle);
-        }
-        return this;
+    props = checkProps('Buffer', props, PROP_CHECKS_INITIALIZE);
+    this.webglUsage = props.webglUsage || GL.STATIC_DRAW;
+    this.debugData = null;
+    this.setAccessor(Object.assign({}, props, props.accessor));
+    if (props.data) {
+      this._setData(props.data, props.offset, props.byteLength);
+    } else {
+      this._setByteLength(props.byteLength || 0);
     }
-    unbind(options) {
-        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.gl2?.bindBufferBase(target, index, null);
-        }
-        else {
-            this.gl.bindBuffer(target, null);
-        }
-        return this;
+    return this;
+  }
+  setProps(props) {
+    props = checkProps('Buffer', props, PROP_CHECKS_SET_PROPS);
+    if ('accessor' in props) {
+      this.setAccessor(props.accessor);
     }
-    // PROTECTED METHODS (INTENDED FOR USE BY OTHER FRAMEWORK CODE ONLY)
-    // Returns a short initial data array
-    getDebugData() {
-        if (!this.debugData) {
-            this.debugData = this.getData({ length: Math.min(DEBUG_DATA_LENGTH, this.byteLength) });
-            return { data: this.debugData, changed: true };
-        }
-        return { data: this.debugData, changed: false };
+    return this;
+  }
+  setAccessor(accessor) {
+    accessor = Object.assign({}, accessor);
+    delete accessor.buffer;
+    this.accessor = new Accessor(accessor);
+    return this;
+  }
+  reallocate(byteLength) {
+    if (byteLength > this.byteLength) {
+      this._setByteLength(byteLength);
+      return true;
     }
-    invalidateDebugData() {
-        this.debugData = null;
+    this.bytesUsed = byteLength;
+    return false;
+  }
+  setData(props) {
+    return this.initialize(props);
+  }
+  subData(options) {
+    if (ArrayBuffer.isView(options)) {
+      options = {
+        data: options
+      };
     }
-    // PRIVATE METHODS
-    // Allocate a new buffer and initialize to contents of typed array
-    _setData(data, offset = 0, byteLength = data.byteLength + offset) {
-        assert(ArrayBuffer.isView(data));
-        this.trackDeallocatedMemory();
-        const target = this._getTarget();
-        this.gl.bindBuffer(target, this.handle);
-        this.gl.bufferData(target, byteLength, this.webglUsage);
-        this.gl.bufferSubData(target, offset, data);
-        this.gl.bindBuffer(target, null);
-        this.debugData = data.slice(0, DEBUG_DATA_LENGTH);
-        this.bytesUsed = byteLength;
-        this.byteLength = byteLength;
-        this.trackAllocatedMemory(byteLength);
-        // infer GL type from supplied typed array
-        const type = getGLTypeFromTypedArray(data);
-        assert(type);
-        this.setAccessor(new Accessor(this.accessor, { type }));
-        return this;
+    const {
+      data,
+      offset = 0,
+      srcOffset = 0
+    } = options;
+    const byteLength = options.byteLength || options.length;
+    assert(data);
+    const target = this.gl.webgl2 ? GL.COPY_WRITE_BUFFER : this.target;
+    this.gl.bindBuffer(target, this.handle);
+    if (srcOffset !== 0 || byteLength !== undefined) {
+      assertWebGL2Context(this.gl);
+      this.gl.bufferSubData(this.target, offset, data, srcOffset, byteLength);
+    } else {
+      this.gl.bufferSubData(target, offset, data);
     }
-    // Allocate a GPU buffer of specified size.
-    _setByteLength(byteLength, webglUsage = this.webglUsage) {
-        assert(byteLength >= 0);
-        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);
-        }
-        const target = this._getTarget();
-        this.gl.bindBuffer(target, this.handle);
-        this.gl.bufferData(target, data, webglUsage);
-        this.gl.bindBuffer(target, null);
-        this.webglUsage = webglUsage;
-        this.debugData = null;
-        this.bytesUsed = byteLength;
-        this.byteLength = byteLength;
-        this.trackAllocatedMemory(byteLength);
-        return this;
+    this.gl.bindBuffer(target, null);
+    this.debugData = null;
+    this._inferType(data);
+    return this;
+  }
+  copyData(options) {
+    const {
+      sourceBuffer,
+      readOffset = 0,
+      writeOffset = 0,
+      size
+    } = options;
+    const {
+      gl,
+      gl2
+    } = this;
+    assertWebGL2Context(gl);
+    gl.bindBuffer(GL.COPY_READ_BUFFER, sourceBuffer.handle);
+    gl.bindBuffer(GL.COPY_WRITE_BUFFER, this.handle);
+    gl2 === null || gl2 === void 0 ? void 0 : 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);
+    this.debugData = null;
+    return this;
+  }
+  getData(options) {
+    var _this$gl;
+    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
+    });
+    const sourceAvailableElementCount = this._getAvailableElementCount(srcByteOffset);
+    const dstElementOffset = dstOffset;
+    let dstAvailableElementCount;
+    let dstElementCount;
+    if (dstData) {
+      dstElementCount = dstData.length;
+      dstAvailableElementCount = dstElementCount - dstElementOffset;
+    } else {
+      dstAvailableElementCount = Math.min(sourceAvailableElementCount, length || sourceAvailableElementCount);
+      dstElementCount = dstElementOffset + dstAvailableElementCount;
     }
-    // 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;
+    const copyElementCount = Math.min(sourceAvailableElementCount, dstAvailableElementCount);
+    length = length || copyElementCount;
+    assert(length <= copyElementCount);
+    dstData = dstData || new ArrayType(dstElementCount);
+    this.gl.bindBuffer(GL.COPY_READ_BUFFER, this.handle);
+    (_this$gl = this.gl2) === null || _this$gl === void 0 ? void 0 : _this$gl.getBufferSubData(GL.COPY_READ_BUFFER, srcByteOffset, dstData, dstOffset, length);
+    this.gl.bindBuffer(GL.COPY_READ_BUFFER, null);
+    return dstData;
+  }
+  bind(options) {
+    const {
+      target = this.target,
+      index = this.accessor && this.accessor.index,
+      offset = 0,
+      size
+    } = options || {};
+    if (target === GL.UNIFORM_BUFFER || target === GL.TRANSFORM_FEEDBACK_BUFFER) {
+      if (size !== undefined) {
+        var _this$gl2;
+        (_this$gl2 = this.gl2) === null || _this$gl2 === void 0 ? void 0 : _this$gl2.bindBufferRange(target, index, this.handle, offset, size);
+      } else {
+        var _this$gl3;
+        assert(offset === 0);
+        (_this$gl3 = this.gl2) === null || _this$gl3 === void 0 ? void 0 : _this$gl3.bindBufferBase(target, index, this.handle);
+      }
+    } else {
+      this.gl.bindBuffer(target, this.handle);
     }
-    _getAvailableElementCount(srcByteOffset) {
-        const ArrayType = getTypedArrayFromGLType(this.accessor.type || GL.FLOAT, { clamped: false });
-        const sourceElementOffset = srcByteOffset / ArrayType.BYTES_PER_ELEMENT;
-        return this.getElementCount() - sourceElementOffset;
+    return this;
+  }
+  unbind(options) {
+    const {
+      target = this.target,
+      index = this.accessor && this.accessor.index
+    } = options || {};
+    const isIndexedBuffer = target === GL.UNIFORM_BUFFER || target === GL.TRANSFORM_FEEDBACK_BUFFER;
+    if (isIndexedBuffer) {
+      var _this$gl4;
+      (_this$gl4 = this.gl2) === null || _this$gl4 === void 0 ? void 0 : _this$gl4.bindBufferBase(target, index, null);
+    } else {
+      this.gl.bindBuffer(target, null);
     }
-    // Automatically infers type from typed array passed to setData
-    // Note: No longer that useful, since type is now autodeduced from the compiled shaders
-    _inferType(data) {
-        if (!this.accessor.type) {
-            this.setAccessor(new Accessor(this.accessor, { type: getGLTypeFromTypedArray(data) }));
-        }
+    return this;
+  }
+  getDebugData() {
+    if (!this.debugData) {
+      this.debugData = this.getData({
+        length: Math.min(DEBUG_DATA_LENGTH, this.byteLength)
+      });
+      return {
+        data: this.debugData,
+        changed: true
+      };
     }
-    // RESOURCE METHODS
-    getParameter(pname) {
-        this.gl.bindBuffer(this.target, this.handle);
-        const value = this.gl.getBufferParameter(this.target, pname);
-        this.gl.bindBuffer(this.target, null);
-        return value;
+    return {
+      data: this.debugData,
+      changed: false
+    };
+  }
+  invalidateDebugData() {
+    this.debugData = null;
+  }
+  _setData(data) {
+    let offset = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 0;
+    let byteLength = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : data.byteLength + offset;
+    assert(ArrayBuffer.isView(data));
+    this.trackDeallocatedMemory();
+    const target = this._getTarget();
+    this.gl.bindBuffer(target, this.handle);
+    this.gl.bufferData(target, byteLength, this.webglUsage);
+    this.gl.bufferSubData(target, offset, data);
+    this.gl.bindBuffer(target, null);
+    this.debugData = data.slice(0, DEBUG_DATA_LENGTH);
+    this.bytesUsed = byteLength;
+    this.byteLength = byteLength;
+    this.trackAllocatedMemory(byteLength);
+    const type = getGLTypeFromTypedArray(data);
+    assert(type);
+    this.setAccessor(new Accessor(this.accessor, {
+      type
+    }));
+    return this;
+  }
+  _setByteLength(byteLength) {
+    let webglUsage = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : this.webglUsage;
+    assert(byteLength >= 0);
+    this.trackDeallocatedMemory();
+    let data = byteLength;
+    if (byteLength === 0) {
+      data = new Float32Array(0);
     }
-    // DEPRECATIONS - v7.0
-    /** @deprecated Use Buffer.accessor.type */
-    get type() {
-        return this.accessor.type;
+    const target = this._getTarget();
+    this.gl.bindBuffer(target, this.handle);
+    this.gl.bufferData(target, data, webglUsage);
+    this.gl.bindBuffer(target, null);
+    this.webglUsage = webglUsage;
+    this.debugData = null;
+    this.bytesUsed = byteLength;
+    this.byteLength = byteLength;
+    this.trackAllocatedMemory(byteLength);
+    return this;
+  }
+  _getTarget() {
+    return this.gl.webgl2 ? GL.COPY_WRITE_BUFFER : this.target;
+  }
+  _getAvailableElementCount(srcByteOffset) {
+    const ArrayType = getTypedArrayFromGLType(this.accessor.type || GL.FLOAT, {
+      clamped: false
+    });
+    const sourceElementOffset = srcByteOffset / ArrayType.BYTES_PER_ELEMENT;
+    return this.getElementCount() - sourceElementOffset;
+  }
+  _inferType(data) {
+    if (!this.accessor.type) {
+      this.setAccessor(new Accessor(this.accessor, {
+        type: getGLTypeFromTypedArray(data)
+      }));
     }
+  }
+  getParameter(pname) {
+    this.gl.bindBuffer(this.target, this.handle);
+    const value = this.gl.getBufferParameter(this.target, pname);
+    this.gl.bindBuffer(this.target, null);
+    return value;
+  }
+  get type() {
+    return this.accessor.type;
+  }
 }
+//# sourceMappingURL=buffer.js.map