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

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

@@ -7,25 +7,32 @@ Object.defineProperty(exports, "__esModule", {
 });
 exports.default = void 0;
 
+var _classCallCheck2 = _interopRequireDefault(require("@babel/runtime/helpers/classCallCheck"));
+
+var _createClass2 = _interopRequireDefault(require("@babel/runtime/helpers/createClass"));
+
 var _defineProperty2 = _interopRequireDefault(require("@babel/runtime/helpers/defineProperty"));
 
-var _constants = _interopRequireDefault(require("@luma.gl/constants"));
+var _api = require("@luma.gl/api");
 
-var _gltools = require("@luma.gl/gltools");
+var _constants = _interopRequireDefault(require("@luma.gl/constants"));
 
-var _accessor = _interopRequireDefault(require("./accessor"));
+var _accessor2 = _interopRequireDefault(require("./accessor"));
 
 var _webglBuffer = _interopRequireDefault(require("./webgl-buffer"));
 
 var _vertexArrayObject = _interopRequireDefault(require("./vertex-array-object"));
 
-var _utils = require("../utils");
+function ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); if (enumerableOnly) { symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; }); } keys.push.apply(keys, symbols); } return keys; }
 
-const ERR_ATTRIBUTE_TYPE = 'VertexArray: attributes must be Buffers or constants (i.e. typed array)';
-const MULTI_LOCATION_ATTRIBUTE_REGEXP = /^(.+)__LOCATION_([0-9]+)$/;
+function _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i] != null ? arguments[i] : {}; if (i % 2) { ownKeys(Object(source), true).forEach(function (key) { (0, _defineProperty2.default)(target, key, source[key]); }); } else if (Object.getOwnPropertyDescriptors) { Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)); } else { ownKeys(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } } return target; }
 
