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

package/dist/es5/classes/webgl-buffer.js

@@ -7,22 +7,40 @@ Object.defineProperty(exports, "__esModule", {
 });
 exports.default = void 0;
 
-var _defineProperty2 = _interopRequireDefault(require("@babel/runtime/helpers/defineProperty"));
+var _typeof2 = _interopRequireDefault(require("@babel/runtime/helpers/typeof"));
 
-var _constants = _interopRequireDefault(require("@luma.gl/constants"));
+var _classCallCheck2 = _interopRequireDefault(require("@babel/runtime/helpers/classCallCheck"));
+
+var _createClass2 = _interopRequireDefault(require("@babel/runtime/helpers/createClass"));
+
+var _assertThisInitialized2 = _interopRequireDefault(require("@babel/runtime/helpers/assertThisInitialized"));
+
+var _inherits2 = _interopRequireDefault(require("@babel/runtime/helpers/inherits"));
+
+var _possibleConstructorReturn2 = _interopRequireDefault(require("@babel/runtime/helpers/possibleConstructorReturn"));
+
+var _getPrototypeOf2 = _interopRequireDefault(require("@babel/runtime/helpers/getPrototypeOf"));
 
-var _gltools = require("@luma.gl/gltools");
+var _defineProperty2 = _interopRequireDefault(require("@babel/runtime/helpers/defineProperty"));
 
 var _api = require("@luma.gl/api");
 
+var _constants = _interopRequireDefault(require("@luma.gl/constants"));
+
+var _webglChecks = require("../context/context/webgl-checks");
+
 var _accessor = _interopRequireDefault(require("./accessor"));
 
-var _webglUtils = require("../webgl-utils");
+var _typedArrayUtils = require("../webgl-utils/typed-array-utils");
 
-var _utils = require("../utils");
+var _webglDevice = _interopRequireDefault(require("../device/webgl-device"));
 
