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

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

@@ -7,374 +7,272 @@ 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 _assertThisInitialized2 = _interopRequireDefault(require("@babel/runtime/helpers/assertThisInitialized"));
+var _constants = _interopRequireDefault(require("@luma.gl/constants"));
 
-var _get2 = _interopRequireDefault(require("@babel/runtime/helpers/get"));
+var _gltools = require("@luma.gl/gltools");
 
-var _createClass2 = _interopRequireDefault(require("@babel/runtime/helpers/createClass"));
+var _probe = require("probe.gl");
 
-var _inherits2 = _interopRequireDefault(require("@babel/runtime/helpers/inherits"));
+var _webglResource = _interopRequireDefault(require("./webgl-resource"));
 
-var _possibleConstructorReturn2 = _interopRequireDefault(require("@babel/runtime/helpers/possibleConstructorReturn"));
+var _webglBuffer = _interopRequireDefault(require("./webgl-buffer"));
 
-var _getPrototypeOf2 = _interopRequireDefault(require("@babel/runtime/helpers/getPrototypeOf"));
+var _arrayUtilsFlat = require("../utils/array-utils-flat");
 
-var _resource = _interopRequireDefault(require("./resource"));
+var _utils = require("../utils");
 
-var _buffer = _interopRequireDefault(require("./buffer"));
+var _lumaContextData = require("../context/luma-context-data");
 
-var _gltools = require("@luma.gl/gltools");
+const ERR_ELEMENTS = 'elements must be GL.ELEMENT_ARRAY_BUFFER';
 
-var _arrayUtilsFlat = require("../utils/array-utils-flat");
-
-var _assert = require("../utils/assert");
+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 _probe = require("probe.gl");
+    return true;
+  }
 
-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); }; }
+  static getDefaultArray(gl) {
+    const lumaContextData = (0, _lumaContextData.getLumaContextData)(gl);
+    lumaContextData.defaultVertexArray = lumaContextData.defaultVertexArray || new VertexArrayObject(gl, {
+      handle: null,
+      isDefaultArray: true
+    });
+    return lumaContextData.defaultVertexArray;
+  }
 
-function _isNativeReflectConstruct() { if (typeof Reflect === "undefined" || !Reflect.construct) return false; if (Reflect.construct.sham) return false; if (typeof Proxy === "function") return true; try { Date.prototype.toString.call(Reflect.construct(Date, [], function () {})); return true; } catch (e) { return false; } }
+  static getMaxAttributes(gl) {
+    VertexArrayObject.MAX_ATTRIBUTES = VertexArrayObject.MAX_ATTRIBUTES || gl.getParameter(gl.MAX_VERTEX_ATTRIBS);
+    return VertexArrayObject.MAX_ATTRIBUTES;
+  }
 
-var ERR_ELEMENTS = 'elements must be GL.ELEMENT_ARRAY_BUFFER';
+  static setConstant(gl, location, array) {
+    switch (array.constructor) {
+      case Float32Array:
+        VertexArrayObject._setConstantFloatArray(gl, location, array);
 
-var VertexArrayObject = function (_Resource) {
-  (0, _inherits2.default)(VertexArrayObject, _Resource);
+        break;
 
-  var _super = _createSuper(VertexArrayObject);
+      case Int32Array:
+        VertexArrayObject._setConstantIntArray((0, _gltools.assertWebGL2Context)(gl), location, array);
 
-  (0, _createClass2.default)(VertexArrayObject, null, [{
-    key: "isSupported",
-    value: function isSupported(gl) {
-      var options = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
+        break;
 
-      if (options.constantAttributeZero) {
-        return (0, _gltools.isWebGL2)(gl) || (0, _probe.getBrowser)() === 'Chrome';
-      }
+      case Uint32Array:
+        VertexArrayObject._setConstantUintArray((0, _gltools.assertWebGL2Context)(gl), location, array);
 
-      return true;
-    }
-  }, {
-    key: "getDefaultArray",
-    value: function getDefaultArray(gl) {
-      gl.luma = gl.luma || {};
-
-      if (!gl.luma.defaultVertexArray) {
-        gl.luma.defaultVertexArray = new VertexArrayObject(gl, {
-          handle: null,
-          isDefaultArray: true
-        });
-      }
+        break;
 
-      return gl.luma.defaultVertexArray;
+      default:
+        (0, _utils.assert)(false);
     }
-  }, {
-    key: "getMaxAttributes",
-    value: function getMaxAttributes(gl) {
-      VertexArrayObject.MAX_ATTRIBUTES = VertexArrayObject.MAX_ATTRIBUTES || gl.getParameter(34921);
-      return VertexArrayObject.MAX_ATTRIBUTES;
-    }
-  }, {
-    key: "setConstant",
-    value: function setConstant(gl, location, array) {
-      switch (array.constructor) {
-        case Float32Array:
-          VertexArrayObject._setConstantFloatArray(gl, location, array);
+  }
 
-          break;
+  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);
+  }
 
-        case Int32Array:
-          VertexArrayObject._setConstantIntArray(gl, location, array);
+  delete() {
+    super.delete();
 
-          break;
+    if (this.buffer) {
+      this.buffer.delete();
+    }
 
-        case Uint32Array:
-          VertexArrayObject._setConstantUintArray(gl, location, array);
+    return this;
+  }
 
-          break;
+  get MAX_ATTRIBUTES() {
+    return VertexArrayObject.getMaxAttributes(this.gl);
+  }
 
-        default:
-          (0, _assert.assert)(false);
-      }
-    }
-  }]);
-
-  function VertexArrayObject(gl) {
-    var _this;
-
-    var opts = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
-    (0, _classCallCheck2.default)(this, VertexArrayObject);
-    var id = opts.id || opts.program && opts.program.id;
-    _this = _super.call(this, gl, Object.assign({}, opts, {
-      id: id
-    }));
-    _this.buffer = null;
-    _this.bufferValue = null;
-    _this.isDefaultArray = opts.isDefaultArray || false;
-    _this.gl2 = gl;
-
-    _this.initialize(opts);
-
-    Object.seal((0, _assertThisInitialized2.default)(_this));
-    return _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;
   }
 
