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

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

@@ -7,271 +7,330 @@ Object.defineProperty(exports, "__esModule", {
 });
 exports.default = void 0;
 
-var _defineProperty2 = _interopRequireDefault(require("@babel/runtime/helpers/defineProperty"));
+var _classCallCheck2 = _interopRequireDefault(require("@babel/runtime/helpers/classCallCheck"));
 
-var _constants = _interopRequireDefault(require("@luma.gl/constants"));
+var _createClass2 = _interopRequireDefault(require("@babel/runtime/helpers/createClass"));
 
-var _gltools = require("@luma.gl/gltools");
+var _assertThisInitialized2 = _interopRequireDefault(require("@babel/runtime/helpers/assertThisInitialized"));
 
-var _probe = require("probe.gl");
+var _get2 = _interopRequireDefault(require("@babel/runtime/helpers/get"));
 
-var _webglResource = _interopRequireDefault(require("./webgl-resource"));
+var _inherits2 = _interopRequireDefault(require("@babel/runtime/helpers/inherits"));
 
-var _webglBuffer = _interopRequireDefault(require("./webgl-buffer"));
+var _possibleConstructorReturn2 = _interopRequireDefault(require("@babel/runtime/helpers/possibleConstructorReturn"));
 
-var _arrayUtilsFlat = require("../utils/array-utils-flat");
+var _getPrototypeOf2 = _interopRequireDefault(require("@babel/runtime/helpers/getPrototypeOf"));
 
-var _utils = require("../utils");
+var _defineProperty2 = _interopRequireDefault(require("@babel/runtime/helpers/defineProperty"));
 
-var _lumaContextData = require("../context/luma-context-data");
+var _api = require("@luma.gl/api");
 
-const ERR_ELEMENTS = 'elements must be GL.ELEMENT_ARRAY_BUFFER';
+var _constants = _interopRequireDefault(require("@luma.gl/constants"));
 
-class VertexArrayObject extends _webglResource.default {
-  static isSupported(gl, options) {
-    if (options !== null && options !== void 0 && options.constantAttributeZero) {
-      return (0, _gltools.isWebGL2)(gl) || (0, _probe.getBrowser)() === 'Chrome';
-    }
+var _env = require("@probe.gl/env");
 
-    return true;
-  }
+var _webglDevice = _interopRequireDefault(require("../adapter/webgl-device"));
 
-  static getDefaultArray(gl) {
-    const lumaContextData = (0, _lumaContextData.getLumaContextData)(gl);
-    lumaContextData.defaultVertexArray = lumaContextData.defaultVertexArray || new VertexArrayObject(gl, {
-      handle: null,
-      isDefaultArray: true
-    });
-    return lumaContextData.defaultVertexArray;
-  }
+var _webglChecks = require("../context/context/webgl-checks");
 
-  static getMaxAttributes(gl) {
-    VertexArrayObject.MAX_ATTRIBUTES = VertexArrayObject.MAX_ATTRIBUTES || gl.getParameter(gl.MAX_VERTEX_ATTRIBS);
-    return VertexArrayObject.MAX_ATTRIBUTES;
-  }
+var _webglResource = _interopRequireDefault(require("./webgl-resource"));
 
-  static setConstant(gl, location, array) {
-    switch (array.constructor) {
-      case Float32Array:
-        VertexArrayObject._setConstantFloatArray(gl, location, array);
+var _webglBuffer = _interopRequireDefault(require("./webgl-buffer"));
 
-        break;
+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; }
 
-      case Int32Array:
-        VertexArrayObject._setConstantIntArray((0, _gltools.assertWebGL2Context)(gl), location, array);
+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; }
 
-        break;
+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); }; }
 
-      case Uint32Array:
-        VertexArrayObject._setConstantUintArray((0, _gltools.assertWebGL2Context)(gl), location, array);
+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; } }
 
-        break;
+var ERR_ELEMENTS = 'elements must be GL.ELEMENT_ARRAY_BUFFER';
 