-class VertexArray {
-  constructor(gl, props) {
+var ERR_ATTRIBUTE_TYPE = 'VertexArray: attributes must be Buffers or constants (i.e. typed array)';
+var MULTI_LOCATION_ATTRIBUTE_REGEXP = /^(.+)__LOCATION_([0-9]+)$/;
+
+var VertexArray = function () {
+  function VertexArray(gl, props) {
+    (0, _classCallCheck2.default)(this, VertexArray);
     (0, _defineProperty2.default)(this, "id", void 0);
     (0, _defineProperty2.default)(this, "gl", void 0);
     (0, _defineProperty2.default)(this, "attributes", {});
@@ -39,7 +46,7 @@ class VertexArray {
     (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);
+    var 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;
@@ -48,373 +55,411 @@ class VertexArray {
     Object.seal(this);
   }
 
-  delete() {
-    if (this.buffer) {
-      this.buffer.delete();
-    }
-
-    this.vertexArrayObject.delete();
-  }
-
-  initialize(props) {
-    this.reset();
-    this.configuration = null;
-    this.bindOnUse = false;
-    return this.setProps(props || {});
-  }
-
-  reset() {
-    this.elements = null;
-    this.elementsAccessor = 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;
-    return this;
-  }
-
-  setProps(props) {
-    if ('program' in props) {
-      this.configuration = props.program && props.program.configuration;
-    }
-
-    if ('configuration' in props) {
-      this.configuration = props.configuration;
-    }
+  (0, _createClass2.default)(VertexArray, [{
+    key: "delete",
+    value: function _delete() {
+      if (this.buffer) {
+        this.buffer.delete();
+      }
 
-    if ('attributes' in props) {
-      this.setAttributes(props.attributes);
+      this.vertexArrayObject.delete();
     }
-
-    if ('elements' in props) {
-      this.setElementBuffer(props.elements);
+  }, {
+    key: "initialize",
+    value: function initialize(props) {
+      this.reset();
+      this.configuration = null;
+      this.bindOnUse = false;
+      return this.setProps(props || {});
     }
-
-    if ('bindOnUse' in props) {
-      props = props.bindOnUse;
+  }, {
+    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;
     }
+  }, {
+    key: "setProps",
+    value: function setProps(props) {
+      if ('program' in props) {
+        this.configuration = props.program && props.program.configuration;
+      }
 
-    return this;
-  }
-
-  clearDrawParams() {
-    this.drawParams = null;
-  }
-
-  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];
+      if ('configuration' in props) {
+        this.configuration = props.configuration;
+      }
 
-        this._setAttribute(locationOrName, value);
+      if ('attributes' in props) {
+        this.setAttributes(props.attributes);
       }
 
-      this.gl.bindBuffer(_constants.default.ARRAY_BUFFER, null);
-    });
-    return this;
-  }
+      if ('elements' in props) {
+        this.setElementBuffer(props.elements);
+      }
 
-  setElementBuffer(elementBuffer = null, accessor = {}) {
-    this.elements = elementBuffer;
-    this.elementsAccessor = accessor;
-    this.clearDrawParams();
-    this.vertexArrayObject.setElementBuffer(elementBuffer, accessor);
-    return this;
-  }
+      if ('bindOnUse' in props) {
+        props = props.bindOnUse;
+      }
 
-  setBuffer(locationOrName, buffer, appAccessor = {}) {
-    if (buffer.target === _constants.default.ELEMENT_ARRAY_BUFFER) {
-      this.setElementBuffer(buffer, appAccessor);
       return this;
     }
-
-    const {
-      location,
-      accessor
-    } = this._resolveLocationAndAccessor(locationOrName, buffer, buffer.accessor, appAccessor);
-
-    if (location >= 0) {
-      this.values[location] = buffer;
-      this.accessors[location] = accessor;
-      this.clearDrawParams();
-      this.vertexArrayObject.setBuffer(location, buffer, accessor);
+  }, {
+    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;
 
-    return this;
-  }
+      Object.assign(this.attributes, attributes);
+      this.vertexArrayObject.bind(function () {
+        for (var locationOrName in attributes) {
+          var value = attributes[locationOrName];
 
-  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._setAttribute(locationOrName, value);
+        }
+
+        _this.gl.bindBuffer(_constants.default.ARRAY_BUFFER, null);
+      });
+      return this;
+    }
+  }, {
+    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;
       this.clearDrawParams();
-      this.vertexArrayObject.enable(location, false);
+      this.vertexArrayObject.setElementBuffer(elementBuffer, accessor);
+      return this;
     }
-
-    return this;
-  }
-
-  unbindBuffers() {
-    this.vertexArrayObject.bind(() => {
-      if (this.elements) {
-        this.vertexArrayObject.setElementBuffer(null);
+  }, {
+    key: "setBuffer",
+    value: function setBuffer(locationOrName, buffer) {
+      var appAccessor = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {};
+
+      if (buffer.target === _constants.default.ELEMENT_ARRAY_BUFFER) {
+        this.setElementBuffer(buffer, appAccessor);
+        return this;
       }
 
-      this.buffer = this.buffer || new _webglBuffer.default(this.gl, {
-        accessor: {
-          size: 4
-        }
-      });
+      var _this$_resolveLocatio = this._resolveLocationAndAccessor(locationOrName, buffer, buffer.accessor, appAccessor),
+          location = _this$_resolveLocatio.location,
+          accessor = _this$_resolveLocatio.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);
-        }
+      if (location >= 0) {
+        this.values[location] = buffer;
+        this.accessors[location] = accessor;
+        this.clearDrawParams();
+        this.vertexArrayObject.setBuffer(location, buffer, accessor);
       }
-    });
-    return this;
-  }
 
-  bindBuffers() {
-    this.vertexArrayObject.bind(() => {
-      if (this.elements) {
-        this.setElementBuffer(this.elements);
+      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, _objectSpread({
+        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);
       }
 
-      for (let location = 0; location < this.vertexArrayObject.MAX_ATTRIBUTES; location++) {
-        const buffer = this.values[location];
-
-        if (buffer instanceof _webglBuffer.default) {
-          this.setBuffer(location, buffer);
+      return this;
+    }
+  }, {
+    key: "unbindBuffers",
+    value: function unbindBuffers() {
+      var _this2 = this;
+
+      this.vertexArrayObject.bind(function () {
+        if (_this2.elements) {
+          _this2.vertexArrayObject.setElementBuffer(null);
         }
-      }
-    });
-    return this;
-  }
 
-  bindForDraw(vertexCount, instanceCount, func) {
-    let value;
-    this.vertexArrayObject.bind(() => {
-      this._setConstantAttributes(vertexCount, instanceCount);
+        _this2.buffer = _this2.buffer || new _webglBuffer.default(_this2.gl, {
+          accessor: {
+            size: 4
+          }
+        });
 
-      value = func();
-    });
-    return value;
-  }
+        for (var location = 0; location < _this2.vertexArrayObject.MAX_ATTRIBUTES; location++) {
+          if (_this2.values[location] instanceof _webglBuffer.default) {
+            _this2.gl.disableVertexAttribArray(location);
 
-  _resolveLocationAndAccessor(locationOrName, value, valueAccessor, appAccessor) {
-    const INVALID_RESULT = {
-      location: -1,
-      accessor: null
-    };
+            _this2.gl.bindBuffer(_constants.default.ARRAY_BUFFER, _this2.buffer.handle);
 
-    const {
-      location,
-      name
-    } = this._getAttributeIndex(locationOrName);
-
-    if (!Number.isFinite(location) || location < 0) {
-      this.unused[locationOrName] = value;
+            _this2.gl.vertexAttribPointer(location, 1, _constants.default.FLOAT, false, 0, 0);
+          }
+        }
+      });
+      return this;
+    }
+  }, {
+    key: "bindBuffers",
+    value: function bindBuffers() {
+      var _this3 = this;
+
+      this.vertexArrayObject.bind(function () {
+        if (_this3.elements) {
+          _this3.setElementBuffer(_this3.elements);
+        }
 
-      _gltools.log.once(3, () => "unused value ".concat(locationOrName, " in ").concat(this.id))();
+        for (var location = 0; location < _this3.vertexArrayObject.MAX_ATTRIBUTES; location++) {
+          var buffer = _this3.values[location];
 
-      return INVALID_RESULT;
+          if (buffer instanceof _webglBuffer.default) {
+            _this3.setBuffer(location, buffer);
+          }
+        }
+      });
+      return this;
     }
+  }, {
+    key: "bindForDraw",
+    value: function bindForDraw(vertexCount, instanceCount, func) {
+      var _this4 = this;
 
-    const accessInfo = this._getAttributeInfo(name || location);
+      var value;
+      this.vertexArrayObject.bind(function () {
+        _this4._setConstantAttributes(vertexCount, instanceCount);
 
-    if (!accessInfo) {
-      return INVALID_RESULT;
+        value = func();
+      });
+      return value;
     }
+  }, {
+    key: "_resolveLocationAndAccessor",
+    value: function _resolveLocationAndAccessor(locationOrName, value, valueAccessor, appAccessor) {
+      var _this5 = this;
+
+      var INVALID_RESULT = {
+        location: -1,
+        accessor: null
+      };
 
-    const currentAccessor = this.accessors[location] || {};
+      var _this$_getAttributeIn = this._getAttributeIndex(locationOrName),
+          location = _this$_getAttributeIn.location,
+          name = _this$_getAttributeIn.name;
 
-    const accessor = _accessor.default.resolve(accessInfo.accessor, currentAccessor, valueAccessor, appAccessor);
+      if (!Number.isFinite(location) || location < 0) {
+        this.unused[locationOrName] = value;
 
-    const {
-      size,
-      type
-    } = accessor;
-    (0, _utils.assert)(Number.isFinite(size) && Number.isFinite(type));
-    return {
-      location,
-      accessor
-    };
-  }
+        _api.log.once(3, function () {
+          return "unused value ".concat(locationOrName, " in ").concat(_this5.id);
+        })();
 
-  _getAttributeInfo(attributeName) {
-    return this.configuration && this.configuration.getAttributeInfo(attributeName);
-  }
+        return INVALID_RESULT;
+      }
 
-  _getAttributeIndex(locationOrName) {
-    const location = Number(locationOrName);
+      var accessInfo = this._getAttributeInfo(name || location);
 
-    if (Number.isFinite(location)) {
-      return {
-        location
-      };
-    }
+      if (!accessInfo) {
+        return INVALID_RESULT;
+      }
+
+      var currentAccessor = this.accessors[location] || {};
 
-    const multiLocation = MULTI_LOCATION_ATTRIBUTE_REGEXP.exec(locationOrName);
-    const name = multiLocation ? multiLocation[1] : locationOrName;
-    const locationOffset = multiLocation ? Number(multiLocation[2]) : 0;
+      var accessor = _accessor2.default.resolve(accessInfo.accessor, currentAccessor, valueAccessor, appAccessor);
 
-    if (this.configuration) {
+      var size = accessor.size,
+          type = accessor.type;
+      (0, _api.assert)(Number.isFinite(size) && Number.isFinite(type));
       return {
-        location: this.configuration.getAttributeLocation(name) + locationOffset,
-        name
+        location: location,
+        accessor: accessor
       };
     }
-
-    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);
+  }, {
+    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
+        };
+      }
 
-  _setConstantAttributes(vertexCount, instanceCount) {
-    const elementCount = Math.max(vertexCount | 0, instanceCount | 0);
-    let constant = this.values[0];
+      var multiLocation = MULTI_LOCATION_ATTRIBUTE_REGEXP.exec(locationOrName);
+      var name = multiLocation ? multiLocation[1] : locationOrName;
+      var locationOffset = multiLocation ? Number(multiLocation[2]) : 0;
 
-    if (ArrayBuffer.isView(constant)) {
-      this._setConstantAttributeZero(constant, elementCount);
-    }
+      if (this.configuration) {
+        return {
+          location: this.configuration.getAttributeLocation(name) + locationOffset,
+          name: name
+        };
+      }
 
-    for (let location = 1; location < this.vertexArrayObject.MAX_ATTRIBUTES; location++) {
-      constant = this.values[location];
+      return {
+        location: -1
+      };
+    }
+  }, {
+    key: "_setAttribute",
+    value: function _setAttribute(locationOrName, value) {
+      if (value instanceof _webglBuffer.default) {
+        this.setBuffer(locationOrName, value);
+      } else if (Array.isArray(value) && value.length && value[0] instanceof _webglBuffer.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 _webglBuffer.default) {
+        var _accessor = value;
+        this.setBuffer(locationOrName, _accessor.buffer, _accessor);
+      } else {
+        throw new Error(ERR_ATTRIBUTE_TYPE);
+      }
+    }
+  }, {
+    key: "_setConstantAttributes",
+    value: function _setConstantAttributes(vertexCount, instanceCount) {
+      var elementCount = Math.max(vertexCount | 0, instanceCount | 0);
+      var constant = this.values[0];
 
       if (ArrayBuffer.isView(constant)) {
-        this._setConstantAttribute(location, constant);
+        this._setConstantAttributeZero(constant, elementCount);
       }
-    }
-  }
 
-  _setConstantAttributeZero(constant, elementCount) {
-    if (_vertexArrayObject.default.isSupported(this.gl, {
-      constantAttributeZero: true
-    })) {
-      this._setConstantAttribute(0, constant);
+      for (var location = 1; location < this.vertexArrayObject.MAX_ATTRIBUTES; location++) {
+        constant = this.values[location];
 
-      return;
+        if (ArrayBuffer.isView(constant)) {
+          this._setConstantAttribute(location, constant);
+        }
+      }
     }
+  }, {
+    key: "_setConstantAttributeZero",
+    value: function _setConstantAttributeZero(constant, elementCount) {
+      if (_vertexArrayObject.default.isSupported(this.gl, {
+        constantAttributeZero: true
+      })) {
+        this._setConstantAttribute(0, constant);
+
+        return;
+      }
 
-    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);
+      var buffer = this.vertexArrayObject.getConstantBuffer(elementCount, constant);
+      this.vertexArrayObject.setBuffer(0, buffer, this.accessors[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;
+  }, {
+    key: "_setConstantAttribute",
+    value: function _setConstantAttribute(location, constant) {
+      _vertexArrayObject.default.setConstant(this.gl, location, constant);
     }
+  }, {
+    key: "_updateDrawParams",
+    value: function _updateDrawParams() {
+      var drawParams = {
+        elementCount: 0,
+        indexType: Uint16Array,
+        indexOffset: 0,
+        isIndexed: false,
+        isInstanced: false,
+        indexCount: Infinity,
+        vertexCount: Infinity,
+        instanceCount: Infinity
+      };
 
-    if (drawParams.indexCount === Infinity) {
-      drawParams.indexCount = 0;
-    }
+      for (var location = 0; location < this.vertexArrayObject.MAX_ATTRIBUTES; location++) {
+        this._updateDrawParamsForLocation(drawParams, location);
+      }
 
-    if (drawParams.vertexCount === Infinity) {
-      drawParams.vertexCount = 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.instanceCount === Infinity) {
-      drawParams.instanceCount = 0;
-    }
+      if (drawParams.indexCount === Infinity) {
+        drawParams.indexCount = 0;
+      }
 
-    return drawParams;
-  }
+      if (drawParams.vertexCount === Infinity) {
+        drawParams.vertexCount = 0;
+      }
 
-  _updateDrawParamsForLocation(drawParams, location) {
-    const value = this.values[location];
-    const accessor = this.accessors[location];
+      if (drawParams.instanceCount === Infinity) {
+        drawParams.instanceCount = 0;
+      }
 
-    if (!value) {
-      return;
+      return drawParams;
     }
+  }, {
+    key: "_updateDrawParamsForLocation",
+    value: function _updateDrawParamsForLocation(drawParams, location) {
+      var value = this.values[location];
+      var accessor = this.accessors[location];
+
+      if (!value) {
+        return;
+      }
 
-    const {
-      divisor
-    } = accessor;
-    const isInstanced = divisor > 0;
-    drawParams.isInstanced = drawParams.isInstanced || isInstanced;
+      var divisor = accessor.divisor;
+      var isInstanced = divisor > 0;
+      drawParams.isInstanced = drawParams.isInstanced || isInstanced;
 
-    if (value instanceof _webglBuffer.default) {
-      const buffer = value;
+      if (value instanceof _webglBuffer.default) {
+        var buffer = value;
 
-      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);
+        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);
+        }
       }
     }
-  }
+  }, {
+    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] : {};
 
-  setElements(elementBuffer = null, accessor = {}) {
-    _gltools.log.deprecated('setElements', 'setElementBuffer')();
+      _api.log.deprecated('setElements', 'setElementBuffer')();
 
-    return this.setElementBuffer(elementBuffer, accessor);
-  }
-
-}
+      return this.setElementBuffer(elementBuffer, accessor);
+    }
+  }]);
+  return VertexArray;
+}();
 
 exports.default = VertexArray;
 //# sourceMappingURL=vertex-array.js.map