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

package/dist/es5/classes/vertex-array.js

@@ -7,450 +7,414 @@ Object.defineProperty(exports, "__esModule", {
 });
 exports.default = void 0;
 
-var _classCallCheck2 = _interopRequireDefault(require("@babel/runtime/helpers/classCallCheck"));
+var _defineProperty2 = _interopRequireDefault(require("@babel/runtime/helpers/defineProperty"));
 
-var _createClass2 = _interopRequireDefault(require("@babel/runtime/helpers/createClass"));
+var _constants = _interopRequireDefault(require("@luma.gl/constants"));
 
 var _gltools = require("@luma.gl/gltools");
 
-var _accessor2 = _interopRequireDefault(require("./accessor"));
+var _accessor = _interopRequireDefault(require("./accessor"));
 
-var _buffer = _interopRequireDefault(require("./buffer"));
+var _webglBuffer = _interopRequireDefault(require("./webgl-buffer"));
 
 var _vertexArrayObject = _interopRequireDefault(require("./vertex-array-object"));
 
-var _assert = require("../utils/assert");
+var _utils = require("../utils");
+
+const ERR_ATTRIBUTE_TYPE = 'VertexArray: attributes must be Buffers or constants (i.e. typed array)';
+const MULTI_LOCATION_ATTRIBUTE_REGEXP = /^(.+)__LOCATION_([0-9]+)$/;
+
+class VertexArray {
+  constructor(gl, props) {
+    (0, _defineProperty2.default)(this, "id", void 0);
+    (0, _defineProperty2.default)(this, "gl", void 0);
+    (0, _defineProperty2.default)(this, "attributes", {});
+    (0, _defineProperty2.default)(this, "vertexArrayObject", void 0);
+    (0, _defineProperty2.default)(this, "accessors", []);
+    (0, _defineProperty2.default)(this, "configuration", null);
+    (0, _defineProperty2.default)(this, "elements", null);
+    (0, _defineProperty2.default)(this, "elementsAccessor", null);
+    (0, _defineProperty2.default)(this, "values", null);
+    (0, _defineProperty2.default)(this, "unused", null);
+    (0, _defineProperty2.default)(this, "drawParams", null);
+    (0, _defineProperty2.default)(this, "buffer", null);
+    (0, _defineProperty2.default)(this, "bindOnUse", false);
+    const id = (props === null || props === void 0 ? void 0 : props.id) || (props === null || props === void 0 ? void 0 : props.program) && (props === null || props === void 0 ? void 0 : props.program.id);
+    this.vertexArrayObject = new _vertexArrayObject.default(gl);
+    this.id = id;
+    this.gl = gl;
+    this.configuration = null;
+    this.initialize(props);
+    Object.seal(this);
+  }
 
-var _stubMethods = require("../utils/stub-methods");
+  delete() {
+    if (this.buffer) {
+      this.buffer.delete();
+    }
 
-var ERR_ATTRIBUTE_TYPE = 'VertexArray: attributes must be Buffers or constants (i.e. typed array)';
-var MULTI_LOCATION_ATTRIBUTE_REGEXP = /^(.+)__LOCATION_([0-9]+)$/;
-var DEPRECATIONS_V6 = ['setBuffers', 'setGeneric', 'clearBindings', 'setLocations', 'setGenericValues', 'setDivisor', 'enable', 'disable'];
+    this.vertexArrayObject.delete();
+  }
 
-var VertexArray = function () {
-  function VertexArray(gl) {
-    var opts = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
-    (0, _classCallCheck2.default)(this, VertexArray);
-    var id = opts.id || opts.program && opts.program.id;
-    this.id = id;
-    this.gl = gl;
+  initialize(props) {
+    this.reset();
     this.configuration = null;
+    this.bindOnUse = false;
+    return this.setProps(props || {});
+  }
+
+  reset() {
     this.elements = null;
     this.elementsAccessor = null;
-    this.values = null;
-    this.accessors = null;
-    this.unused = null;
+    const {
+      MAX_ATTRIBUTES
+    } = this.vertexArrayObject;
+    this.values = new Array(MAX_ATTRIBUTES).fill(null);
+    this.accessors = new Array(MAX_ATTRIBUTES).fill(null);
+    this.unused = {};
     this.drawParams = null;
-    this.buffer = null;
-    this.attributes = {};
-    this.vertexArrayObject = new _vertexArrayObject.default(gl);
-    (0, _stubMethods.stubRemovedMethods)(this, 'VertexArray', 'v6.0', DEPRECATIONS_V6);
-    this.initialize(opts);
-    Object.seal(this);
+    return this;
   }
 
-  (0, _createClass2.default)(VertexArray, [{
-    key: "delete",
-    value: function _delete() {
-      if (this.buffer) {
-        this.buffer.delete();
-      }
+  setProps(props) {
+    if ('program' in props) {
+      this.configuration = props.program && props.program.configuration;
+    }
 
-      this.vertexArrayObject.delete();
+    if ('configuration' in props) {
+      this.configuration = props.configuration;
     }
-  }, {
-    key: "initialize",
-    value: function initialize() {
-      var props = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
-      this.reset();
-      this.configuration = null;
-      this.bindOnUse = false;
-      return this.setProps(props);
+
+    if ('attributes' in props) {
+      this.setAttributes(props.attributes);
     }
-  }, {
-    key: "reset",
-    value: function reset() {
-      this.elements = null;
-      this.elementsAccessor = null;
-      var MAX_ATTRIBUTES = this.vertexArrayObject.MAX_ATTRIBUTES;
-      this.values = new Array(MAX_ATTRIBUTES).fill(null);
-      this.accessors = new Array(MAX_ATTRIBUTES).fill(null);
-      this.unused = {};
-      this.drawParams = null;
-      return this;
+
+    if ('elements' in props) {
+      this.setElementBuffer(props.elements);
     }
-  }, {
-    key: "setProps",
-    value: function setProps(props) {
-      if ('program' in props) {
-        this.configuration = props.program && props.program.configuration;
-      }
 
-      if ('configuration' in props) {
-        this.configuration = props.configuration;
-      }
+    if ('bindOnUse' in props) {
+      props = props.bindOnUse;
+    }
 
-      if ('attributes' in props) {
-        this.setAttributes(props.attributes);
-      }
+    return this;
+  }
 
-      if ('elements' in props) {
-        this.setElementBuffer(props.elements);
-      }
+  clearDrawParams() {
+    this.drawParams = null;
+  }
 
-      if ('bindOnUse' in props) {
-        props = props.bindOnUse;
+  getDrawParams() {
+    this.drawParams = this.drawParams || this._updateDrawParams();
+    return this.drawParams;
+  }
+
+  setAttributes(attributes) {
+    Object.assign(this.attributes, attributes);
+    this.vertexArrayObject.bind(() => {
+      for (const locationOrName in attributes) {
+        const value = attributes[locationOrName];
+
+        this._setAttribute(locationOrName, value);
       }
 
+      this.gl.bindBuffer(_constants.default.ARRAY_BUFFER, null);
+    });
+    return this;
+  }
+
+  setElementBuffer(elementBuffer = null, accessor = {}) {
+    this.elements = elementBuffer;
+    this.elementsAccessor = accessor;
+    this.clearDrawParams();
+    this.vertexArrayObject.setElementBuffer(elementBuffer, accessor);
+    return this;
+  }
+
+  setBuffer(locationOrName, buffer, appAccessor = {}) {
+    if (buffer.target === _constants.default.ELEMENT_ARRAY_BUFFER) {
+      this.setElementBuffer(buffer, appAccessor);
       return this;
     }
-  }, {
-    key: "clearDrawParams",
-    value: function clearDrawParams() {
-      this.drawParams = null;
-    }
-  }, {
-    key: "getDrawParams",
-    value: function getDrawParams() {
-      this.drawParams = this.drawParams || this._updateDrawParams();
-      return this.drawParams;
-    }
-  }, {
-    key: "setAttributes",
-    value: function setAttributes(attributes) {
-      var _this = this;
-
-      Object.assign(this.attributes, attributes);
-      this.vertexArrayObject.bind(function () {
-        for (var locationOrName in attributes) {
-          var value = attributes[locationOrName];
 
-          _this._setAttribute(locationOrName, value);
-        }
+    const {
+      location,
+      accessor
+    } = this._resolveLocationAndAccessor(locationOrName, buffer, buffer.accessor, appAccessor);
 
-        _this.gl.bindBuffer(34962, null);
-      });
-      return this;
+    if (location >= 0) {
+      this.values[location] = buffer;
+      this.accessors[location] = accessor;
+      this.clearDrawParams();
+      this.vertexArrayObject.setBuffer(location, buffer, accessor);
     }
-  }, {
-    key: "setElementBuffer",
-    value: function setElementBuffer() {
-      var elementBuffer = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : null;
-      var accessor = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
-      this.elements = elementBuffer;
-      this.elementsAccessor = accessor;
+
+    return this;
+  }
+
+  setConstant(locationOrName, arrayValue, appAccessor = {}) {
+    const {
+      location,
+      accessor
+    } = this._resolveLocationAndAccessor(locationOrName, arrayValue, {
+      size: arrayValue.length,
+      ...appAccessor
+    });
+
+    if (location >= 0) {
+      arrayValue = this.vertexArrayObject._normalizeConstantArrayValue(arrayValue);
+      this.values[location] = arrayValue;
+      this.accessors[location] = accessor;
       this.clearDrawParams();
-      this.vertexArrayObject.setElementBuffer(elementBuffer, accessor);
-      return this;
+      this.vertexArrayObject.enable(location, false);
     }
-  }, {
-    key: "setBuffer",
-    value: function setBuffer(locationOrName, buffer) {
-      var appAccessor = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {};
 
-      if (buffer.target === 34963) {
-        return this.setElementBuffer(buffer, appAccessor);
+    return this;
+  }
+
+  unbindBuffers() {
+    this.vertexArrayObject.bind(() => {
+      if (this.elements) {
+        this.vertexArrayObject.setElementBuffer(null);
       }
 
-      var _this$_resolveLocatio = this._resolveLocationAndAccessor(locationOrName, buffer, buffer.accessor, appAccessor),
-          location = _this$_resolveLocatio.location,
-          accessor = _this$_resolveLocatio.accessor;
+      this.buffer = this.buffer || new _webglBuffer.default(this.gl, {
+        accessor: {
+          size: 4
+        }
+      });
 
-      if (location >= 0) {
-        this.values[location] = buffer;
-        this.accessors[location] = accessor;
-        this.clearDrawParams();
-        this.vertexArrayObject.setBuffer(location, buffer, accessor);
+      for (let location = 0; location < this.vertexArrayObject.MAX_ATTRIBUTES; location++) {
+        if (this.values[location] instanceof _webglBuffer.default) {
+          this.gl.disableVertexAttribArray(location);
+          this.gl.bindBuffer(_constants.default.ARRAY_BUFFER, this.buffer.handle);
+          this.gl.vertexAttribPointer(location, 1, _constants.default.FLOAT, false, 0, 0);
+        }
       }
+    });
+    return this;
+  }
 
-      return this;
-    }
-  }, {
-    key: "setConstant",
-    value: function setConstant(locationOrName, arrayValue) {
-      var appAccessor = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {};
-
-      var _this$_resolveLocatio2 = this._resolveLocationAndAccessor(locationOrName, arrayValue, Object.assign({
-        size: arrayValue.length
-      }, appAccessor)),
-          location = _this$_resolveLocatio2.location,
-          accessor = _this$_resolveLocatio2.accessor;
-
-      if (location >= 0) {
-        arrayValue = this.vertexArrayObject._normalizeConstantArrayValue(arrayValue);
-        this.values[location] = arrayValue;
-        this.accessors[location] = accessor;
-        this.clearDrawParams();
-        this.vertexArrayObject.enable(location, false);
+  bindBuffers() {
+    this.vertexArrayObject.bind(() => {
+      if (this.elements) {
+        this.setElementBuffer(this.elements);
       }
 
-      return this;
-    }
-  }, {
-    key: "unbindBuffers",
-    value: function unbindBuffers() {
-      var _this2 = this;
-
-      this.vertexArrayObject.bind(function () {
-        if (_this2.elements) {
-          _this2.vertexArrayObject.setElementBuffer(null);
-        }
+      for (let location = 0; location < this.vertexArrayObject.MAX_ATTRIBUTES; location++) {
+        const buffer = this.values[location];
 
-        _this2.buffer = _this2.buffer || new _buffer.default(_this2.gl, {
-          accessor: {
-            size: 4
-          }
-        });
+        if (buffer instanceof _webglBuffer.default) {
+          this.setBuffer(location, buffer);
+        }
+      }
+    });
+    return this;
+  }
 
-        for (var location = 0; location < _this2.vertexArrayObject.MAX_ATTRIBUTES; location++) {
-          if (_this2.values[location] instanceof _buffer.default) {
-            _this2.gl.disableVertexAttribArray(location);
+  bindForDraw(vertexCount, instanceCount, func) {
+    let value;
+    this.vertexArrayObject.bind(() => {
+      this._setConstantAttributes(vertexCount, instanceCount);
 
-            _this2.gl.bindBuffer(34962, _this2.buffer.handle);
+      value = func();
+    });
+    return value;
+  }
 
-            _this2.gl.vertexAttribPointer(location, 1, 5126, false, 0, 0);
-          }
-        }
-      });
-      return this;
-    }
-  }, {
-    key: "bindBuffers",
-    value: function bindBuffers() {
-      var _this3 = this;
-
-      this.vertexArrayObject.bind(function () {
-        if (_this3.elements) {
-          _this3.setElementBuffer(_this3.elements);
-        }
+  _resolveLocationAndAccessor(locationOrName, value, valueAccessor, appAccessor) {
+    const INVALID_RESULT = {
+      location: -1,
+      accessor: null
+    };
 
-        for (var location = 0; location < _this3.vertexArrayObject.MAX_ATTRIBUTES; location++) {
-          var buffer = _this3.values[location];
+    const {
+      location,
+      name
+    } = this._getAttributeIndex(locationOrName);
 
-          if (buffer instanceof _buffer.default) {
-            _this3.setBuffer(location, buffer);
-          }
-        }
-      });
-      return this;
-    }
-  }, {
-    key: "bindForDraw",
-    value: function bindForDraw(vertexCount, instanceCount, func) {
-      var _this4 = this;
+    if (!Number.isFinite(location) || location < 0) {
+      this.unused[locationOrName] = value;
 
-      var value;
-      this.vertexArrayObject.bind(function () {
-        _this4._setConstantAttributes(vertexCount, instanceCount);
+      _gltools.log.once(3, () => "unused value ".concat(locationOrName, " in ").concat(this.id))();
 
-        value = func();
-      });
-      return value;
+      return INVALID_RESULT;
     }
-  }, {
-    key: "_resolveLocationAndAccessor",
-    value: function _resolveLocationAndAccessor(locationOrName, value, valueAccessor, appAccessor) {
-      var _this5 = this;
-
-      var INVALID_RESULT = {
-        location: -1,
-        accessor: null
-      };
 
-      var _this$_getAttributeIn = this._getAttributeIndex(locationOrName),
-          location = _this$_getAttributeIn.location,
-          name = _this$_getAttributeIn.name;
+    const accessInfo = this._getAttributeInfo(name || location);
 
-      if (!Number.isFinite(location) || location < 0) {
-        this.unused[locationOrName] = value;
-
-        _gltools.log.once(3, function () {
-          return "unused value ".concat(locationOrName, " in ").concat(_this5.id);
-        })();
+    if (!accessInfo) {
+      return INVALID_RESULT;
+    }
 
-        return INVALID_RESULT;
-      }
+    const currentAccessor = this.accessors[location] || {};
 
-      var accessInfo = this._getAttributeInfo(name || location);
+    const accessor = _accessor.default.resolve(accessInfo.accessor, currentAccessor, valueAccessor, appAccessor);
 
-      if (!accessInfo) {
-        return INVALID_RESULT;
-      }
+    const {
+      size,
+      type
+    } = accessor;
+    (0, _utils.assert)(Number.isFinite(size) && Number.isFinite(type));
+    return {
+      location,
+      accessor
+    };
+  }
 
-      var currentAccessor = this.accessors[location] || {};
+  _getAttributeInfo(attributeName) {
+    return this.configuration && this.configuration.getAttributeInfo(attributeName);
+  }
 
-      var accessor = _accessor2.default.resolve(accessInfo.accessor, currentAccessor, valueAccessor, appAccessor);
+  _getAttributeIndex(locationOrName) {
+    const location = Number(locationOrName);
 
-      var size = accessor.size,
-          type = accessor.type;
-      (0, _assert.assert)(Number.isFinite(size) && Number.isFinite(type));
+    if (Number.isFinite(location)) {
       return {
-        location: location,
-        accessor: accessor
+        location
       };
     }
-  }, {
-    key: "_getAttributeInfo",
-    value: function _getAttributeInfo(attributeName) {
-      return this.configuration && this.configuration.getAttributeInfo(attributeName);
-    }
-  }, {
-    key: "_getAttributeIndex",
-    value: function _getAttributeIndex(locationOrName) {
-      var location = Number(locationOrName);
-
-      if (Number.isFinite(location)) {
-        return {
-          location: location
-        };
-      }
-
-      var multiLocation = MULTI_LOCATION_ATTRIBUTE_REGEXP.exec(locationOrName);
-      var name = multiLocation ? multiLocation[1] : locationOrName;
-      var locationOffset = multiLocation ? Number(multiLocation[2]) : 0;
 
-      if (this.configuration) {
-        return {
-          location: this.configuration.getAttributeLocation(name) + locationOffset,
-          name: name
-        };
-      }
+    const multiLocation = MULTI_LOCATION_ATTRIBUTE_REGEXP.exec(locationOrName);
+    const name = multiLocation ? multiLocation[1] : locationOrName;
+    const locationOffset = multiLocation ? Number(multiLocation[2]) : 0;
 
+    if (this.configuration) {
       return {
-        location: -1
+        location: this.configuration.getAttributeLocation(name) + locationOffset,
+        name
       };
     }
-  }, {
-    key: "_setAttribute",
-    value: function _setAttribute(locationOrName, value) {
-      if (value instanceof _buffer.default) {
-        this.setBuffer(locationOrName, value);
-      } else if (Array.isArray(value) && value.length && value[0] instanceof _buffer.default) {
-        var buffer = value[0];
-        var accessor = value[1];
-        this.setBuffer(locationOrName, buffer, accessor);
-      } else if (ArrayBuffer.isView(value) || Array.isArray(value)) {
-        var constant = value;
-        this.setConstant(locationOrName, constant);
-      } else if (value.buffer instanceof _buffer.default) {
-        var _accessor = value;
-        this.setBuffer(locationOrName, _accessor.buffer, _accessor);
-      } else {
-        throw new Error(ERR_ATTRIBUTE_TYPE);
-      }
+
+    return {
+      location: -1
+    };
+  }
+
+  _setAttribute(locationOrName, value) {
+    if (value instanceof _webglBuffer.default) {
+      this.setBuffer(locationOrName, value);
+    } else if (Array.isArray(value) && value.length && value[0] instanceof _webglBuffer.default) {
+      const buffer = value[0];
+      const accessor = value[1];
+      this.setBuffer(locationOrName, buffer, accessor);
+    } else if (ArrayBuffer.isView(value) || Array.isArray(value)) {
+      const constant = value;
+      this.setConstant(locationOrName, constant);
+    } else if (value.buffer instanceof _webglBuffer.default) {
+      const accessor = value;
+      this.setBuffer(locationOrName, accessor.buffer, accessor);
+    } else {
+      throw new Error(ERR_ATTRIBUTE_TYPE);
+    }
+  }
+
+  _setConstantAttributes(vertexCount, instanceCount) {
+    const elementCount = Math.max(vertexCount | 0, instanceCount | 0);
+    let constant = this.values[0];
+
+    if (ArrayBuffer.isView(constant)) {
+      this._setConstantAttributeZero(constant, elementCount);
     }
-  }, {
-    key: "_setConstantAttributes",
-    value: function _setConstantAttributes(vertexCount, instanceCount) {
-      var elementCount = Math.max(vertexCount | 0, instanceCount | 0);
-      var constant = this.values[0];
+
+    for (let location = 1; location < this.vertexArrayObject.MAX_ATTRIBUTES; location++) {
+      constant = this.values[location];
 
       if (ArrayBuffer.isView(constant)) {
-        this._setConstantAttributeZero(constant, elementCount);
+        this._setConstantAttribute(location, constant);
       }
+    }
+  }
 
-      for (var location = 1; location < this.vertexArrayObject.MAX_ATTRIBUTES; location++) {
-        constant = this.values[location];
+  _setConstantAttributeZero(constant, elementCount) {
+    if (_vertexArrayObject.default.isSupported(this.gl, {
+      constantAttributeZero: true
+    })) {
+      this._setConstantAttribute(0, constant);
 
-        if (ArrayBuffer.isView(constant)) {
-          this._setConstantAttribute(location, constant);
-        }
-      }
+      return;
     }
-  }, {
-    key: "_setConstantAttributeZero",
-    value: function _setConstantAttributeZero(constant, elementCount) {
-      if (_vertexArrayObject.default.isSupported(this.gl, {
-        constantAttributeZero: true
-      })) {
-        this._setConstantAttribute(0, constant);
-
-        return;
-      }
 
-      var buffer = this.vertexArrayObject.getConstantBuffer(elementCount, constant);
-      this.vertexArrayObject.setBuffer(0, buffer, this.accessors[0]);
+    const buffer = this.vertexArrayObject.getConstantBuffer(elementCount, constant);
+    this.vertexArrayObject.setBuffer(0, buffer, this.accessors[0]);
+  }
+
+  _setConstantAttribute(location, constant) {
+    _vertexArrayObject.default.setConstant(this.gl, location, constant);
+  }
+
+  _updateDrawParams() {
+    const drawParams = {
+      elementCount: 0,
+      indexType: Uint16Array,
+      indexOffset: 0,
+      isIndexed: false,
+      isInstanced: false,
+      indexCount: Infinity,
+      vertexCount: Infinity,
+      instanceCount: Infinity
+    };
+
+    for (let location = 0; location < this.vertexArrayObject.MAX_ATTRIBUTES; location++) {
+      this._updateDrawParamsForLocation(drawParams, location);
     }
-  }, {
-    key: "_setConstantAttribute",
-    value: function _setConstantAttribute(location, constant) {
-      _vertexArrayObject.default.setConstant(this.gl, location, constant);
+
+    if (this.elements) {
+      drawParams.elementCount = this.elements.getElementCount(this.elements.accessor);
+      drawParams.isIndexed = true;
+      drawParams.indexType = this.elementsAccessor.type || this.elements.accessor.type;
+      drawParams.indexOffset = this.elementsAccessor.offset || 0;
     }
-  }, {
-    key: "_updateDrawParams",
-    value: function _updateDrawParams() {
-      var drawParams = {
-        isIndexed: false,
-        isInstanced: false,
-        indexCount: Infinity,
-        vertexCount: Infinity,
-        instanceCount: Infinity
-      };
 
-      for (var location = 0; location < this.vertexArrayObject.MAX_ATTRIBUTES; location++) {
-        this._updateDrawParamsForLocation(drawParams, location);
-      }
+    if (drawParams.indexCount === Infinity) {
+      drawParams.indexCount = 0;
+    }
 
-      if (this.elements) {
-        drawParams.elementCount = this.elements.getElementCount(this.elements.accessor);
-        drawParams.isIndexed = true;
-        drawParams.indexType = this.elementsAccessor.type || this.elements.accessor.type;
-        drawParams.indexOffset = this.elementsAccessor.offset || 0;
-      }
+    if (drawParams.vertexCount === Infinity) {
+      drawParams.vertexCount = 0;
+    }
 
-      if (drawParams.indexCount === Infinity) {
-        drawParams.indexCount = 0;
-      }
+    if (drawParams.instanceCount === Infinity) {
+      drawParams.instanceCount = 0;
+    }
 
-      if (drawParams.vertexCount === Infinity) {
-        drawParams.vertexCount = 0;
-      }
+    return drawParams;
+  }
 
-      if (drawParams.instanceCount === Infinity) {
-        drawParams.instanceCount = 0;
-      }
+  _updateDrawParamsForLocation(drawParams, location) {
+    const value = this.values[location];
+    const accessor = this.accessors[location];
 
-      return drawParams;
+    if (!value) {
+      return;
     }
-  }, {
-    key: "_updateDrawParamsForLocation",
-    value: function _updateDrawParamsForLocation(drawParams, location) {
-      var value = this.values[location];
-      var accessor = this.accessors[location];
-
-      if (!value) {
-        return;
-      }
 
-      var divisor = accessor.divisor;
-      var isInstanced = divisor > 0;
-      drawParams.isInstanced = drawParams.isInstanced || isInstanced;
+    const {
+      divisor
+    } = accessor;
+    const isInstanced = divisor > 0;
+    drawParams.isInstanced = drawParams.isInstanced || isInstanced;
 
-      if (value instanceof _buffer.default) {
-        var buffer = value;
+    if (value instanceof _webglBuffer.default) {
+      const buffer = value;
 
-        if (isInstanced) {
-          var instanceCount = buffer.getVertexCount(accessor);
-          drawParams.instanceCount = Math.min(drawParams.instanceCount, instanceCount);
-        } else {
-          var vertexCount = buffer.getVertexCount(accessor);
-          drawParams.vertexCount = Math.min(drawParams.vertexCount, vertexCount);
-        }
+      if (isInstanced) {
+        const instanceCount = buffer.getVertexCount(accessor);
+        drawParams.instanceCount = Math.min(drawParams.instanceCount, instanceCount);
+      } else {
+        const vertexCount = buffer.getVertexCount(accessor);
+        drawParams.vertexCount = Math.min(drawParams.vertexCount, vertexCount);
       }
     }
-  }, {
-    key: "setElements",
-    value: function setElements() {
-      var elementBuffer = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : null;
-      var accessor = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
+  }
 
-      _gltools.log.deprecated('setElements', 'setElementBuffer')();
+  setElements(elementBuffer = null, accessor = {}) {
+    _gltools.log.deprecated('setElements', 'setElementBuffer')();
 
-      return this.setElementBuffer(elementBuffer, accessor);
-    }
-  }]);
-  return VertexArray;
-}();
+    return this.setElementBuffer(elementBuffer, accessor);
+  }
+
+}
 
 exports.default = VertexArray;
 //# sourceMappingURL=vertex-array.js.map