-      default:
-        (0, _utils.assert)(false);
-    }
-  }
+var VertexArrayObject = function (_WebGLResource) {
+  (0, _inherits2.default)(VertexArrayObject, _WebGLResource);
 
-  constructor(gl, opts) {
-    super(gl, { ...opts,
-      id: (opts === null || opts === void 0 ? void 0 : opts.id) || (opts === null || opts === void 0 ? void 0 : opts.program) && (opts === null || opts === void 0 ? void 0 : opts.program.id)
-    }, {});
-    (0, _defineProperty2.default)(this, "buffer", null);
-    (0, _defineProperty2.default)(this, "bufferValue", null);
-    (0, _defineProperty2.default)(this, "isDefaultArray", false);
-    this.buffer = null;
-    this.bufferValue = null;
-    this.isDefaultArray = (opts === null || opts === void 0 ? void 0 : opts.isDefaultArray) || false;
-    Object.seal(this);
-  }
+  var _super = _createSuper(VertexArrayObject);
 
-  delete() {
-    super.delete();
+  function VertexArrayObject(gl, props) {
+    var _this;
 
-    if (this.buffer) {
-      this.buffer.delete();
-    }
-
-    return this;
+    (0, _classCallCheck2.default)(this, VertexArrayObject);
+    _this = _super.call(this, _webglDevice.default.attach(gl), _objectSpread(_objectSpread({}, props), {}, {
+      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)
+    }), {});
+    (0, _defineProperty2.default)((0, _assertThisInitialized2.default)(_this), "buffer", null);
+    (0, _defineProperty2.default)((0, _assertThisInitialized2.default)(_this), "bufferValue", null);
+    (0, _defineProperty2.default)((0, _assertThisInitialized2.default)(_this), "isDefaultArray", false);
+    _this.buffer = null;
+    _this.bufferValue = null;
+    _this.isDefaultArray = (props === null || props === void 0 ? void 0 : props.isDefaultArray) || false;
+    Object.seal((0, _assertThisInitialized2.default)(_this));
+    return _this;
   }
 
-  get MAX_ATTRIBUTES() {
-    return VertexArrayObject.getMaxAttributes(this.gl);
-  }
+  (0, _createClass2.default)(VertexArrayObject, [{
+    key: "delete",
+    value: function _delete() {
+      (0, _get2.default)((0, _getPrototypeOf2.default)(VertexArrayObject.prototype), "delete", this).call(this);
 
-  setElementBuffer(elementBuffer = null, opts = {}) {
-    (0, _utils.assert)(!elementBuffer || elementBuffer.target === _constants.default.ELEMENT_ARRAY_BUFFER, ERR_ELEMENTS);
-    this.bind(() => {
-      this.gl.bindBuffer(_constants.default.ELEMENT_ARRAY_BUFFER, elementBuffer ? elementBuffer.handle : null);
-    });
-    return this;
-  }
+      if (this.buffer) {
+        this.buffer.delete();
+      }
 
-  setBuffer(location, buffer, accessor) {
-    if (buffer.target === _constants.default.ELEMENT_ARRAY_BUFFER) {
-      return this.setElementBuffer(buffer, accessor);
+      return this;
     }
-
-    const {
-      size,
-      type,
-      stride,
-      offset,
-      normalized,
-      integer,
-      divisor
-    } = accessor;
-    const {
-      gl,
-      gl2
-    } = this;
-    location = Number(location);
-    this.bind(() => {
-      gl.bindBuffer(gl.ARRAY_BUFFER, buffer.handle);
-
-      if (integer) {
-        (0, _utils.assert)((0, _gltools.isWebGL2)(gl));
-        gl2.vertexAttribIPointer(location, size, type, stride, offset);
-      } else {
-        gl.vertexAttribPointer(location, size, type, normalized, stride, offset);
+  }, {
+    key: "MAX_ATTRIBUTES",
+    get: function get() {
+      return VertexArrayObject.getMaxAttributes(this.gl);
+    }
+  }, {
+    key: "setElementBuffer",
+    value: function setElementBuffer() {
+      var _this2 = this;
+
+      var elementBuffer = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : null;
+      var opts = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
+      (0, _api.assert)(!elementBuffer || elementBuffer.target === _constants.default.ELEMENT_ARRAY_BUFFER, ERR_ELEMENTS);
+      this.bind(function () {
+        _this2.gl.bindBuffer(_constants.default.ELEMENT_ARRAY_BUFFER, elementBuffer ? elementBuffer.handle : null);
+      });
+      return this;
+    }
+  }, {
+    key: "setBuffer",
+    value: function setBuffer(location, buffer, accessor) {
+      if (buffer.target === _constants.default.ELEMENT_ARRAY_BUFFER) {
+        return this.setElementBuffer(buffer, accessor);
       }
 
-      gl.enableVertexAttribArray(location);
-      gl2.vertexAttribDivisor(location, divisor || 0);
-    });
-    return this;
-  }
-
-  enable(location, enable = true) {
-    const disablingAttributeZero = !enable && location === 0 && !VertexArrayObject.isSupported(this.gl, {
-      constantAttributeZero: true
-    });
-
-    if (!disablingAttributeZero) {
+      var size = accessor.size,
+          type = accessor.type,
+          stride = accessor.stride,
+          offset = accessor.offset,
+          normalized = accessor.normalized,
+          integer = accessor.integer,
+          divisor = accessor.divisor;
+      var gl = this.gl,
+          gl2 = this.gl2;
       location = Number(location);
-      this.bind(() => enable ? this.gl.enableVertexAttribArray(location) : this.gl.disableVertexAttribArray(location));
-    }
-
-    return this;
-  }
-
-  getConstantBuffer(elementCount, value) {
-    const constantValue = this._normalizeConstantArrayValue(value);
-
-    const byteLength = constantValue.byteLength * elementCount;
-    const length = constantValue.length * elementCount;
-    let updateNeeded = !this.buffer;
-    this.buffer = this.buffer || new _webglBuffer.default(this.gl, byteLength);
-    updateNeeded = updateNeeded || this.buffer.reallocate(byteLength);
-    updateNeeded = updateNeeded || !this._compareConstantArrayValues(constantValue, this.bufferValue);
-
-    if (updateNeeded) {
-      const typedArray = (0, _arrayUtilsFlat.getScratchArray)(value.constructor, length);
-      (0, _arrayUtilsFlat.fillArray)({
-        target: typedArray,
-        source: constantValue,
-        start: 0,
-        count: length
+      this.bind(function () {
+        gl.bindBuffer(gl.ARRAY_BUFFER, buffer.handle);
+
+        if (integer) {
+          (0, _api.assert)((0, _webglChecks.isWebGL2)(gl));
+          gl2.vertexAttribIPointer(location, size, type, stride, offset);
+        } else {
+          gl.vertexAttribPointer(location, size, type, normalized, stride, offset);
+        }
+
+        gl.enableVertexAttribArray(location);
+        gl2.vertexAttribDivisor(location, divisor || 0);
       });
-      this.buffer.subData(typedArray);
-      this.bufferValue = value;
+      return this;
     }
+  }, {
+    key: "enable",
+    value: function enable(location) {
+      var _this3 = this;
 
-    return this.buffer;
-  }
+      var _enable = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : true;
 
-  initialize(props) {
-    return this.setProps(props);
-  }
+      var disablingAttributeZero = !_enable && location === 0 && !VertexArrayObject.isSupported(this.gl, {
+        constantAttributeZero: true
+      });
 
-  setProps(props) {
-    return this;
-  }
+      if (!disablingAttributeZero) {
+        location = Number(location);
+        this.bind(function () {
+          return _enable ? _this3.gl.enableVertexAttribArray(location) : _this3.gl.disableVertexAttribArray(location);
+        });
+      }
 
-  _normalizeConstantArrayValue(arrayValue) {
-    if (Array.isArray(arrayValue)) {
-      return new Float32Array(arrayValue);
+      return this;
     }
+  }, {
+    key: "getConstantBuffer",
+    value: function getConstantBuffer(elementCount, value) {
+      var constantValue = this._normalizeConstantArrayValue(value);
+
+      var byteLength = constantValue.byteLength * elementCount;
+      var length = constantValue.length * elementCount;
+      var updateNeeded = !this.buffer;
+      this.buffer = this.buffer || new _webglBuffer.default(this.gl, byteLength);
+      updateNeeded = updateNeeded || this.buffer.reallocate(byteLength);
+      updateNeeded = updateNeeded || !this._compareConstantArrayValues(constantValue, this.bufferValue);
+
+      if (updateNeeded) {
+        var typedArray = (0, _api.getScratchArray)(value.constructor, length);
+        (0, _api.fillArray)({
+          target: typedArray,
+          source: constantValue,
+          start: 0,
+          count: length
+        });
+        this.buffer.subData(typedArray);
+        this.bufferValue = value;
+      }
 
-    return arrayValue;
-  }
-
-  _compareConstantArrayValues(v1, v2) {
-    if (!v1 || !v2 || v1.length !== v2.length || v1.constructor !== v2.constructor) {
-      return false;
+      return this.buffer;
+    }
+  }, {
+    key: "initialize",
+    value: function initialize(props) {
+      return this.setProps(props);
     }
+  }, {
+    key: "setProps",
+    value: function setProps(props) {
+      return this;
+    }
+  }, {
+    key: "_normalizeConstantArrayValue",
+    value: function _normalizeConstantArrayValue(arrayValue) {
+      if (Array.isArray(arrayValue)) {
+        return new Float32Array(arrayValue);
+      }
 
-    for (let i = 0; i < v1.length; ++i) {
-      if (v1[i] !== v2[i]) {
+      return arrayValue;
+    }
+  }, {
+    key: "_compareConstantArrayValues",
+    value: function _compareConstantArrayValues(v1, v2) {
+      if (!v1 || !v2 || v1.length !== v2.length || v1.constructor !== v2.constructor) {
         return false;
       }
-    }
-
-    return true;
-  }
 
-  static _setConstantFloatArray(gl, location, array) {
-    switch (array.length) {
-      case 1:
-        gl.vertexAttrib1fv(location, array);
-        break;
-
-      case 2:
-        gl.vertexAttrib2fv(location, array);
-        break;
-
-      case 3:
-        gl.vertexAttrib3fv(location, array);
-        break;
-
-      case 4:
-        gl.vertexAttrib4fv(location, array);
-        break;
+      for (var i = 0; i < v1.length; ++i) {
+        if (v1[i] !== v2[i]) {
+          return false;
+        }
+      }
 
-      default:
-        (0, _utils.assert)(false);
+      return true;
     }
-  }
+  }, {
+    key: "_createHandle",
+    value: function _createHandle() {
+      return this.gl2.createVertexArray();
+    }
+  }, {
+    key: "_deleteHandle",
+    value: function _deleteHandle() {
+      this.gl2.deleteVertexArray(this.handle);
+      return [this.elements];
+    }
+  }, {
+    key: "_bindHandle",
+    value: function _bindHandle(handle) {
+      this.gl2.bindVertexArray(handle);
+    }
+  }, {
+    key: "_getParameter",
+    value: function _getParameter(pname, _ref) {
+      var _this4 = this;
+
+      var location = _ref.location;
+      (0, _api.assert)(Number.isFinite(location));
+      return this.bind(function () {
+        switch (pname) {
+          case _constants.default.VERTEX_ATTRIB_ARRAY_POINTER:
+            return _this4.gl.getVertexAttribOffset(location, pname);
+
+          default:
+            return _this4.gl.getVertexAttrib(location, pname);
+        }
+      });
+    }
+  }], [{
+    key: "isSupported",
+    value: function isSupported(gl, options) {
+      if (options !== null && options !== void 0 && options.constantAttributeZero) {
+        return (0, _webglChecks.isWebGL2)(gl) || (0, _env.getBrowser)() === 'Chrome';
+      }
 
-  static _setConstantIntArray(gl, location, array) {
-    (0, _utils.assert)((0, _gltools.isWebGL2)(gl));
-    gl.vertexAttribI4iv(location, array);
-  }
+      return true;
+    }
+  }, {
+    key: "getDefaultArray",
+    value: function getDefaultArray(gl) {
+      var webglDevice = _webglDevice.default.fromContext(gl);
+
+      webglDevice.defaultVertexArray = webglDevice.defaultVertexArray || new VertexArrayObject(gl, {
+        handle: null,
+        isDefaultArray: true
+      });
+      return webglDevice.defaultVertexArray;
+    }
+  }, {
+    key: "getMaxAttributes",
+    value: function getMaxAttributes(gl) {
+      VertexArrayObject.MAX_ATTRIBUTES = VertexArrayObject.MAX_ATTRIBUTES || gl.getParameter(gl.MAX_VERTEX_ATTRIBS);
+      return VertexArrayObject.MAX_ATTRIBUTES;
+    }
+  }, {
+    key: "setConstant",
+    value: function setConstant(gl, location, array) {
+      switch (array.constructor) {
+        case Float32Array:
+          VertexArrayObject._setConstantFloatArray(gl, location, array);
 
-  static _setConstantUintArray(gl, location, array) {
-    (0, _utils.assert)((0, _gltools.isWebGL2)(gl));
-    gl.vertexAttribI4uiv(location, array);
-  }
+          break;
 
-  _createHandle() {
-    return this.gl2.createVertexArray();
-  }
+        case Int32Array:
+          VertexArrayObject._setConstantIntArray((0, _webglChecks.assertWebGL2Context)(gl), location, array);
 
-  _deleteHandle() {
-    this.gl2.deleteVertexArray(this.handle);
-    return [this.elements];
-  }
+          break;
 
-  _bindHandle(handle) {
-    this.gl2.bindVertexArray(handle);
-  }
+        case Uint32Array:
+          VertexArrayObject._setConstantUintArray((0, _webglChecks.assertWebGL2Context)(gl), location, array);
 
-  _getParameter(pname, {
-    location
-  }) {
-    (0, _utils.assert)(Number.isFinite(location));
-    return this.bind(() => {
-      switch (pname) {
-        case _constants.default.VERTEX_ATTRIB_ARRAY_POINTER:
-          return this.gl.getVertexAttribOffset(location, pname);
+          break;
 
         default:
-          return this.gl.getVertexAttrib(location, pname);
+          (0, _api.assert)(false);
       }
-    });
-  }
+    }
+  }, {
+    key: "_setConstantFloatArray",
+    value: function _setConstantFloatArray(gl, location, array) {
+      switch (array.length) {
+        case 1:
+          gl.vertexAttrib1fv(location, array);
+          break;
+
+        case 2:
+          gl.vertexAttrib2fv(location, array);
+          break;
+
+        case 3:
+          gl.vertexAttrib3fv(location, array);
+          break;
+
+        case 4:
+          gl.vertexAttrib4fv(location, array);
+          break;
 
-}
+        default:
+          (0, _api.assert)(false);
+      }
+    }
+  }, {
+    key: "_setConstantIntArray",
+    value: function _setConstantIntArray(gl, location, array) {
+      (0, _api.assert)((0, _webglChecks.isWebGL2)(gl));
+      gl.vertexAttribI4iv(location, array);
+    }
+  }, {
+    key: "_setConstantUintArray",
+    value: function _setConstantUintArray(gl, location, array) {
+      (0, _api.assert)((0, _webglChecks.isWebGL2)(gl));
+      gl.vertexAttribI4uiv(location, array);
+    }
+  }]);
+  return VertexArrayObject;
+}(_webglResource.default);
 
 exports.default = VertexArrayObject;
 (0, _defineProperty2.default)(VertexArrayObject, "MAX_ATTRIBUTES", void 0);

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

@@ -1 +1 @@
-{"version":3,"sources":["../../../src/classes/vertex-array-object.ts"],"names":["ERR_ELEMENTS","VertexArrayObject","WebGLResource","isSupported","gl","options","constantAttributeZero","getDefaultArray","lumaContextData","defaultVertexArray","handle","isDefaultArray","getMaxAttributes","MAX_ATTRIBUTES","getParameter","MAX_VERTEX_ATTRIBS","setConstant","location","array","constructor","Float32Array","_setConstantFloatArray","Int32Array","_setConstantIntArray","Uint32Array","_setConstantUintArray","opts","id","program","buffer","bufferValue","Object","seal","delete","setElementBuffer","elementBuffer","target","GL","ELEMENT_ARRAY_BUFFER","bind","bindBuffer","setBuffer","accessor","size","type","stride","offset","normalized","integer","divisor","gl2","Number","ARRAY_BUFFER","vertexAttribIPointer","vertexAttribPointer","enableVertexAttribArray","vertexAttribDivisor","enable","disablingAttributeZero","disableVertexAttribArray","getConstantBuffer","elementCount","value","constantValue","_normalizeConstantArrayValue","byteLength","length","updateNeeded","Buffer","reallocate","_compareConstantArrayValues","typedArray","source","start","count","subData","initialize","props","setProps","arrayValue","Array","isArray","v1","v2","i","vertexAttrib1fv","vertexAttrib2fv","vertexAttrib3fv","vertexAttrib4fv","vertexAttribI4iv","vertexAttribI4uiv","_createHandle","createVertexArray","_deleteHandle","deleteVertexArray","elements","_bindHandle","bindVertexArray","_getParameter","pname","isFinite","VERTEX_ATTRIB_ARRAY_POINTER","getVertexAttribOffset","getVertexAttrib"],"mappings":"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","sourcesContent":["import GL from '@luma.gl/constants';\nimport {assertWebGL2Context, isWebGL2} from '@luma.gl/gltools';\nimport {getBrowser} from 'probe.gl';\nimport Program from './program';\nimport WebGLResource, {ResourceProps} from './webgl-resource';\nimport Buffer from './webgl-buffer';\nimport {getScratchArray, fillArray} from '../utils/array-utils-flat';\nimport {assert} from '../utils';\nimport {getLumaContextData} from '../context/luma-context-data';\n\nconst ERR_ELEMENTS = 'elements must be GL.ELEMENT_ARRAY_BUFFER';\n\n/**\n * VertexArrayObject properties\n * @param constantAttributeZero Attribute 0 can not be disable on most desktop OpenGL based browsers\n * and on iOS Safari browser.\n */\nexport type VertexArrayObjectProps = ResourceProps & {\n  constantAttributeZero?: boolean;\n  program?: Program;\n  isDefaultArray?: boolean;\n};\n\nexport default class VertexArrayObject extends WebGLResource<VertexArrayObjectProps> {\n  private static MAX_ATTRIBUTES: number;\n\n  static isSupported(gl: WebGLRenderingContext, options?: VertexArrayObjectProps): boolean {\n    if (options?.constantAttributeZero) {\n      return isWebGL2(gl) || getBrowser() === 'Chrome';\n    }\n\n    // Whether additional objects can be created\n    return true;\n  }\n\n  /**\n   * Returns the global (null) vertex array object. Exists even when no extension available.\n   * @todo (Tarek): VAOs are now polyfilled. Deprecate this in 9.0\n   */\n  static getDefaultArray(gl: WebGLRenderingContext): VertexArrayObject {\n    const lumaContextData = getLumaContextData(gl);\n    lumaContextData.defaultVertexArray = lumaContextData.defaultVertexArray || \n      new VertexArrayObject(gl, {handle: null, isDefaultArray: true});\n    return lumaContextData.defaultVertexArray;\n  }\n\n  /** Get maximum number of attributes in a vertex array */\n  static getMaxAttributes(gl: WebGLRenderingContext): number {\n    // TODO - should be cached per context\n    // @ts-ignore\n    VertexArrayObject.MAX_ATTRIBUTES =\n      // @ts-ignore\n      VertexArrayObject.MAX_ATTRIBUTES || gl.getParameter(gl.MAX_VERTEX_ATTRIBS);\n    // @ts-ignore\n    return VertexArrayObject.MAX_ATTRIBUTES;\n  }\n\n  /**\n   * Set an attribute to a constant value\n   * @param gl \n   * @param location \n   * @param array \n   * \n   * @note Constants are stored globally on the WebGL context, not the VAO\n   * so they need to be updated before every render\n   * @todo - use known type (in configuration or passed in) to allow non-typed arrays?\n   * @todo - remember/cache values to avoid setting them unnecessarily?\n   */\n  static setConstant(gl: WebGLRenderingContext, location: any, array: any): void {\n    switch (array.constructor) {\n      case Float32Array:\n        VertexArrayObject._setConstantFloatArray(gl, location, array);\n        break;\n      case Int32Array:\n        VertexArrayObject._setConstantIntArray(assertWebGL2Context(gl), location, array);\n        break;\n      case Uint32Array:\n        VertexArrayObject._setConstantUintArray(assertWebGL2Context(gl), location, array);\n        break;\n      default:\n        assert(false);\n    }\n  }\n\n  private buffer: Buffer | null = null;\n  private bufferValue = null;\n  private isDefaultArray: boolean = false;\n\n  // Create a VertexArray\n  constructor(gl: WebGLRenderingContext, opts?: VertexArrayObjectProps) {\n    // Use program's id if program but no id is supplied\n    super(gl, {...opts, id: opts?.id || (opts?.program && opts?.program.id)}, {} as any);\n\n    this.buffer = null;\n    this.bufferValue = null;\n    this.isDefaultArray = opts?.isDefaultArray || false;\n\n    Object.seal(this);\n  }\n\n  delete(): this {\n    super.delete();\n    if (this.buffer) {\n      this.buffer.delete();\n    }\n    return this;\n  }\n\n  get MAX_ATTRIBUTES(): number {\n    return VertexArrayObject.getMaxAttributes(this.gl);\n  }\n\n  // Set (bind) an elements buffer, for indexed rendering.\n  // Must be a Buffer bound to GL.ELEMENT_ARRAY_BUFFER. Constants not supported\n  setElementBuffer(elementBuffer = null, opts = {}) {\n    assert(!elementBuffer || elementBuffer.target === GL.ELEMENT_ARRAY_BUFFER, ERR_ELEMENTS);\n\n    // The GL.ELEMENT_ARRAY_BUFFER_BINDING is stored on the VertexArrayObject...\n    this.bind(() => {\n      this.gl.bindBuffer(GL.ELEMENT_ARRAY_BUFFER, elementBuffer ? elementBuffer.handle : null);\n    });\n\n    return this;\n  }\n\n  /** Set a location in vertex attributes array to a buffer, enables the location, sets divisor */\n  setBuffer(location, buffer, accessor): this {\n    // Check target\n    if (buffer.target === GL.ELEMENT_ARRAY_BUFFER) {\n      return this.setElementBuffer(buffer, accessor);\n    }\n\n    const {size, type, stride, offset, normalized, integer, divisor} = accessor;\n\n    const {gl, gl2} = this;\n    location = Number(location);\n\n    this.bind(() => {\n      // A non-zero buffer object must be bound to the GL_ARRAY_BUFFER target\n      gl.bindBuffer(gl.ARRAY_BUFFER, buffer.handle);\n\n      // WebGL2 supports *integer* data formats, i.e. GPU will see integer values\n      if (integer) {\n        assert(isWebGL2(gl));\n        gl2.vertexAttribIPointer(location, size, type, stride, offset);\n      } else {\n        // Attaches ARRAY_BUFFER with specified buffer format to location\n        gl.vertexAttribPointer(location, size, type, normalized, stride, offset);\n      }\n      gl.enableVertexAttribArray(location);\n      gl2.vertexAttribDivisor(location, divisor || 0);\n\n      // NOTE We don't unbind buffer here, typically another buffer will be bound just after\n    });\n\n    return this;\n  }\n\n  /**\n   * Enabling an attribute location makes it reference the currently bound buffer\n   *  Disabling an attribute location makes it reference the global constant value\n   * TODO - handle single values for size 1 attributes?\n   * TODO - convert classic arrays based on known type?\n   */ \n  enable(location, enable = true): this {\n    // Attribute 0 cannot be disabled in most desktop OpenGL based browsers\n    const disablingAttributeZero =\n      !enable &&\n      location === 0 &&\n      !VertexArrayObject.isSupported(this.gl, {constantAttributeZero: true});\n\n    if (!disablingAttributeZero) {\n      location = Number(location);\n      this.bind(() =>\n        enable\n          ? this.gl.enableVertexAttribArray(location)\n          : this.gl.disableVertexAttribArray(location)\n      );\n    }\n    return this;\n  }\n\n  /**\n   * Provide a means to create a buffer that is equivalent to a constant.\n   * NOTE: Desktop OpenGL cannot disable attribute 0.\n   * https://stackoverflow.com/questions/20305231/webgl-warning-attribute-0-is-disabled-\n   * this-has-significant-performance-penalty\n   */ \n  getConstantBuffer(elementCount: number, value): Buffer {\n    // Create buffer only when needed, and reuse it (avoids inflating buffer creation statistics)\n\n    const constantValue = this._normalizeConstantArrayValue(value);\n\n    const byteLength = constantValue.byteLength * elementCount;\n    const length = constantValue.length * elementCount;\n\n    let updateNeeded = !this.buffer;\n\n    this.buffer = this.buffer || new Buffer(this.gl, byteLength);\n    updateNeeded = updateNeeded || this.buffer.reallocate(byteLength);\n\n    // Reallocate and update contents if needed\n    updateNeeded =\n      updateNeeded || !this._compareConstantArrayValues(constantValue, this.bufferValue);\n\n    if (updateNeeded) {\n      // Create a typed array that is big enough, and fill it with the required data\n      const typedArray = getScratchArray(value.constructor, length);\n      fillArray({target: typedArray, source: constantValue, start: 0, count: length});\n      this.buffer.subData(typedArray);\n      this.bufferValue = value;\n    }\n\n    return this.buffer;\n  }\n\n  // DEPRECATED\n\n  /** @deprecated this function has no effect */\n  initialize(props?: VertexArrayObjectProps): this {\n    return this.setProps(props);\n  }\n\n  /** @deprecated this function is not implemented */\n  setProps(props: VertexArrayObjectProps): this {\n    // TODO: decide which props should be supported\n    return this;\n  }  \n\n  // PRIVATE\n\n  // TODO - convert Arrays based on known type? (read type from accessor, don't assume Float32Array)\n  // TODO - handle single values for size 1 attributes?\n  _normalizeConstantArrayValue(arrayValue) {\n    if (Array.isArray(arrayValue)) {\n      return new Float32Array(arrayValue);\n    }\n    return arrayValue;\n  }\n\n  _compareConstantArrayValues(v1, v2): boolean {\n    if (!v1 || !v2 || v1.length !== v2.length || v1.constructor !== v2.constructor) {\n      return false;\n    }\n    for (let i = 0; i < v1.length; ++i) {\n      if (v1[i] !== v2[i]) {\n        return false;\n      }\n    }\n    return true;\n  }\n\n  static _setConstantFloatArray(gl: WebGLRenderingContext, location, array): void {\n    switch (array.length) {\n      case 1:\n        gl.vertexAttrib1fv(location, array);\n        break;\n      case 2:\n        gl.vertexAttrib2fv(location, array);\n        break;\n      case 3:\n        gl.vertexAttrib3fv(location, array);\n        break;\n      case 4:\n        gl.vertexAttrib4fv(location, array);\n        break;\n      default:\n        assert(false);\n    }\n  }\n\n  static _setConstantIntArray(gl: WebGL2RenderingContext, location, array) {\n    assert(isWebGL2(gl));\n    gl.vertexAttribI4iv(location, array);\n    // switch (array.length) {\n    //   case 1:\n    //     gl.vertexAttribI1iv(location, array);\n    //     break;\n    //   case 2:\n    //     gl.vertexAttribI2iv(location, array);\n    //     break;\n    //   case 3:\n    //     gl.vertexAttribI3iv(location, array);\n    //     break;\n    //   case 4:\n    //     break;\n    //   default:\n    //     assert(false);\n    // }\n  }\n\n  static _setConstantUintArray(gl: WebGL2RenderingContext, location, array) {\n    assert(isWebGL2(gl));\n    gl.vertexAttribI4uiv(location, array);\n    // switch (array.length) {\n    //   case 1:\n    //     gl.vertexAttribI1uiv(location, array);\n    //     break;\n    //   case 2:\n    //     gl.vertexAttribI2uiv(location, array);\n    //     break;\n    //   case 3:\n    //     gl.vertexAttribI3uiv(location, array);\n    //     break;\n    //   case 4:\n    //     gl.vertexAttribI4uiv(location, array);\n    //     break;\n    //   default:\n    //     assert(false);\n    // }\n  }\n\n  // RESOURCE IMPLEMENTATION\n\n  _createHandle() {\n    return this.gl2.createVertexArray();\n  }\n\n  _deleteHandle(): void {\n    this.gl2.deleteVertexArray(this.handle);\n    // @ts-ignore\n    return [this.elements];\n    // return [this.elements, ...this.buffers];\n  }\n\n  _bindHandle(handle): void {\n    this.gl2.bindVertexArray(handle);\n  }\n\n  // Generic getter for information about a vertex attribute at a given position\n  _getParameter(pname: number, {location}) {\n    assert(Number.isFinite(location));\n    return this.bind(() => {\n      switch (pname) {\n        case GL.VERTEX_ATTRIB_ARRAY_POINTER:\n          return this.gl.getVertexAttribOffset(location, pname);\n        default:\n          return this.gl.getVertexAttrib(location, pname);\n      }\n    });\n  }\n}\n"],"file":"vertex-array-object.js"}
+{"version":3,"sources":["../../../src/classes/vertex-array-object.ts"],"names":["ERR_ELEMENTS","VertexArrayObject","gl","props","WebGLDevice","attach","id","program","buffer","bufferValue","isDefaultArray","Object","seal","delete","getMaxAttributes","elementBuffer","opts","target","GL","ELEMENT_ARRAY_BUFFER","bind","bindBuffer","handle","location","accessor","setElementBuffer","size","type","stride","offset","normalized","integer","divisor","gl2","Number","ARRAY_BUFFER","vertexAttribIPointer","vertexAttribPointer","enableVertexAttribArray","vertexAttribDivisor","enable","disablingAttributeZero","isSupported","constantAttributeZero","disableVertexAttribArray","elementCount","value","constantValue","_normalizeConstantArrayValue","byteLength","length","updateNeeded","Buffer","reallocate","_compareConstantArrayValues","typedArray","constructor","source","start","count","subData","setProps","arrayValue","Array","isArray","Float32Array","v1","v2","i","createVertexArray","deleteVertexArray","elements","bindVertexArray","pname","isFinite","VERTEX_ATTRIB_ARRAY_POINTER","getVertexAttribOffset","getVertexAttrib","options","webglDevice","fromContext","defaultVertexArray","MAX_ATTRIBUTES","getParameter","MAX_VERTEX_ATTRIBS","array","_setConstantFloatArray","Int32Array","_setConstantIntArray","Uint32Array","_setConstantUintArray","vertexAttrib1fv","vertexAttrib2fv","vertexAttrib3fv","vertexAttrib4fv","vertexAttribI4iv","vertexAttribI4uiv","WebGLResource"],"mappings":"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","sourcesContent":["import type {NumberArray} from '@luma.gl/api';\nimport {assert, getScratchArray, fillArray} from '@luma.gl/api';\nimport GL from '@luma.gl/constants';\nimport {getBrowser} from '@probe.gl/env';\nimport WebGLDevice from '../adapter/webgl-device';\nimport {assertWebGL2Context, isWebGL2} from '../context/context/webgl-checks';\nimport Program from './program';\nimport WebGLResource, {ResourceProps} from './webgl-resource';\nimport Buffer from './webgl-buffer';\n\nconst ERR_ELEMENTS = 'elements must be GL.ELEMENT_ARRAY_BUFFER';\n\n/**\n * VertexArrayObject properties\n * @param constantAttributeZero Attribute 0 can not be disable on most desktop OpenGL based browsers\n * and on iOS Safari browser.\n */\nexport type VertexArrayObjectProps = ResourceProps & {\n  constantAttributeZero?: boolean;\n  program?: Program;\n  isDefaultArray?: boolean;\n};\n\nexport default class VertexArrayObject extends WebGLResource<VertexArrayObjectProps> {\n  private static MAX_ATTRIBUTES: number;\n\n  static isSupported(gl: WebGLRenderingContext | WebGL2RenderingContext, options?: VertexArrayObjectProps): boolean {\n    if (options?.constantAttributeZero) {\n      return isWebGL2(gl) || getBrowser() === 'Chrome';\n    }\n\n    // Whether additional objects can be created\n    return true;\n  }\n\n  /**\n   * Returns the global (null) vertex array object. Exists even when no extension available.\n   * @todo (Tarek): VAOs are now polyfilled. Deprecate this in 9.0\n   */\n  static getDefaultArray(gl: WebGLRenderingContext): VertexArrayObject {\n    const webglDevice = WebGLDevice.fromContext(gl);\n    webglDevice.defaultVertexArray = webglDevice.defaultVertexArray || \n      new VertexArrayObject(gl, {handle: null, isDefaultArray: true});\n    return webglDevice.defaultVertexArray;\n  }\n\n  /** Get maximum number of attributes in a vertex array */\n  static getMaxAttributes(gl: WebGLRenderingContext): number {\n    // TODO - should be cached per context\n    VertexArrayObject.MAX_ATTRIBUTES =\n      VertexArrayObject.MAX_ATTRIBUTES || gl.getParameter(gl.MAX_VERTEX_ATTRIBS);\n    return VertexArrayObject.MAX_ATTRIBUTES;\n  }\n\n  /**\n   * Set an attribute to a constant value\n   * @param gl \n   * @param location \n   * @param array \n   * \n   * @note Constants are stored globally on the WebGL context, not the VAO\n   * so they need to be updated before every render\n   * @todo - use known type (in configuration or passed in) to allow non-typed arrays?\n   * @todo - remember/cache values to avoid setting them unnecessarily?\n   */\n  static setConstant(gl: WebGLRenderingContext, location: any, array: any): void {\n    switch (array.constructor) {\n      case Float32Array:\n        VertexArrayObject._setConstantFloatArray(gl, location, array);\n        break;\n      case Int32Array:\n        VertexArrayObject._setConstantIntArray(assertWebGL2Context(gl), location, array);\n        break;\n      case Uint32Array:\n        VertexArrayObject._setConstantUintArray(assertWebGL2Context(gl), location, array);\n        break;\n      default:\n        assert(false);\n    }\n  }\n\n  private buffer: Buffer | null = null;\n  private bufferValue = null;\n  private isDefaultArray: boolean = false;\n\n  // Create a VertexArray\n  constructor(gl: WebGLRenderingContext, props?: VertexArrayObjectProps) {\n    // Use program's id if program but no id is supplied\n    super(WebGLDevice.attach(gl), {...props, id: props?.id || (props?.program && props?.program.id)}, {} as any);\n\n    this.buffer = null;\n    this.bufferValue = null;\n    this.isDefaultArray = props?.isDefaultArray || false;\n\n    Object.seal(this);\n  }\n\n  delete(): this {\n    super.delete();\n    if (this.buffer) {\n      this.buffer.delete();\n    }\n    return this;\n  }\n\n  get MAX_ATTRIBUTES(): number {\n    return VertexArrayObject.getMaxAttributes(this.gl);\n  }\n\n  // Set (bind) an elements buffer, for indexed rendering.\n  // Must be a Buffer bound to GL.ELEMENT_ARRAY_BUFFER. Constants not supported\n  setElementBuffer(elementBuffer: Buffer = null, opts = {}) {\n    assert(!elementBuffer || elementBuffer.target === GL.ELEMENT_ARRAY_BUFFER, ERR_ELEMENTS);\n\n    // The GL.ELEMENT_ARRAY_BUFFER_BINDING is stored on the VertexArrayObject...\n    this.bind(() => {\n      this.gl.bindBuffer(GL.ELEMENT_ARRAY_BUFFER, elementBuffer ? elementBuffer.handle : null);\n    });\n\n    return this;\n  }\n\n  /** Set a location in vertex attributes array to a buffer, enables the location, sets divisor */\n  setBuffer(location: number, buffer: Buffer, accessor: any): this {\n    // Check target\n    if (buffer.target === GL.ELEMENT_ARRAY_BUFFER) {\n      return this.setElementBuffer(buffer, accessor);\n    }\n\n    const {size, type, stride, offset, normalized, integer, divisor} = accessor;\n\n    const {gl, gl2} = this;\n    location = Number(location);\n\n    this.bind(() => {\n      // A non-zero buffer object must be bound to the GL_ARRAY_BUFFER target\n      gl.bindBuffer(gl.ARRAY_BUFFER, buffer.handle);\n\n      // WebGL2 supports *integer* data formats, i.e. GPU will see integer values\n      if (integer) {\n        assert(isWebGL2(gl));\n        gl2.vertexAttribIPointer(location, size, type, stride, offset);\n      } else {\n        // Attaches ARRAY_BUFFER with specified buffer format to location\n        gl.vertexAttribPointer(location, size, type, normalized, stride, offset);\n      }\n      gl.enableVertexAttribArray(location);\n      gl2.vertexAttribDivisor(location, divisor || 0);\n\n      // NOTE We don't unbind buffer here, typically another buffer will be bound just after\n    });\n\n    return this;\n  }\n\n  /**\n   * Enabling an attribute location makes it reference the currently bound buffer\n   *  Disabling an attribute location makes it reference the global constant value\n   * TODO - handle single values for size 1 attributes?\n   * TODO - convert classic arrays based on known type?\n   */ \n  enable(location: number, enable = true): this {\n    // Attribute 0 cannot be disabled in most desktop OpenGL based browsers\n    const disablingAttributeZero =\n      !enable &&\n      location === 0 &&\n      !VertexArrayObject.isSupported(this.gl, {constantAttributeZero: true});\n\n    if (!disablingAttributeZero) {\n      location = Number(location);\n      this.bind(() =>\n        enable\n          ? this.gl.enableVertexAttribArray(location)\n          : this.gl.disableVertexAttribArray(location)\n      );\n    }\n    return this;\n  }\n\n  /**\n   * Provide a means to create a buffer that is equivalent to a constant.\n   * NOTE: Desktop OpenGL cannot disable attribute 0.\n   * https://stackoverflow.com/questions/20305231/webgl-warning-attribute-0-is-disabled-\n   * this-has-significant-performance-penalty\n   */ \n  getConstantBuffer(elementCount: number, value): Buffer {\n    // Create buffer only when needed, and reuse it (avoids inflating buffer creation statistics)\n\n    const constantValue = this._normalizeConstantArrayValue(value);\n\n    const byteLength = constantValue.byteLength * elementCount;\n    const length = constantValue.length * elementCount;\n\n    let updateNeeded = !this.buffer;\n\n    this.buffer = this.buffer || new Buffer(this.gl, byteLength);\n    updateNeeded = updateNeeded || this.buffer.reallocate(byteLength);\n\n    // Reallocate and update contents if needed\n    updateNeeded =\n      updateNeeded || !this._compareConstantArrayValues(constantValue, this.bufferValue);\n\n    if (updateNeeded) {\n      // Create a typed array that is big enough, and fill it with the required data\n      const typedArray = getScratchArray(value.constructor, length);\n      fillArray({target: typedArray, source: constantValue, start: 0, count: length});\n      this.buffer.subData(typedArray);\n      this.bufferValue = value;\n    }\n\n    return this.buffer;\n  }\n\n  // DEPRECATED\n\n  /** @deprecated this function has no effect */\n  initialize(props?: VertexArrayObjectProps): this {\n    return this.setProps(props);\n  }\n\n  /** @deprecated this function is not implemented */\n  setProps(props: VertexArrayObjectProps): this {\n    // TODO: decide which props should be supported\n    return this;\n  }  \n\n  // PRIVATE\n\n  // TODO - convert Arrays based on known type? (read type from accessor, don't assume Float32Array)\n  // TODO - handle single values for size 1 attributes?\n  _normalizeConstantArrayValue(arrayValue: NumberArray) {\n    if (Array.isArray(arrayValue)) {\n      return new Float32Array(arrayValue);\n    }\n    return arrayValue;\n  }\n\n  _compareConstantArrayValues(v1, v2): boolean {\n    if (!v1 || !v2 || v1.length !== v2.length || v1.constructor !== v2.constructor) {\n      return false;\n    }\n    for (let i = 0; i < v1.length; ++i) {\n      if (v1[i] !== v2[i]) {\n        return false;\n      }\n    }\n    return true;\n  }\n\n  static _setConstantFloatArray(gl: WebGLRenderingContext, location, array): void {\n    switch (array.length) {\n      case 1:\n        gl.vertexAttrib1fv(location, array);\n        break;\n      case 2:\n        gl.vertexAttrib2fv(location, array);\n        break;\n      case 3:\n        gl.vertexAttrib3fv(location, array);\n        break;\n      case 4:\n        gl.vertexAttrib4fv(location, array);\n        break;\n      default:\n        assert(false);\n    }\n  }\n\n  static _setConstantIntArray(gl: WebGL2RenderingContext, location, array) {\n    assert(isWebGL2(gl));\n    gl.vertexAttribI4iv(location, array);\n    // switch (array.length) {\n    //   case 1:\n    //     gl.vertexAttribI1iv(location, array);\n    //     break;\n    //   case 2:\n    //     gl.vertexAttribI2iv(location, array);\n    //     break;\n    //   case 3:\n    //     gl.vertexAttribI3iv(location, array);\n    //     break;\n    //   case 4:\n    //     break;\n    //   default:\n    //     assert(false);\n    // }\n  }\n\n  static _setConstantUintArray(gl: WebGL2RenderingContext, location, array) {\n    assert(isWebGL2(gl));\n    gl.vertexAttribI4uiv(location, array);\n    // switch (array.length) {\n    //   case 1:\n    //     gl.vertexAttribI1uiv(location, array);\n    //     break;\n    //   case 2:\n    //     gl.vertexAttribI2uiv(location, array);\n    //     break;\n    //   case 3:\n    //     gl.vertexAttribI3uiv(location, array);\n    //     break;\n    //   case 4:\n    //     gl.vertexAttribI4uiv(location, array);\n    //     break;\n    //   default:\n    //     assert(false);\n    // }\n  }\n\n  // RESOURCE IMPLEMENTATION\n\n  _createHandle() {\n    return this.gl2.createVertexArray();\n  }\n\n  _deleteHandle(): void {\n    this.gl2.deleteVertexArray(this.handle);\n    // @ts-expect-error\n    return [this.elements];\n    // return [this.elements, ...this.buffers];\n  }\n\n  _bindHandle(handle): void {\n    this.gl2.bindVertexArray(handle);\n  }\n\n  // Generic getter for information about a vertex attribute at a given position\n  _getParameter(pname: number, {location}) {\n    assert(Number.isFinite(location));\n    return this.bind(() => {\n      switch (pname) {\n        case GL.VERTEX_ATTRIB_ARRAY_POINTER:\n          return this.gl.getVertexAttribOffset(location, pname);\n        default:\n          return this.gl.getVertexAttrib(location, pname);\n      }\n    });\n  }\n}\n"],"file":"vertex-array-object.js"}