-  (0, _createClass2.default)(VertexArrayObject, [{
-    key: "delete",
-    value: function _delete() {
-      (0, _get2.default)((0, _getPrototypeOf2.default)(VertexArrayObject.prototype), "delete", this).call(this);
+  setBuffer(location, buffer, accessor) {
+    if (buffer.target === _constants.default.ELEMENT_ARRAY_BUFFER) {
+      return this.setElementBuffer(buffer, accessor);
+    }
 
-      if (this.buffer) {
-        this.buffer.delete();
+    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);
       }
 
-      return this;
-    }
-  }, {
-    key: "initialize",
-    value: function initialize() {
-      var props = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
-      return this.setProps(props);
-    }
-  }, {
-    key: "setProps",
-    value: function setProps(props) {
-      return this;
-    }
-  }, {
-    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, _assert.assert)(!elementBuffer || elementBuffer.target === 34963, ERR_ELEMENTS);
-      this.bind(function () {
-        _this2.gl.bindBuffer(34963, elementBuffer ? elementBuffer.handle : null);
-      });
-      return this;
-    }
-  }, {
-    key: "setBuffer",
-    value: function setBuffer(location, buffer, accessor) {
-      if (buffer.target === 34963) {
-        return this.setElementBuffer(buffer, accessor);
-      }
+      gl.enableVertexAttribArray(location);
+      gl2.vertexAttribDivisor(location, divisor || 0);
+    });
+    return this;
+  }
 