-const DEBUG_DATA_LENGTH = 10;
-const DEPRECATED_PROPS = {
+function _createSuper(Derived) { var hasNativeReflectConstruct = _isNativeReflectConstruct(); return function _createSuperInternal() { var Super = (0, _getPrototypeOf2.default)(Derived), result; if (hasNativeReflectConstruct) { var NewTarget = (0, _getPrototypeOf2.default)(this).constructor; result = Reflect.construct(Super, arguments, NewTarget); } else { result = Super.apply(this, arguments); } return (0, _possibleConstructorReturn2.default)(this, result); }; }
+
+function _isNativeReflectConstruct() { if (typeof Reflect === "undefined" || !Reflect.construct) return false; if (Reflect.construct.sham) return false; if (typeof Proxy === "function") return true; try { Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function () {})); return true; } catch (e) { return false; } }
+
+var DEBUG_DATA_LENGTH = 10;
+var DEPRECATED_PROPS = {
   offset: 'accessor.offset',
   stride: 'accessor.stride',
   type: 'accessor.type',
@@ -33,359 +51,412 @@ const DEPRECATED_PROPS = {
   instanced: 'accessor.divisor',
   isInstanced: 'accessor.divisor'
 };
-const PROP_CHECKS_INITIALIZE = {
+var PROP_CHECKS_INITIALIZE = {
   removedProps: {},
   replacedProps: {
     bytes: 'byteLength'
   },
   deprecatedProps: DEPRECATED_PROPS
 };
-const PROP_CHECKS_SET_PROPS = {
+var PROP_CHECKS_SET_PROPS = {
   removedProps: DEPRECATED_PROPS
 };
 
-class WEBGLBuffer extends _api.Buffer {
-  constructor(gl, props = {}) {
-    super(gl, props);
-    (0, _defineProperty2.default)(this, "gl", void 0);
-    (0, _defineProperty2.default)(this, "gl2", void 0);
-    (0, _defineProperty2.default)(this, "handle", void 0);
-    (0, _defineProperty2.default)(this, "target", void 0);
-    (0, _defineProperty2.default)(this, "usage", void 0);
-    (0, _defineProperty2.default)(this, "byteLength", void 0);
-    (0, _defineProperty2.default)(this, "bytesUsed", void 0);
-    (0, _defineProperty2.default)(this, "accessor", void 0);
-    (0, _defineProperty2.default)(this, "debugData", void 0);
-    this.gl = gl;
-    this.gl2 = (0, _gltools.getWebGL2Context)(gl);
-    const handle = typeof props === 'object' ? props.handle : undefined;
-    this.handle = handle || this.gl.createBuffer();
-    this.target = props.target || (this.gl.webgl2 ? _constants.default.COPY_READ_BUFFER : _constants.default.ARRAY_BUFFER);
-    this.initialize(props);
-    Object.seal(this);
+var WEBGLBuffer = function (_Buffer) {
+  (0, _inherits2.default)(WEBGLBuffer, _Buffer);
+
+  var _super = _createSuper(WEBGLBuffer);
+
+  function WEBGLBuffer(gl) {
+    var _this;
+
+    var props = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
+    (0, _classCallCheck2.default)(this, WEBGLBuffer);
+    _this = _super.call(this, _webglDevice.default.attach(gl), props);
+    (0, _defineProperty2.default)((0, _assertThisInitialized2.default)(_this), "device", void 0);
+    (0, _defineProperty2.default)((0, _assertThisInitialized2.default)(_this), "gl", void 0);
+    (0, _defineProperty2.default)((0, _assertThisInitialized2.default)(_this), "gl2", void 0);
+    (0, _defineProperty2.default)((0, _assertThisInitialized2.default)(_this), "handle", void 0);
+    (0, _defineProperty2.default)((0, _assertThisInitialized2.default)(_this), "target", void 0);
+    (0, _defineProperty2.default)((0, _assertThisInitialized2.default)(_this), "usage", void 0);
+    (0, _defineProperty2.default)((0, _assertThisInitialized2.default)(_this), "byteLength", void 0);
+    (0, _defineProperty2.default)((0, _assertThisInitialized2.default)(_this), "bytesUsed", void 0);
+    (0, _defineProperty2.default)((0, _assertThisInitialized2.default)(_this), "accessor", void 0);
+    (0, _defineProperty2.default)((0, _assertThisInitialized2.default)(_this), "debugData", void 0);
+    _this.gl = gl;
+    _this.gl2 = (0, _webglChecks.getWebGL2Context)(gl);
+    var handle = (0, _typeof2.default)(props) === 'object' ? props.handle : undefined;
+    _this.handle = handle || _this.gl.createBuffer();
+    _this.target = props.target || (_this.gl.webgl2 ? _constants.default.COPY_READ_BUFFER : _constants.default.ARRAY_BUFFER);
+
+    _this.initialize(props);
+
+    Object.seal((0, _assertThisInitialized2.default)(_this));
+    return _this;
   }
 
-  destroy() {
-    if (this.handle) {
-      this.removeStats();
-      this.trackDeallocatedMemory();
-      this.gl.deleteBuffer(this.handle);
-      this.handle = null;
+  (0, _createClass2.default)(WEBGLBuffer, [{
+    key: "destroy",
+    value: function destroy() {
+      if (this.handle) {
+        this.removeStats();
+        this.trackDeallocatedMemory();
+        this.gl.deleteBuffer(this.handle);
+        this.handle = null;
+      }
     }
-  }
-
-  getElementCount(accessor = this.accessor) {
-    return Math.round(this.byteLength / _accessor.default.getBytesPerElement(accessor));
-  }
-
-  getVertexCount(accessor = this.accessor) {
-    return Math.round(this.byteLength / _accessor.default.getBytesPerVertex(accessor));
-  }
-
-  initialize(props = {}) {
-    if (ArrayBuffer.isView(props)) {
-      props = {
-        data: props
-      };
+  }, {
+    key: "getElementCount",
+    value: function getElementCount() {
+      var accessor = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : this.accessor;
+      return Math.round(this.byteLength / _accessor.default.getBytesPerElement(accessor));
     }
-
-    if (Number.isFinite(props)) {
-      props = {
-        byteLength: props
-      };
+  }, {
+    key: "getVertexCount",
+    value: function getVertexCount() {
+      var accessor = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : this.accessor;
+      return Math.round(this.byteLength / _accessor.default.getBytesPerVertex(accessor));
     }
+  }, {
+    key: "initialize",
+    value: function initialize() {
+      var props = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
+
+      if (ArrayBuffer.isView(props)) {
+        props = {
+          data: props
+        };
+      }
 
-    props = (0, _utils.checkProps)('Buffer', props, PROP_CHECKS_INITIALIZE);
-    this.usage = props.usage || _constants.default.STATIC_DRAW;
-    this.debugData = null;
-    this.setAccessor(Object.assign({}, props, props.accessor));
+      if (Number.isFinite(props)) {
+        props = {
+          byteLength: props
+        };
+      }
 
-    if (props.data) {
-      this._setData(props.data, props.offset, props.byteLength);
-    } else {
-      this._setByteLength(props.byteLength || 0);
-    }
+      props = (0, _api.checkProps)('Buffer', props, PROP_CHECKS_INITIALIZE);
+      this.usage = props.usage || _constants.default.STATIC_DRAW;
+      this.debugData = null;
+      this.setAccessor(Object.assign({}, props, props.accessor));
 
-    return this;
-  }
-
-  setProps(props) {
-    props = (0, _utils.checkProps)('Buffer', props, PROP_CHECKS_SET_PROPS);
+      if (props.data) {
+        this._setData(props.data, props.offset, props.byteLength);
+      } else {
+        this._setByteLength(props.byteLength || 0);
+      }
 
-    if ('accessor' in props) {
-      this.setAccessor(props.accessor);
+      return this;
     }
+  }, {
+    key: "setProps",
+    value: function setProps(props) {
+      props = (0, _api.checkProps)('Buffer', props, PROP_CHECKS_SET_PROPS);
 
-    return this;
-  }
-
-  setAccessor(accessor) {
-    accessor = Object.assign({}, accessor);
-    delete accessor.buffer;
-    this.accessor = new _accessor.default(accessor);
-    return this;
-  }
-
-  reallocate(byteLength) {
-    if (byteLength > this.byteLength) {
-      this._setByteLength(byteLength);
+      if ('accessor' in props) {
+        this.setAccessor(props.accessor);
+      }
 
-      return true;
+      return this;
     }
+  }, {
+    key: "setAccessor",
+    value: function setAccessor(accessor) {
+      accessor = Object.assign({}, accessor);
+      delete accessor.buffer;
+      this.accessor = new _accessor.default(accessor);
+      return this;
+    }
+  }, {
+    key: "reallocate",
+    value: function reallocate(byteLength) {
+      if (byteLength > this.byteLength) {
+        this._setByteLength(byteLength);
 
-    this.bytesUsed = byteLength;
-    return false;
-  }
-
-  setData(props) {
-    return this.initialize(props);
-  }
+        return true;
+      }
 
-  subData(props) {
-    if (ArrayBuffer.isView(props)) {
-      props = {
-        data: props
-      };
+      this.bytesUsed = byteLength;
+      return false;
     }
-
-    const {
-      data,
-      offset = 0,
-      srcOffset = 0
-    } = props;
-    const byteLength = props.byteLength || props.length;
-    (0, _utils.assert)(data);
-    const target = this.gl.webgl2 ? _constants.default.COPY_WRITE_BUFFER : this.target;
-    this.gl.bindBuffer(target, this.handle);
-
-    if (srcOffset !== 0 || byteLength !== undefined) {
-      (0, _gltools.assertWebGL2Context)(this.gl);
-      this.gl.bufferSubData(this.target, offset, data, srcOffset, byteLength);
-    } else {
-      this.gl.bufferSubData(target, offset, data);
+  }, {
+    key: "setData",
+    value: function setData(props) {
+      return this.initialize(props);
     }
+  }, {
+    key: "subData",
+    value: function subData(props) {
+      if (ArrayBuffer.isView(props)) {
+        props = {
+          data: props
+        };
+      }
 
-    this.gl.bindBuffer(target, null);
-    this.debugData = null;
+      var _props = props,
+          data = _props.data,
+          _props$offset = _props.offset,
+          offset = _props$offset === void 0 ? 0 : _props$offset,
+          _props$srcOffset = _props.srcOffset,
+          srcOffset = _props$srcOffset === void 0 ? 0 : _props$srcOffset;
+      var byteLength = props.byteLength || props.length;
+      (0, _api.assert)(data);
+      var target = this.gl.webgl2 ? _constants.default.COPY_WRITE_BUFFER : this.target;
+      this.gl.bindBuffer(target, this.handle);
 
-    this._inferType(data);
+      if (srcOffset !== 0 || byteLength !== undefined) {
+        (0, _webglChecks.assertWebGL2Context)(this.gl);
+        this.gl.bufferSubData(this.target, offset, data, srcOffset, byteLength);
+      } else {
+        this.gl.bufferSubData(target, offset, data);
+      }
 
-    return this;
-  }
+      this.gl.bindBuffer(target, null);
+      this.debugData = null;
 
-  copyData(options) {
-    const {
-      sourceBuffer,
-      readOffset = 0,
-      writeOffset = 0,
-      size
-    } = options;
-    const {
-      gl,
-      gl2
-    } = this;
-    (0, _gltools.assertWebGL2Context)(gl);
-    gl.bindBuffer(_constants.default.COPY_READ_BUFFER, sourceBuffer.handle);
-    gl.bindBuffer(_constants.default.COPY_WRITE_BUFFER, this.handle);
-    gl2.copyBufferSubData(_constants.default.COPY_READ_BUFFER, _constants.default.COPY_WRITE_BUFFER, readOffset, writeOffset, size);
-    gl.bindBuffer(_constants.default.COPY_READ_BUFFER, null);
-    gl.bindBuffer(_constants.default.COPY_WRITE_BUFFER, null);
-    this.debugData = null;
-    return this;
-  }
+      this._inferType(data);
 
-  getData(options) {
-    let {
-      dstData = null,
-      length = 0
-    } = options || {};
-    const {
-      srcByteOffset = 0,
-      dstOffset = 0
-    } = options || {};
-    (0, _gltools.assertWebGL2Context)(this.gl);
-    const ArrayType = (0, _webglUtils.getTypedArrayFromGLType)(this.accessor.type || _constants.default.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;
+      return this;
+    }
+  }, {
+    key: "copyData",
+    value: function copyData(options) {
+      var sourceBuffer = options.sourceBuffer,
+          _options$readOffset = options.readOffset,
+          readOffset = _options$readOffset === void 0 ? 0 : _options$readOffset,
+          _options$writeOffset = options.writeOffset,
+          writeOffset = _options$writeOffset === void 0 ? 0 : _options$writeOffset,
+          size = options.size;
+      var gl = this.gl,
+          gl2 = this.gl2;
+      (0, _webglChecks.assertWebGL2Context)(gl);
+      gl.bindBuffer(_constants.default.COPY_READ_BUFFER, sourceBuffer.handle);
+      gl.bindBuffer(_constants.default.COPY_WRITE_BUFFER, this.handle);
+      gl2.copyBufferSubData(_constants.default.COPY_READ_BUFFER, _constants.default.COPY_WRITE_BUFFER, readOffset, writeOffset, size);
+      gl.bindBuffer(_constants.default.COPY_READ_BUFFER, null);
+      gl.bindBuffer(_constants.default.COPY_WRITE_BUFFER, null);
+      this.debugData = null;
+      return this;
     }
+  }, {
+    key: "getData",
+    value: function getData(options) {
+      var _ref = options || {},
+          _ref$dstData = _ref.dstData,
+          dstData = _ref$dstData === void 0 ? null : _ref$dstData,
+          _ref$length = _ref.length,
+          length = _ref$length === void 0 ? 0 : _ref$length;
+
+      var _ref2 = options || {},
+          _ref2$srcByteOffset = _ref2.srcByteOffset,
+          srcByteOffset = _ref2$srcByteOffset === void 0 ? 0 : _ref2$srcByteOffset,
+          _ref2$dstOffset = _ref2.dstOffset,
+          dstOffset = _ref2$dstOffset === void 0 ? 0 : _ref2$dstOffset;
+
+      (0, _webglChecks.assertWebGL2Context)(this.gl);
+      var ArrayType = (0, _typedArrayUtils.getTypedArrayFromGLType)(this.accessor.type || _constants.default.FLOAT, {
+        clamped: false
+      });
 
-    const copyElementCount = Math.min(sourceAvailableElementCount, dstAvailableElementCount);
-    length = length || copyElementCount;
-    (0, _utils.assert)(length <= copyElementCount);
-    dstData = dstData || new ArrayType(dstElementCount);
-    this.gl.bindBuffer(_constants.default.COPY_READ_BUFFER, this.handle);
-    this.gl2.getBufferSubData(_constants.default.COPY_READ_BUFFER, srcByteOffset, dstData, dstOffset, length);
-    this.gl.bindBuffer(_constants.default.COPY_READ_BUFFER, null);
-    return dstData;
-  }
+      var sourceAvailableElementCount = this._getAvailableElementCount(srcByteOffset);
+
+      var dstElementOffset = dstOffset;
+      var dstAvailableElementCount;
+      var dstElementCount;
 
-  bind(options) {
-    const {
-      target = this.target,
-      index = this.accessor && this.accessor.index,
-      offset = 0,
-      size
-    } = options || {};
-
-    if (target === _constants.default.UNIFORM_BUFFER || target === _constants.default.TRANSFORM_FEEDBACK_BUFFER) {
-      if (size !== undefined) {
-        this.gl2.bindBufferRange(target, index, this.handle, offset, size);
+      if (dstData) {
+        dstElementCount = dstData.length;
+        dstAvailableElementCount = dstElementCount - dstElementOffset;
       } else {
-        (0, _utils.assert)(offset === 0);
-        this.gl2.bindBufferBase(target, index, this.handle);
+        dstAvailableElementCount = Math.min(sourceAvailableElementCount, length || sourceAvailableElementCount);
+        dstElementCount = dstElementOffset + dstAvailableElementCount;
       }
-    } else {
-      this.gl.bindBuffer(target, this.handle);
-    }
-
-    return this;
-  }
 
-  unbind(options) {
-    const {
-      target = this.target,
-      index = this.accessor && this.accessor.index
-    } = options || {};
-    const isIndexedBuffer = target === _constants.default.UNIFORM_BUFFER || target === _constants.default.TRANSFORM_FEEDBACK_BUFFER;
+      var copyElementCount = Math.min(sourceAvailableElementCount, dstAvailableElementCount);
+      length = length || copyElementCount;
+      (0, _api.assert)(length <= copyElementCount);
+      dstData = dstData || new ArrayType(dstElementCount);
+      this.gl.bindBuffer(_constants.default.COPY_READ_BUFFER, this.handle);
+      this.gl2.getBufferSubData(_constants.default.COPY_READ_BUFFER, srcByteOffset, dstData, dstOffset, length);
+      this.gl.bindBuffer(_constants.default.COPY_READ_BUFFER, null);
+      return dstData;
+    }
+  }, {
+    key: "bind",
+    value: function bind(options) {
+      var _ref3 = options || {},
+          _ref3$target = _ref3.target,
+          target = _ref3$target === void 0 ? this.target : _ref3$target,
+          _ref3$index = _ref3.index,
+          index = _ref3$index === void 0 ? this.accessor && this.accessor.index : _ref3$index,
+          _ref3$offset = _ref3.offset,
+          offset = _ref3$offset === void 0 ? 0 : _ref3$offset,
+          size = _ref3.size;
+
+      if (target === _constants.default.UNIFORM_BUFFER || target === _constants.default.TRANSFORM_FEEDBACK_BUFFER) {
+        if (size !== undefined) {
+          this.gl2.bindBufferRange(target, index, this.handle, offset, size);
+        } else {
+          (0, _api.assert)(offset === 0);
+          this.gl2.bindBufferBase(target, index, this.handle);
+        }
+      } else {
+        this.gl.bindBuffer(target, this.handle);
+      }
 
-    if (isIndexedBuffer) {
-      this.gl2.bindBufferBase(target, index, null);
-    } else {
-      this.gl.bindBuffer(target, null);
+      return this;
     }
+  }, {
+    key: "unbind",
+    value: function unbind(options) {
+      var _ref4 = options || {},
+          _ref4$target = _ref4.target,
+          target = _ref4$target === void 0 ? this.target : _ref4$target,
+          _ref4$index = _ref4.index,
+          index = _ref4$index === void 0 ? this.accessor && this.accessor.index : _ref4$index;
+
+      var isIndexedBuffer = target === _constants.default.UNIFORM_BUFFER || target === _constants.default.TRANSFORM_FEEDBACK_BUFFER;
+
+      if (isIndexedBuffer) {
+        this.gl2.bindBufferBase(target, index, null);
+      } else {
+        this.gl.bindBuffer(target, null);
+      }
 
-    return this;
-  }
+      return this;
+    }
+  }, {
+    key: "getDebugData",
+    value: function getDebugData() {
+      if (!this.debugData) {
+        this.debugData = this.getData({
+          length: Math.min(DEBUG_DATA_LENGTH, this.byteLength)
+        });
+        return {
+          data: this.debugData,
+          changed: true
+        };
+      }
 
-  getDebugData() {
-    if (!this.debugData) {
-      this.debugData = this.getData({
-        length: Math.min(DEBUG_DATA_LENGTH, this.byteLength)
-      });
       return {
         data: this.debugData,
-        changed: true
+        changed: false
       };
     }
-
-    return {
-      data: this.debugData,
-      changed: false
-    };
-  }
-
-  invalidateDebugData() {
-    this.debugData = null;
-  }
-
-  _setData(data, offset = 0, byteLength = data.byteLength + offset) {
-    (0, _utils.assert)(ArrayBuffer.isView(data));
-    this.trackDeallocatedMemory();
-
-    const target = this._getTarget();
-
-    this.gl.bindBuffer(target, this.handle);
-    this.gl.bufferData(target, byteLength, this.usage);
-    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 = (0, _webglUtils.getGLTypeFromTypedArray)(data);
-    (0, _utils.assert)(type);
-    this.setAccessor(new _accessor.default(this.accessor, {
-      type
-    }));
-    return this;
-  }
-
-  _setByteLength(byteLength, usage = this.usage) {
-    (0, _utils.assert)(byteLength >= 0);
-    this.trackDeallocatedMemory();
-    let data = byteLength;
-
-    if (byteLength === 0) {
-      data = new Float32Array(0);
+  }, {
+    key: "invalidateDebugData",
+    value: function invalidateDebugData() {
+      this.debugData = null;
     }
+  }, {
+    key: "_setData",
+    value: function _setData(data) {
+      var offset = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 0;
+      var byteLength = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : data.byteLength + offset;
+      (0, _api.assert)(ArrayBuffer.isView(data));
+      this.trackDeallocatedMemory();
 
-    const target = this._getTarget();
-
-    this.gl.bindBuffer(target, this.handle);
-    this.gl.bufferData(target, data, usage);
-    this.gl.bindBuffer(target, null);
-    this.usage = usage;
-    this.debugData = null;
-    this.bytesUsed = byteLength;
-    this.byteLength = byteLength;
-    this.trackAllocatedMemory(byteLength);
-    return this;
-  }
-
-  _getTarget() {
-    return this.gl.webgl2 ? _constants.default.COPY_WRITE_BUFFER : this.target;
-  }
-
-  _getAvailableElementCount(srcByteOffset) {
-    const ArrayType = (0, _webglUtils.getTypedArrayFromGLType)(this.accessor.type || _constants.default.FLOAT, {
-      clamped: false
-    });
-    const sourceElementOffset = srcByteOffset / ArrayType.BYTES_PER_ELEMENT;
-    return this.getElementCount() - sourceElementOffset;
-  }
+      var target = this._getTarget();
 
-  _inferType(data) {
-    if (!this.accessor.type) {
+      this.gl.bindBuffer(target, this.handle);
+      this.gl.bufferData(target, byteLength, this.usage);
+      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);
+      var type = (0, _typedArrayUtils.getGLTypeFromTypedArray)(data);
+      (0, _api.assert)(type);
       this.setAccessor(new _accessor.default(this.accessor, {
-        type: (0, _webglUtils.getGLTypeFromTypedArray)(data)
+        type: type
       }));
+      return this;
     }
-  }
-
-  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;
-  }
-
-  get bytes() {
-    _gltools.log.deprecated('Buffer.bytes', 'Buffer.byteLength')();
+  }, {
+    key: "_setByteLength",
+    value: function _setByteLength(byteLength) {
+      var usage = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : this.usage;
+      (0, _api.assert)(byteLength >= 0);
+      this.trackDeallocatedMemory();
+      var data = byteLength;
 
-    return this.byteLength;
-  }
+      if (byteLength === 0) {
+        data = new Float32Array(0);
+      }
 
-  setByteLength(byteLength) {
-    _gltools.log.deprecated('setByteLength', 'reallocate')();
+      var target = this._getTarget();
 
-    return this.reallocate(byteLength);
-  }
+      this.gl.bindBuffer(target, this.handle);
+      this.gl.bufferData(target, data, usage);
+      this.gl.bindBuffer(target, null);
+      this.usage = usage;
+      this.debugData = null;
+      this.bytesUsed = byteLength;
+      this.byteLength = byteLength;
+      this.trackAllocatedMemory(byteLength);
+      return this;
+    }
+  }, {
+    key: "_getTarget",
+    value: function _getTarget() {
+      return this.gl.webgl2 ? _constants.default.COPY_WRITE_BUFFER : this.target;
+    }
+  }, {
+    key: "_getAvailableElementCount",
+    value: function _getAvailableElementCount(srcByteOffset) {
+      var ArrayType = (0, _typedArrayUtils.getTypedArrayFromGLType)(this.accessor.type || _constants.default.FLOAT, {
+        clamped: false
+      });
+      var sourceElementOffset = srcByteOffset / ArrayType.BYTES_PER_ELEMENT;
+      return this.getElementCount() - sourceElementOffset;
+    }
+  }, {
+    key: "_inferType",
+    value: function _inferType(data) {
+      if (!this.accessor.type) {
+        this.setAccessor(new _accessor.default(this.accessor, {
+          type: (0, _typedArrayUtils.getGLTypeFromTypedArray)(data)
+        }));
+      }
+    }
+  }, {
+    key: "getParameter",
+    value: function getParameter(pname) {
+      this.gl.bindBuffer(this.target, this.handle);
+      var value = this.gl.getBufferParameter(this.target, pname);
+      this.gl.bindBuffer(this.target, null);
+      return value;
+    }
+  }, {
+    key: "type",
+    get: function get() {
+      return this.accessor.type;
+    }
+  }, {
+    key: "bytes",
+    get: function get() {
+      _api.log.deprecated('Buffer.bytes', 'Buffer.byteLength')();
 
-  updateAccessor(opts) {
-    _gltools.log.deprecated('updateAccessor(...)', 'setAccessor(new Accessor(buffer.accessor, ...)')();
+      return this.byteLength;
+    }
+  }, {
+    key: "setByteLength",
+    value: function setByteLength(byteLength) {
+      _api.log.deprecated('setByteLength', 'reallocate')();
 
-    this.accessor = new _accessor.default(this.accessor, opts);
-    return this;
-  }
+      return this.reallocate(byteLength);
+    }
+  }, {
+    key: "updateAccessor",
+    value: function updateAccessor(opts) {
+      _api.log.deprecated('updateAccessor(...)', 'setAccessor(new Accessor(buffer.accessor, ...)')();
 
-}
+      this.accessor = new _accessor.default(this.accessor, opts);
+      return this;
+    }
+  }]);
+  return WEBGLBuffer;
+}(_api.Buffer);
 
 exports.default = WEBGLBuffer;
 //# sourceMappingURL=webgl-buffer.js.map