-      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;
+  enable(location, enable = true) {
+    const disablingAttributeZero = !enable && location === 0 && !VertexArrayObject.isSupported(this.gl, {
+      constantAttributeZero: true
+    });
+
+    if (!disablingAttributeZero) {
       location = Number(location);
-      this.bind(function () {
-        gl.bindBuffer(34962, buffer.handle);
-
-        if (integer) {
-          (0, _assert.assert)((0, _gltools.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);
-      });
-      return this;
+      this.bind(() => enable ? this.gl.enableVertexAttribArray(location) : this.gl.disableVertexAttribArray(location));
     }
-  }, {
-    key: "enable",
-    value: function enable(location) {
-      var _this3 = this;
 
-      var _enable = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : true;
+    return this;
+  }
 
-      var disablingAttributeZero = !_enable && location === 0 && !VertexArrayObject.isSupported(this.gl, {
-        constantAttributeZero: true
+  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.buffer.subData(typedArray);
+      this.bufferValue = value;
+    }
 
-      if (!disablingAttributeZero) {
-        location = Number(location);
-        this.bind(function () {
-          return _enable ? _this3.gl.enableVertexAttribArray(location) : _this3.gl.disableVertexAttribArray(location);
-        });
-      }
+    return this.buffer;
+  }
 
-      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 _buffer.default(this.gl, byteLength);
-      updateNeeded = updateNeeded || this.buffer.reallocate(byteLength);
-      updateNeeded = updateNeeded || !this._compareConstantArrayValues(constantValue, this.bufferValue);
-
-      if (updateNeeded) {
-        var typedArray = (0, _arrayUtilsFlat.getScratchArray)(value.constructor, length);
-        (0, _arrayUtilsFlat.fillArray)({
-          target: typedArray,
-          source: constantValue,
-          start: 0,
-          count: length
-        });
-        this.buffer.subData(typedArray);
-        this.bufferValue = value;
-      }
+  initialize(props) {
+    return this.setProps(props);
+  }
 
-      return this.buffer;
-    }
-  }, {
-    key: "_normalizeConstantArrayValue",
-    value: function _normalizeConstantArrayValue(arrayValue) {
-      if (Array.isArray(arrayValue)) {
-        return new Float32Array(arrayValue);
-      }
+  setProps(props) {
+    return this;
+  }
 
-      return arrayValue;
+  _normalizeConstantArrayValue(arrayValue) {
+    if (Array.isArray(arrayValue)) {
+      return new Float32Array(arrayValue);
     }
-  }, {
-    key: "_compareConstantArrayValues",
-    value: function _compareConstantArrayValues(v1, v2) {
-      if (!v1 || !v2 || v1.length !== v2.length || v1.constructor !== v2.constructor) {
-        return false;
-      }
 
-      for (var i = 0; i < v1.length; ++i) {
-        if (v1[i] !== v2[i]) {
-          return false;
-        }
-      }
+    return arrayValue;
+  }
 
-      return true;
-    }
-  }, {
-    key: "_createHandle",
-    value: function _createHandle() {
-      var gl2 = this.gl;
-      return gl2.createVertexArray();
-    }
-  }, {
-    key: "_deleteHandle",
-    value: function _deleteHandle(handle) {
-      this.gl2.deleteVertexArray(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, _assert.assert)(Number.isFinite(location));
-      return this.bind(function () {
-        switch (pname) {
-          case 34373:
-            return _this4.gl.getVertexAttribOffset(location, pname);
-
-          default:
-            return _this4.gl.getVertexAttrib(location, pname);
-        }
-      });
-    }
-  }, {
-    key: "MAX_ATTRIBUTES",
-    get: function get() {
-      return VertexArrayObject.getMaxAttributes(this.gl);
+  _compareConstantArrayValues(v1, v2) {
+    if (!v1 || !v2 || v1.length !== v2.length || v1.constructor !== v2.constructor) {
+      return 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, _assert.assert)(false);
+    for (let i = 0; i < v1.length; ++i) {
+      if (v1[i] !== v2[i]) {
+        return false;
       }
     }
-  }, {
-    key: "_setConstantIntArray",
-    value: function _setConstantIntArray(gl, location, array) {
-      (0, _assert.assert)((0, _gltools.isWebGL2)(gl));
 
-      switch (array.length) {
-        case 1:
-          gl.vertexAttribI1iv(location, array);
-          break;
+    return true;
+  }
 
-        case 2:
-          gl.vertexAttribI2iv(location, array);
-          break;
+  static _setConstantFloatArray(gl, location, array) {
+    switch (array.length) {
+      case 1:
+        gl.vertexAttrib1fv(location, array);
+        break;
 
-        case 3:
-          gl.vertexAttribI3iv(location, array);
-          break;
+      case 2:
+        gl.vertexAttrib2fv(location, array);
+        break;
 
-        case 4:
-          gl.vertexAttribI4iv(location, array);
-          break;
+      case 3:
+        gl.vertexAttrib3fv(location, array);
+        break;
 
-        default:
-          (0, _assert.assert)(false);
-      }
+      case 4:
+        gl.vertexAttrib4fv(location, array);
+        break;
+
+      default:
+        (0, _utils.assert)(false);
     }
-  }, {
-    key: "_setConstantUintArray",
-    value: function _setConstantUintArray(gl, location, array) {
-      (0, _assert.assert)((0, _gltools.isWebGL2)(gl));
+  }
 
-      switch (array.length) {
-        case 1:
-          gl.vertexAttribI1uiv(location, array);
-          break;
+  static _setConstantIntArray(gl, location, array) {
+    (0, _utils.assert)((0, _gltools.isWebGL2)(gl));
+    gl.vertexAttribI4iv(location, array);
+  }
 
-        case 2:
-          gl.vertexAttribI2uiv(location, array);
-          break;
+  static _setConstantUintArray(gl, location, array) {
+    (0, _utils.assert)((0, _gltools.isWebGL2)(gl));
+    gl.vertexAttribI4uiv(location, array);
+  }
 
-        case 3:
-          gl.vertexAttribI3uiv(location, array);
-          break;
+  _createHandle() {
+    return this.gl2.createVertexArray();
+  }
+
+  _deleteHandle() {
+    this.gl2.deleteVertexArray(this.handle);
+    return [this.elements];
+  }
+
+  _bindHandle(handle) {
+    this.gl2.bindVertexArray(handle);
+  }
 
-        case 4:
-          gl.vertexAttribI4uiv(location, array);
-          break;
+  _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);
 
         default:
-          (0, _assert.assert)(false);
+          return this.gl.getVertexAttrib(location, pname);
       }
-    }
-  }]);
-  return VertexArrayObject;
-}(_resource.default);
+    });
+  }
+
+}
 
 exports.default = VertexArrayObject;
+(0, _defineProperty2.default)(VertexArrayObject, "MAX_ATTRIBUTES", void 0);
 //# sourceMappingURL=vertex-array-object.js.map