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

package/dist/es5/classes/texture.js

@@ -5,791 +5,906 @@ var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefau
 Object.defineProperty(exports, "__esModule", {
   value: true
 });
-Object.defineProperty(exports, "TextureProps", {
-  enumerable: true,
-  get: function () {
-    return _api.TextureProps;
-  }
-});
 exports.default = void 0;
 
-var _defineProperty2 = _interopRequireDefault(require("@babel/runtime/helpers/defineProperty"));
+var _slicedToArray2 = _interopRequireDefault(require("@babel/runtime/helpers/slicedToArray"));
 
-var _constants = _interopRequireDefault(require("@luma.gl/constants"));
+var _classCallCheck2 = _interopRequireDefault(require("@babel/runtime/helpers/classCallCheck"));
 
-var _gltools = require("@luma.gl/gltools");
+var _createClass2 = _interopRequireDefault(require("@babel/runtime/helpers/createClass"));
 
-var _env = require("probe.gl/env");
+var _assertThisInitialized2 = _interopRequireDefault(require("@babel/runtime/helpers/assertThisInitialized"));
 
-var _webglUtils = require("../webgl-utils");
+var _inherits2 = _interopRequireDefault(require("@babel/runtime/helpers/inherits"));
 
-var _api = require("@luma.gl/api");
+var _possibleConstructorReturn2 = _interopRequireDefault(require("@babel/runtime/helpers/possibleConstructorReturn"));
 
-var _webglBuffer = _interopRequireDefault(require("./webgl-buffer"));
+var _getPrototypeOf2 = _interopRequireDefault(require("@babel/runtime/helpers/getPrototypeOf"));
 
-var _textureFormats = require("./texture-formats");
+var _defineProperty2 = _interopRequireDefault(require("@babel/runtime/helpers/defineProperty"));
 
-var _utils = require("../utils");
+var _api = require("@luma.gl/api");
 
-const NPOT_MIN_FILTERS = [_constants.default.LINEAR, _constants.default.NEAREST];
+var _constants = _interopRequireDefault(require("@luma.gl/constants"));
 
-const WebGLBuffer = _env.global.WebGLBuffer || function WebGLBuffer() {};
+var _webglChecks = require("../context/context/webgl-checks");
 
-class WEBGLTexture extends _api.Texture {
-  static isSupported(gl, options) {
-    const {
-      format,
-      linearFiltering
-    } = options;
-    let supported = true;
+var _withParameters = require("../context/state-tracker/with-parameters");
 
-    if (format) {
-      supported = supported && (0, _textureFormats.isFormatSupported)(gl, format);
-      supported = supported && (!linearFiltering || (0, _textureFormats.isLinearFilteringSupported)(gl, format));
-    }
+var _constantsToKeys = require("../webgl-utils/constants-to-keys");
 
-    return supported;
-  }
+var _webglDevice = _interopRequireDefault(require("../device/webgl-device"));
 
-  constructor(gl, props) {
-    super(gl, props);
-    (0, _defineProperty2.default)(this, "MAX_ATTRIBUTES", void 0);
-    (0, _defineProperty2.default)(this, "gl", void 0);
-    (0, _defineProperty2.default)(this, "gl2", void 0);
-    (0, _defineProperty2.default)(this, "handle", void 0);
-    (0, _defineProperty2.default)(this, "data", void 0);
-    (0, _defineProperty2.default)(this, "width", void 0);
-    (0, _defineProperty2.default)(this, "height", void 0);
-    (0, _defineProperty2.default)(this, "depth", void 0);
-    (0, _defineProperty2.default)(this, "format", undefined);
-    (0, _defineProperty2.default)(this, "type", undefined);
-    (0, _defineProperty2.default)(this, "dataFormat", undefined);
-    (0, _defineProperty2.default)(this, "border", undefined);
-    (0, _defineProperty2.default)(this, "mipmaps", undefined);
-    (0, _defineProperty2.default)(this, "target", void 0);
-    (0, _defineProperty2.default)(this, "textureUnit", undefined);
-    (0, _defineProperty2.default)(this, "loaded", false);
-    (0, _defineProperty2.default)(this, "_video", void 0);
-    const {
-      id = (0, _utils.uid)('texture'),
-      handle,
-      target
-    } = props;
-    this.target = target;
-    this.textureUnit = undefined;
-    this.loaded = false;
-    this.width = undefined;
-    this.height = undefined;
-    this.depth = undefined;
-    this.format = undefined;
-    this.type = undefined;
-    this.dataFormat = undefined;
-    this.border = undefined;
-    this.textureUnit = undefined;
-    this.mipmaps = undefined;
-    this.gl = gl;
-    this.gl2 = (0, _gltools.getWebGL2Context)(gl);
-    this.handle = this.props.handle || this.gl.createTexture();
-  }
+var _webglBuffer = _interopRequireDefault(require("./webgl-buffer"));
 
-  destroy() {
-    if (this.handle) {
-      this.gl.deleteTexture(this.handle);
-      this.removeStats();
-      this.trackDeallocatedMemory('Texture');
-      this.handle = null;
-    }
-  }
+var _textureFormats = require("./texture-formats");
 
-  toString() {
-    return "Texture(".concat(this.id, ",").concat(this.width, "x").concat(this.height, ")");
+function _createForOfIteratorHelper(o, allowArrayLike) { var it = typeof Symbol !== "undefined" && o[Symbol.iterator] || o["@@iterator"]; if (!it) { if (Array.isArray(o) || (it = _unsupportedIterableToArray(o)) || allowArrayLike && o && typeof o.length === "number") { if (it) o = it; var i = 0; var F = function F() {}; return { s: F, n: function n() { if (i >= o.length) return { done: true }; return { done: false, value: o[i++] }; }, e: function e(_e) { throw _e; }, f: F }; } throw new TypeError("Invalid attempt to iterate non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); } var normalCompletion = true, didErr = false, err; return { s: function s() { it = it.call(o); }, n: function n() { var step = it.next(); normalCompletion = step.done; return step; }, e: function e(_e2) { didErr = true; err = _e2; }, f: function f() { try { if (!normalCompletion && it.return != null) it.return(); } finally { if (didErr) throw err; } } }; }
+
+function _unsupportedIterableToArray(o, minLen) { if (!o) return; if (typeof o === "string") return _arrayLikeToArray(o, minLen); var n = Object.prototype.toString.call(o).slice(8, -1); if (n === "Object" && o.constructor) n = o.constructor.name; if (n === "Map" || n === "Set") return Array.from(o); if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray(o, minLen); }
+
+function _arrayLikeToArray(arr, len) { if (len == null || len > arr.length) len = arr.length; for (var i = 0, arr2 = new Array(len); i < len; i++) { arr2[i] = arr[i]; } return arr2; }
+
+function _createSuper(Derived) { var hasNativeReflectConstruct = _isNativeReflectConstruct(); return function _createSuperInternal() { var Super = (0, _getPrototypeOf2.default)(Derived), result; if (hasNativeReflectConstruct) { var NewTarget = (0, _getPrototypeOf2.default)(this).constructor; result = Reflect.construct(Super, arguments, NewTarget); } else { result = Super.apply(this, arguments); } return (0, _possibleConstructorReturn2.default)(this, result); }; }
+
+function _isNativeReflectConstruct() { if (typeof Reflect === "undefined" || !Reflect.construct) return false; if (Reflect.construct.sham) return false; if (typeof Proxy === "function") return true; try { Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function () {})); return true; } catch (e) { return false; } }
+
+var NPOT_MIN_FILTERS = [_constants.default.LINEAR, _constants.default.NEAREST];
+
+var WEBGLTexture = function (_Texture) {
+  (0, _inherits2.default)(WEBGLTexture, _Texture);
+
+  var _super = _createSuper(WEBGLTexture);
+
+  function WEBGLTexture(device, props) {
+    var _this;
+
+    (0, _classCallCheck2.default)(this, WEBGLTexture);
+    _this = _super.call(this, _webglDevice.default.attach(device), props);
+    (0, _defineProperty2.default)((0, _assertThisInitialized2.default)(_this), "MAX_ATTRIBUTES", void 0);
+    (0, _defineProperty2.default)((0, _assertThisInitialized2.default)(_this), "device", void 0);
+    (0, _defineProperty2.default)((0, _assertThisInitialized2.default)(_this), "gl", void 0);
+    (0, _defineProperty2.default)((0, _assertThisInitialized2.default)(_this), "gl2", void 0);
+    (0, _defineProperty2.default)((0, _assertThisInitialized2.default)(_this), "handle", void 0);
+    (0, _defineProperty2.default)((0, _assertThisInitialized2.default)(_this), "data", void 0);
+    (0, _defineProperty2.default)((0, _assertThisInitialized2.default)(_this), "width", void 0);
+    (0, _defineProperty2.default)((0, _assertThisInitialized2.default)(_this), "height", void 0);
+    (0, _defineProperty2.default)((0, _assertThisInitialized2.default)(_this), "depth", void 0);
+    (0, _defineProperty2.default)((0, _assertThisInitialized2.default)(_this), "format", undefined);
+    (0, _defineProperty2.default)((0, _assertThisInitialized2.default)(_this), "type", undefined);
+    (0, _defineProperty2.default)((0, _assertThisInitialized2.default)(_this), "dataFormat", undefined);
+    (0, _defineProperty2.default)((0, _assertThisInitialized2.default)(_this), "border", undefined);
+    (0, _defineProperty2.default)((0, _assertThisInitialized2.default)(_this), "mipmaps", undefined);
+    (0, _defineProperty2.default)((0, _assertThisInitialized2.default)(_this), "target", void 0);
+    (0, _defineProperty2.default)((0, _assertThisInitialized2.default)(_this), "textureUnit", undefined);
+    (0, _defineProperty2.default)((0, _assertThisInitialized2.default)(_this), "loaded", false);
+    (0, _defineProperty2.default)((0, _assertThisInitialized2.default)(_this), "_video", void 0);
+    var _props$id = props.id,
+        id = _props$id === void 0 ? (0, _api.uid)('texture') : _props$id,
+        handle = props.handle,
+        target = props.target;
+    _this.target = target;
+    _this.textureUnit = undefined;
+    _this.loaded = false;
+    _this.width = undefined;
+    _this.height = undefined;
+    _this.depth = undefined;
+    _this.format = undefined;
+    _this.type = undefined;
+    _this.dataFormat = undefined;
+    _this.border = undefined;
+    _this.textureUnit = undefined;
+    _this.mipmaps = undefined;
+    _this.device = _webglDevice.default.attach(device);
+    _this.gl = _this.device.gl;
+    _this.gl2 = _this.device.gl2;
+    _this.handle = _this.props.handle || _this.gl.createTexture();
+    return _this;
   }
 
-  initialize(props = {}) {
-    let data = props.data;
-
-    if (data instanceof Promise) {
-      data.then(resolvedImageData => this.initialize(Object.assign({}, props, {
-        pixels: resolvedImageData,
-        data: resolvedImageData
-      })));
-      return this;
+  (0, _createClass2.default)(WEBGLTexture, [{
+    key: "destroy",
+    value: function destroy() {
+      if (this.handle) {
+        this.gl.deleteTexture(this.handle);
+        this.removeStats();
+        this.trackDeallocatedMemory('Texture');
+        this.handle = null;
+      }
     }
+  }, {
+    key: "toString",
+    value: function toString() {
+      return "Texture(".concat(this.id, ",").concat(this.width, "x").concat(this.height, ")");
+    }
+  }, {
+    key: "initialize",
+    value: function initialize() {
+      var _this2 = this;
+
+      var props = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
+      var data = props.data;
+
+      if (data instanceof Promise) {
+        data.then(function (resolvedImageData) {
+          return _this2.initialize(Object.assign({}, props, {
+            pixels: resolvedImageData,
+            data: resolvedImageData
+          }));
+        });
+        return this;
+      }
 
-    const isVideo = typeof HTMLVideoElement !== 'undefined' && data instanceof HTMLVideoElement;
-
-    if (isVideo && data.readyState < HTMLVideoElement.HAVE_METADATA) {
-      this._video = null;
-      data.addEventListener('loadeddata', () => this.initialize(props));
-      return this;
-    }
+      var isVideo = typeof HTMLVideoElement !== 'undefined' && data instanceof HTMLVideoElement;
 
-    const {
-      pixels = null,
-      format = _constants.default.RGBA,
-      border = 0,
-      recreate = false,
-      parameters = {},
-      pixelStore = {},
-      textureUnit = undefined
-    } = props;
-
-    if (!data) {
-      data = pixels;
-    }
+      if (isVideo && data.readyState < HTMLVideoElement.HAVE_METADATA) {
+        this._video = null;
+        data.addEventListener('loadeddata', function () {
+          return _this2.initialize(props);
+        });
+        return this;
+      }
 
-    let {
-      width,
-      height,
-      dataFormat,
-      type,
-      compressed = false,
-      mipmaps = true
-    } = props;
-    const {
-      depth = 0
-    } = props;
-    ({
-      width,
-      height,
-      compressed,
-      dataFormat,
-      type
-    } = this._deduceParameters({
-      format,
-      type,
-      dataFormat,
-      compressed,
-      data,
-      width,
-      height
-    }));
-    this.width = width;
-    this.height = height;
-    this.depth = depth;
-    this.format = format;
-    this.type = type;
-    this.dataFormat = dataFormat;
-    this.border = border;
-    this.textureUnit = textureUnit;
-
-    if (Number.isFinite(this.textureUnit)) {
-      this.gl.activeTexture(_constants.default.TEXTURE0 + this.textureUnit);
-      this.gl.bindTexture(this.target, this.handle);
-    }
+      var _props$pixels = props.pixels,
+          pixels = _props$pixels === void 0 ? null : _props$pixels,
+          _props$format = props.format,
+          format = _props$format === void 0 ? _constants.default.RGBA : _props$format,
+          _props$border = props.border,
+          border = _props$border === void 0 ? 0 : _props$border,
+          _props$recreate = props.recreate,
+          recreate = _props$recreate === void 0 ? false : _props$recreate,
+          _props$parameters = props.parameters,
+          parameters = _props$parameters === void 0 ? {} : _props$parameters,
+          _props$pixelStore = props.pixelStore,
+          pixelStore = _props$pixelStore === void 0 ? {} : _props$pixelStore,
+          _props$textureUnit = props.textureUnit,
+          textureUnit = _props$textureUnit === void 0 ? undefined : _props$textureUnit;
+
+      if (!data) {
+        data = pixels;
+      }
 
-    if (mipmaps && this._isNPOT()) {
-      _gltools.log.warn("texture: ".concat(this, " is Non-Power-Of-Two, disabling mipmaping"))();
+      var width = props.width,
+          height = props.height,
+          dataFormat = props.dataFormat,
+          type = props.type,
+          _props$compressed = props.compressed,
+          compressed = _props$compressed === void 0 ? false : _props$compressed,
+          _props$mipmaps = props.mipmaps,
+          mipmaps = _props$mipmaps === void 0 ? true : _props$mipmaps;
+      var _props$depth = props.depth,
+          depth = _props$depth === void 0 ? 0 : _props$depth;
+
+      var _this$_deduceParamete = this._deduceParameters({
+        format: format,
+        type: type,
+        dataFormat: dataFormat,
+        compressed: compressed,
+        data: data,
+        width: width,
+        height: height
+      });
 
-      mipmaps = false;
+      width = _this$_deduceParamete.width;
+      height = _this$_deduceParamete.height;
+      compressed = _this$_deduceParamete.compressed;
+      dataFormat = _this$_deduceParamete.dataFormat;
+      type = _this$_deduceParamete.type;
+      this.width = width;
+      this.height = height;
+      this.depth = depth;
+      this.format = format;
+      this.type = type;
+      this.dataFormat = dataFormat;
+      this.border = border;
+      this.textureUnit = textureUnit;
 
-      this._updateForNPOT(parameters);
-    }
+      if (Number.isFinite(this.textureUnit)) {
+        this.gl.activeTexture(_constants.default.TEXTURE0 + this.textureUnit);
+        this.gl.bindTexture(this.target, this.handle);
+      }
 
-    this.mipmaps = mipmaps;
-    this.setImageData({
-      data,
-      width,
-      height,
-      depth,
-      format,
-      type,
-      dataFormat,
-      border,
-      mipmaps,
-      parameters: pixelStore,
-      compressed
-    });
-
-    if (mipmaps) {
-      this.generateMipmap();
-    }
+      if (mipmaps && this._isNPOT()) {
+        _api.log.warn("texture: ".concat(this, " is Non-Power-Of-Two, disabling mipmaping"))();
 
-    this.setParameters(parameters);
+        mipmaps = false;
 
-    if (recreate) {
-      this.data = data;
-    }
+        this._updateForNPOT(parameters);
+      }
 
-    if (isVideo) {
-      this._video = {
-        video: data,
-        parameters,
-        lastTime: data.readyState >= HTMLVideoElement.HAVE_CURRENT_DATA ? data.currentTime : -1
-      };
-    }
+      this.mipmaps = mipmaps;
+      this.setImageData({
+        data: data,
+        width: width,
+        height: height,
+        depth: depth,
+        format: format,
+        type: type,
+        dataFormat: dataFormat,
+        border: border,
+        mipmaps: mipmaps,
+        parameters: pixelStore,
+        compressed: compressed
+      });
 
-    return this;
-  }
+      if (mipmaps) {
+        this.generateMipmap();
+      }
 
-  update() {
-    if (this._video) {
-      const {
-        video,
-        parameters,
-        lastTime
-      } = this._video;
+      this.setParameters(parameters);
 
-      if (lastTime === video.currentTime || video.readyState < HTMLVideoElement.HAVE_CURRENT_DATA) {
-        return;
+      if (recreate) {
+        this.data = data;
       }
 
-      this.setSubImageData({
-        data: video,
-        parameters
-      });
-
-      if (this.mipmaps) {
-        this.generateMipmap();
+      if (isVideo) {
+        this._video = {
+          video: data,
+          parameters: parameters,
+          lastTime: data.readyState >= HTMLVideoElement.HAVE_CURRENT_DATA ? data.currentTime : -1
+        };
       }
 
-      this._video.lastTime = video.currentTime;
+      return this;
     }
-  }
+  }, {
+    key: "update",
+    value: function update() {
+      if (this._video) {
+        var _this$_video = this._video,
+            video = _this$_video.video,
+            parameters = _this$_video.parameters,
+            lastTime = _this$_video.lastTime;
+
+        if (lastTime === video.currentTime || video.readyState < HTMLVideoElement.HAVE_CURRENT_DATA) {
+          return;
+        }
 
-  resize({
-    height,
-    width,
-    mipmaps = false
-  }) {
-    if (width !== this.width || height !== this.height) {
-      return this.initialize({
-        width,
-        height,
-        format: this.format,
-        type: this.type,
-        dataFormat: this.dataFormat,
-        border: this.border,
-        mipmaps
-      });
-    }
+        this.setSubImageData({
+          data: video,
+          parameters: parameters
+        });
 
-    return this;
-  }
+        if (this.mipmaps) {
+          this.generateMipmap();
+        }
 
-  generateMipmap(params = {}) {
-    if (this._isNPOT()) {
-      _gltools.log.warn("texture: ".concat(this, " is Non-Power-Of-Two, disabling mipmaping"))();
+        this._video.lastTime = video.currentTime;
+      }
+    }
+  }, {
+    key: "resize",
+    value: function resize(_ref) {
+      var height = _ref.height,
+          width = _ref.width,
+          _ref$mipmaps = _ref.mipmaps,
+          mipmaps = _ref$mipmaps === void 0 ? false : _ref$mipmaps;
+
+      if (width !== this.width || height !== this.height) {
+        return this.initialize({
+          width: width,
+          height: height,
+          format: this.format,
+          type: this.type,
+          dataFormat: this.dataFormat,
+          border: this.border,
+          mipmaps: mipmaps
+        });
+      }
 
       return this;
     }
+  }, {
+    key: "generateMipmap",
+    value: function generateMipmap() {
+      var _this3 = this;
 
-    this.mipmaps = true;
-    this.gl.bindTexture(this.target, this.handle);
-    (0, _gltools.withParameters)(this.gl, params, () => {
-      this.gl.generateMipmap(this.target);
-    });
-    this.gl.bindTexture(this.target, null);
-    return this;
-  }
+      var params = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
 
-  setImageData(options) {
-    this.trackDeallocatedMemory('Texture');
-    const {
-      target = this.target,
-      pixels = null,
-      level = 0,
-      format = this.format,
-      border = this.border,
-      offset = 0,
-      parameters = {}
-    } = options;
-    let {
-      data = null,
-      type = this.type,
-      width = this.width,
-      height = this.height,
-      dataFormat = this.dataFormat,
-      compressed = false
-    } = options;
-
-    if (!data) {
-      data = pixels;
-    }
+      if (this._isNPOT()) {
+        _api.log.warn("texture: ".concat(this, " is Non-Power-Of-Two, disabling mipmaping"))();
 
-    ({
-      type,
-      dataFormat,
-      compressed,
-      width,
-      height
-    } = this._deduceParameters({
-      format,
-      type,
-      dataFormat,
-      compressed,
-      data,
-      width,
-      height
-    }));
-    const {
-      gl
-    } = this;
-    gl.bindTexture(this.target, this.handle);
-    let dataType = null;
-    ({
-      data,
-      dataType
-    } = this._getDataType({
-      data,
-      compressed
-    }));
-    let gl2;
-    (0, _gltools.withParameters)(this.gl, parameters, () => {
-      switch (dataType) {
-        case 'null':
-          gl.texImage2D(target, level, format, width, height, border, dataFormat, type, data);
-          break;
+        return this;
+      }
 
-        case 'typed-array':
-          gl.texImage2D(target, level, format, width, height, border, dataFormat, type, data, offset);
-          break;
+      this.mipmaps = true;
+      this.gl.bindTexture(this.target, this.handle);
+      (0, _withParameters.withParameters)(this.gl, params, function () {
+        _this3.gl.generateMipmap(_this3.target);
+      });
+      this.gl.bindTexture(this.target, null);
+      return this;
+    }
+  }, {
+    key: "setImageData",
+    value: function setImageData(options) {
+      this.trackDeallocatedMemory('Texture');
+      var _options$target = options.target,
+          target = _options$target === void 0 ? this.target : _options$target,
+          _options$pixels = options.pixels,
+          pixels = _options$pixels === void 0 ? null : _options$pixels,
+          _options$level = options.level,
+          level = _options$level === void 0 ? 0 : _options$level,
+          _options$format = options.format,
+          format = _options$format === void 0 ? this.format : _options$format,
+          _options$border = options.border,
+          border = _options$border === void 0 ? this.border : _options$border,
+          _options$offset = options.offset,
+          offset = _options$offset === void 0 ? 0 : _options$offset,
+          _options$parameters = options.parameters,
+          parameters = _options$parameters === void 0 ? {} : _options$parameters;
+      var _options$data = options.data,
+          data = _options$data === void 0 ? null : _options$data,
+          _options$type = options.type,
+          type = _options$type === void 0 ? this.type : _options$type,
+          _options$width = options.width,
+          width = _options$width === void 0 ? this.width : _options$width,
+          _options$height = options.height,
+          height = _options$height === void 0 ? this.height : _options$height,
+          _options$dataFormat = options.dataFormat,
+          dataFormat = _options$dataFormat === void 0 ? this.dataFormat : _options$dataFormat,
+          _options$compressed = options.compressed,
+          compressed = _options$compressed === void 0 ? false : _options$compressed;
+
+      if (!data) {
+        data = pixels;
+      }
 
-        case 'buffer':
-          gl2 = (0, _gltools.assertWebGL2Context)(gl);
-          gl2.bindBuffer(_constants.default.PIXEL_UNPACK_BUFFER, data.handle || data);
-          gl2.texImage2D(target, level, format, width, height, border, dataFormat, type, offset);
-          gl2.bindBuffer(_constants.default.PIXEL_UNPACK_BUFFER, null);
-          break;
+      var _this$_deduceParamete2 = this._deduceParameters({
+        format: format,
+        type: type,
+        dataFormat: dataFormat,
+        compressed: compressed,
+        data: data,
+        width: width,
+        height: height
+      });
 
-        case 'browser-object':
-          if ((0, _gltools.isWebGL2)(gl)) {
+      type = _this$_deduceParamete2.type;
+      dataFormat = _this$_deduceParamete2.dataFormat;
+      compressed = _this$_deduceParamete2.compressed;
+      width = _this$_deduceParamete2.width;
+      height = _this$_deduceParamete2.height;
+      var gl = this.gl;
+      gl.bindTexture(this.target, this.handle);
+      var dataType = null;
+
+      var _this$_getDataType = this._getDataType({
+        data: data,
+        compressed: compressed
+      });
+
+      data = _this$_getDataType.data;
+      dataType = _this$_getDataType.dataType;
+      var gl2;
+      (0, _withParameters.withParameters)(this.gl, parameters, function () {
+        switch (dataType) {
+          case 'null':
             gl.texImage2D(target, level, format, width, height, border, dataFormat, type, data);
-          } else {
-            gl.texImage2D(target, level, format, dataFormat, type, data);
-          }
+            break;
+
+          case 'typed-array':
+            gl.texImage2D(target, level, format, width, height, border, dataFormat, type, data, offset);
+            break;
+
+          case 'buffer':
+            gl2 = (0, _webglChecks.assertWebGL2Context)(gl);
+            gl2.bindBuffer(_constants.default.PIXEL_UNPACK_BUFFER, data.handle || data);
+            gl2.texImage2D(target, level, format, width, height, border, dataFormat, type, offset);
+            gl2.bindBuffer(_constants.default.PIXEL_UNPACK_BUFFER, null);
+            break;
+
+          case 'browser-object':
+            if ((0, _webglChecks.isWebGL2)(gl)) {
+              gl.texImage2D(target, level, format, width, height, border, dataFormat, type, data);
+            } else {
+              gl.texImage2D(target, level, format, dataFormat, type, data);
+            }
+
+            break;
+
+          case 'compressed':
+            var _iterator = _createForOfIteratorHelper(data.entries()),
+                _step;
+
+            try {
+              for (_iterator.s(); !(_step = _iterator.n()).done;) {
+                var _step$value = (0, _slicedToArray2.default)(_step.value, 2),
+                    levelIndex = _step$value[0],
+                    levelData = _step$value[1];
+
+                gl.compressedTexImage2D(target, levelIndex, levelData.format, levelData.width, levelData.height, border, levelData.data);
+              }
+            } catch (err) {
+              _iterator.e(err);
+            } finally {
+              _iterator.f();
+            }
+
+            break;
+
+          default:
+            (0, _api.assert)(false, 'Unknown image data type');
+        }
+      });
 
-          break;
+      if (data && data.byteLength) {
+        this.trackAllocatedMemory(data.byteLength, 'Texture');
+      } else {
+        var channels = _textureFormats.DATA_FORMAT_CHANNELS[this.dataFormat] || 4;
+        var channelSize = _textureFormats.TYPE_SIZES[this.type] || 1;
+        this.trackAllocatedMemory(this.width * this.height * channels * channelSize, 'Texture');
+      }
 
-        case 'compressed':
-          for (const [levelIndex, levelData] of data.entries()) {
-            gl.compressedTexImage2D(target, levelIndex, levelData.format, levelData.width, levelData.height, border, levelData.data);
-          }
+      this.loaded = true;
+      return this;
+    }
+  }, {
+    key: "setSubImageData",
+    value: function setSubImageData(_ref2) {
+      var _this4 = this;
+
+      var _ref2$target = _ref2.target,
+          target = _ref2$target === void 0 ? this.target : _ref2$target,
+          _ref2$pixels = _ref2.pixels,
+          pixels = _ref2$pixels === void 0 ? null : _ref2$pixels,
+          _ref2$data = _ref2.data,
+          data = _ref2$data === void 0 ? null : _ref2$data,
+          _ref2$x = _ref2.x,
+          x = _ref2$x === void 0 ? 0 : _ref2$x,
+          _ref2$y = _ref2.y,
+          y = _ref2$y === void 0 ? 0 : _ref2$y,
+          _ref2$width = _ref2.width,
+          width = _ref2$width === void 0 ? this.width : _ref2$width,
+          _ref2$height = _ref2.height,
+          height = _ref2$height === void 0 ? this.height : _ref2$height,
+          _ref2$level = _ref2.level,
+          level = _ref2$level === void 0 ? 0 : _ref2$level,
+          _ref2$format = _ref2.format,
+          format = _ref2$format === void 0 ? this.format : _ref2$format,
+          _ref2$type = _ref2.type,
+          type = _ref2$type === void 0 ? this.type : _ref2$type,
+          _ref2$dataFormat = _ref2.dataFormat,
+          dataFormat = _ref2$dataFormat === void 0 ? this.dataFormat : _ref2$dataFormat,
+          _ref2$compressed = _ref2.compressed,
+          compressed = _ref2$compressed === void 0 ? false : _ref2$compressed,
+          _ref2$offset = _ref2.offset,
+          offset = _ref2$offset === void 0 ? 0 : _ref2$offset,
+          _ref2$border = _ref2.border,
+          border = _ref2$border === void 0 ? this.border : _ref2$border,
+          _ref2$parameters = _ref2.parameters,
+          parameters = _ref2$parameters === void 0 ? {} : _ref2$parameters;
+
+      var _this$_deduceParamete3 = this._deduceParameters({
+        format: format,
+        type: type,
+        dataFormat: dataFormat,
+        compressed: compressed,
+        data: data,
+        width: width,
+        height: height
+      });
 
-          break;
+      type = _this$_deduceParamete3.type;
+      dataFormat = _this$_deduceParamete3.dataFormat;
+      compressed = _this$_deduceParamete3.compressed;
+      width = _this$_deduceParamete3.width;
+      height = _this$_deduceParamete3.height;
+      (0, _api.assert)(this.depth === 0, 'texSubImage not supported for 3D textures');
 
-        default:
-          (0, _utils.assert)(false, 'Unknown image data type');
+      if (!data) {
+        data = pixels;
       }
-    });
 
-    if (data && data.byteLength) {
-      this.trackAllocatedMemory(data.byteLength, 'Texture');
-    } else {
-      const channels = _textureFormats.DATA_FORMAT_CHANNELS[this.dataFormat] || 4;
-      const channelSize = _textureFormats.TYPE_SIZES[this.type] || 1;
-      this.trackAllocatedMemory(this.width * this.height * channels * channelSize, 'Texture');
-    }
+      if (data && data.data) {
+        var ndarray = data;
+        data = ndarray.data;
+        width = ndarray.shape[0];
+        height = ndarray.shape[1];
+      }
 
-    this.loaded = true;
-    return this;
-  }
+      if (data instanceof _webglBuffer.default) {
+        data = data.handle;
+      }
 
-  setSubImageData({
-    target = this.target,
-    pixels = null,
-    data = null,
-    x = 0,
-    y = 0,
-    width = this.width,
-    height = this.height,
-    level = 0,
-    format = this.format,
-    type = this.type,
-    dataFormat = this.dataFormat,
-    compressed = false,
-    offset = 0,
-    border = this.border,
-    parameters = {}
-  }) {
-    ({
-      type,
-      dataFormat,
-      compressed,
-      width,
-      height
-    } = this._deduceParameters({
-      format,
-      type,
-      dataFormat,
-      compressed,
-      data,
-      width,
-      height
-    }));
-    (0, _utils.assert)(this.depth === 0, 'texSubImage not supported for 3D textures');
-
-    if (!data) {
-      data = pixels;
-    }
+      this.gl.bindTexture(this.target, this.handle);
+      (0, _withParameters.withParameters)(this.gl, parameters, function () {
+        if (compressed) {
+          _this4.gl.compressedTexSubImage2D(target, level, x, y, width, height, format, data);
+        } else if (data === null) {
+          _this4.gl.texSubImage2D(target, level, x, y, width, height, dataFormat, type, null);
+        } else if (ArrayBuffer.isView(data)) {
+          _this4.gl.texSubImage2D(target, level, x, y, width, height, dataFormat, type, data, offset);
+        } else if (typeof WebGLBuffer !== 'undefined' && data instanceof WebGLBuffer) {
+          var gl2 = (0, _webglChecks.assertWebGL2Context)(_this4.gl);
+          gl2.bindBuffer(_constants.default.PIXEL_UNPACK_BUFFER, data);
+          gl2.texSubImage2D(target, level, x, y, width, height, dataFormat, type, offset);
+          gl2.bindBuffer(_constants.default.PIXEL_UNPACK_BUFFER, null);
+        } else if ((0, _webglChecks.isWebGL2)(_this4.gl)) {
+          var _gl = (0, _webglChecks.assertWebGL2Context)(_this4.gl);
 
-    if (data && data.data) {
-      const ndarray = data;
-      data = ndarray.data;
-      width = ndarray.shape[0];
-      height = ndarray.shape[1];
+          _gl.texSubImage2D(target, level, x, y, width, height, dataFormat, type, data);
+        } else {
+          _this4.gl.texSubImage2D(target, level, x, y, dataFormat, type, data);
+        }
+      });
+      this.gl.bindTexture(this.target, null);
     }
+  }, {
+    key: "copyFramebuffer",
+    value: function copyFramebuffer() {
+      var opts = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
 
-    if (data instanceof _webglBuffer.default) {
-      data = data.handle;
+      _api.log.error('Texture.copyFramebuffer({...}) is no logner supported, use copyToTexture(source, target, opts})')();
+
+      return null;
+    }
+  }, {
+    key: "getActiveUnit",
+    value: function getActiveUnit() {
+      return this.gl.getParameter(_constants.default.ACTIVE_TEXTURE) - _constants.default.TEXTURE0;
     }
+  }, {
+    key: "bind",
+    value: function bind() {
+      var textureUnit = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : this.textureUnit;
+      var gl = this.gl;
 
-    this.gl.bindTexture(this.target, this.handle);
-    (0, _gltools.withParameters)(this.gl, parameters, () => {
-      if (compressed) {
-        this.gl.compressedTexSubImage2D(target, level, x, y, width, height, format, data);
-      } else if (data === null) {
-        this.gl.texSubImage2D(target, level, x, y, width, height, dataFormat, type, null);
-      } else if (ArrayBuffer.isView(data)) {
-        this.gl.texSubImage2D(target, level, x, y, width, height, dataFormat, type, data, offset);
-      } else if (data instanceof WebGLBuffer) {
-        const gl2 = (0, _gltools.assertWebGL2Context)(this.gl);
-        gl2.bindBuffer(_constants.default.PIXEL_UNPACK_BUFFER, data);
-        gl2.texSubImage2D(target, level, x, y, width, height, dataFormat, type, offset);
-        gl2.bindBuffer(_constants.default.PIXEL_UNPACK_BUFFER, null);
-      } else if ((0, _gltools.isWebGL2)(this.gl)) {
-        const gl2 = (0, _gltools.assertWebGL2Context)(this.gl);
-        gl2.texSubImage2D(target, level, x, y, width, height, dataFormat, type, data);
-      } else {
-        this.gl.texSubImage2D(target, level, x, y, dataFormat, type, data);
+      if (textureUnit !== undefined) {
+        this.textureUnit = textureUnit;
+        gl.activeTexture(gl.TEXTURE0 + textureUnit);
       }
-    });
-    this.gl.bindTexture(this.target, null);
-  }
-
-  copyFramebuffer(opts = {}) {
-    _gltools.log.error('Texture.copyFramebuffer({...}) is no logner supported, use copyToTexture(source, target, opts})')();
-
-    return null;
-  }
-
-  getActiveUnit() {
-    return this.gl.getParameter(_constants.default.ACTIVE_TEXTURE) - _constants.default.TEXTURE0;
-  }
-
-  bind(textureUnit = this.textureUnit) {
-    const {
-      gl
-    } = this;
 
-    if (textureUnit !== undefined) {
-      this.textureUnit = textureUnit;
-      gl.activeTexture(gl.TEXTURE0 + textureUnit);
+      gl.bindTexture(this.target, this.handle);
+      return textureUnit;
     }
+  }, {
+    key: "unbind",
+    value: function unbind() {
+      var textureUnit = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : this.textureUnit;
+      var gl = this.gl;
 
-    gl.bindTexture(this.target, this.handle);
-    return textureUnit;
-  }
-
-  unbind(textureUnit = this.textureUnit) {
-    const {
-      gl
-    } = this;
+      if (textureUnit !== undefined) {
+        this.textureUnit = textureUnit;
+        gl.activeTexture(gl.TEXTURE0 + textureUnit);
+      }
 
-    if (textureUnit !== undefined) {
-      this.textureUnit = textureUnit;
-      gl.activeTexture(gl.TEXTURE0 + textureUnit);
+      gl.bindTexture(this.target, null);
+      return textureUnit;
     }
+  }, {
+    key: "_getDataType",
+    value: function _getDataType(_ref3) {
+      var data = _ref3.data,
+          _ref3$compressed = _ref3.compressed,
+          compressed = _ref3$compressed === void 0 ? false : _ref3$compressed;
 
-    gl.bindTexture(this.target, null);
-    return textureUnit;
-  }
+      if (compressed) {
+        return {
+          data: data,
+          dataType: 'compressed'
+        };
+      }
 
-  _getDataType({
-    data,
-    compressed = false
-  }) {
-    if (compressed) {
-      return {
-        data,
-        dataType: 'compressed'
-      };
-    }
+      if (data === null) {
+        return {
+          data: data,
+          dataType: 'null'
+        };
+      }
 
-    if (data === null) {
-      return {
-        data,
-        dataType: 'null'
-      };
-    }
+      if (ArrayBuffer.isView(data)) {
+        return {
+          data: data,
+          dataType: 'typed-array'
+        };
+      }
 
-    if (ArrayBuffer.isView(data)) {
-      return {
-        data,
-        dataType: 'typed-array'
-      };
-    }
+      if (data instanceof _webglBuffer.default) {
+        return {
+          data: data.handle,
+          dataType: 'buffer'
+        };
+      }
+
+      if (typeof WebGLBuffer !== 'undefined' && data instanceof WebGLBuffer) {
+        return {
+          data: data,
+          dataType: 'buffer'
+        };
+      }
 
-    if (data instanceof _webglBuffer.default) {
       return {
-        data: data.handle,
-        dataType: 'buffer'
+        data: data,
+        dataType: 'browser-object'
       };
     }
-
-    if (data instanceof WebGLBuffer) {
+  }, {
+    key: "_deduceParameters",
+    value: function _deduceParameters(opts) {
+      var format = opts.format,
+          data = opts.data;
+      var width = opts.width,
+          height = opts.height,
+          dataFormat = opts.dataFormat,
+          type = opts.type,
+          compressed = opts.compressed;
+      var textureFormat = _textureFormats.TEXTURE_FORMATS[format];
+      dataFormat = dataFormat || textureFormat && textureFormat.dataFormat;
+      type = type || textureFormat && textureFormat.types[0];
+      compressed = compressed || textureFormat && textureFormat.compressed;
+
+      var _this$_deduceImageSiz = this._deduceImageSize(data, width, height);
+
+      width = _this$_deduceImageSiz.width;
+      height = _this$_deduceImageSiz.height;
       return {
-        data,
-        dataType: 'buffer'
+        dataFormat: dataFormat,
+        type: type,
+        compressed: compressed,
+        width: width,
+        height: height,
+        format: format,
+        data: data
       };
     }
+  }, {
+    key: "_deduceImageSize",
+    value: function _deduceImageSize(data, width, height) {
+      var size;
+
+      if (typeof ImageData !== 'undefined' && data instanceof ImageData) {
+        size = {
+          width: data.width,
+          height: data.height
+        };
+      } else if (typeof HTMLImageElement !== 'undefined' && data instanceof HTMLImageElement) {
+        size = {
+          width: data.naturalWidth,
+          height: data.naturalHeight
+        };
+      } else if (typeof HTMLCanvasElement !== 'undefined' && data instanceof HTMLCanvasElement) {
+        size = {
+          width: data.width,
+          height: data.height
+        };
+      } else if (typeof ImageBitmap !== 'undefined' && data instanceof ImageBitmap) {
+        size = {
+          width: data.width,
+          height: data.height
+        };
+      } else if (typeof HTMLVideoElement !== 'undefined' && data instanceof HTMLVideoElement) {
+        size = {
+          width: data.videoWidth,
+          height: data.videoHeight
+        };
+      } else if (!data) {
+        size = {
+          width: width >= 0 ? width : 1,
+          height: height >= 0 ? height : 1
+        };
+      } else {
+        size = {
+          width: width,
+          height: height
+        };
+      }
 
-    return {
-      data,
-      dataType: 'browser-object'
-    };
-  }
-
-  _deduceParameters(opts) {
-    const {
-      format,
-      data
-    } = opts;
-    let {
-      width,
-      height,
-      dataFormat,
-      type,
-      compressed
-    } = opts;
-    const textureFormat = _textureFormats.TEXTURE_FORMATS[format];
-    dataFormat = dataFormat || textureFormat && textureFormat.dataFormat;
-    type = type || textureFormat && textureFormat.types[0];
-    compressed = compressed || textureFormat && textureFormat.compressed;
-    ({
-      width,
-      height
-    } = this._deduceImageSize(data, width, height));
-    return {
-      dataFormat,
-      type,
-      compressed,
-      width,
-      height,
-      format,
-      data
-    };
-  }
+      (0, _api.assert)(size, 'Could not deduced texture size');
+      (0, _api.assert)(width === undefined || size.width === width, 'Deduced texture width does not match supplied width');
+      (0, _api.assert)(height === undefined || size.height === height, 'Deduced texture height does not match supplied height');
+      return size;
+    }
+  }, {
+    key: "getParameter",
+    value: function getParameter(pname) {
+      var props = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
+      pname = (0, _constantsToKeys.getKeyValue)(this.gl, pname);
+      (0, _api.assert)(pname);
+      var parameters = this.constructor.PARAMETERS || {};
+      var parameter = parameters[pname];
+
+      if (parameter) {
+        var isWebgl2 = (0, _webglChecks.isWebGL2)(this.gl);
+        var parameterAvailable = (!('webgl2' in parameter) || isWebgl2) && (!('extension' in parameter) || this.gl.getExtension(parameter.extension));
+
+        if (!parameterAvailable) {
+          var webgl1Default = parameter.webgl1;
+          var webgl2Default = 'webgl2' in parameter ? parameter.webgl2 : parameter.webgl1;
+          var defaultValue = isWebgl2 ? webgl2Default : webgl1Default;
+          return defaultValue;
+        }
+      }
 
-  _deduceImageSize(data, width, height) {
-    let size;
+      return this._getParameter(pname, props);
+    }
+  }, {
+    key: "getParameters",
+    value: function getParameters() {
+      var options = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
+      var parameters = options.parameters,
+          keys = options.keys;
+      var PARAMETERS = this.constructor.PARAMETERS || {};
+      var isWebgl2 = (0, _webglChecks.isWebGL2)(this.gl);
+      var values = {};
+      var parameterKeys = parameters || Object.keys(PARAMETERS);
+
+      var _iterator2 = _createForOfIteratorHelper(parameterKeys),
+          _step2;
+
+      try {
+        for (_iterator2.s(); !(_step2 = _iterator2.n()).done;) {
+          var pname = _step2.value;
+          var parameter = PARAMETERS[pname];
+          var parameterAvailable = parameter && (!('webgl2' in parameter) || isWebgl2) && (!('extension' in parameter) || this.gl.getExtension(parameter.extension));
+
+          if (parameterAvailable) {
+            var key = keys ? (0, _constantsToKeys.getKey)(this.gl, pname) : pname;
+            values[key] = this.getParameter(pname, options);
+
+            if (keys && parameter.type === 'GLenum') {
+              values[key] = (0, _constantsToKeys.getKey)(this.gl, values[key]);
+            }
+          }
+        }
+      } catch (err) {
+        _iterator2.e(err);
+      } finally {
+        _iterator2.f();
+      }
 
-    if (typeof ImageData !== 'undefined' && data instanceof ImageData) {
-      size = {
-        width: data.width,
-        height: data.height
-      };
-    } else if (typeof HTMLImageElement !== 'undefined' && data instanceof HTMLImageElement) {
-      size = {
-        width: data.naturalWidth,
-        height: data.naturalHeight
-      };
-    } else if (typeof HTMLCanvasElement !== 'undefined' && data instanceof HTMLCanvasElement) {
-      size = {
-        width: data.width,
-        height: data.height
-      };
-    } else if (typeof ImageBitmap !== 'undefined' && data instanceof ImageBitmap) {
-      size = {
-        width: data.width,
-        height: data.height
-      };
-    } else if (typeof HTMLVideoElement !== 'undefined' && data instanceof HTMLVideoElement) {
-      size = {
-        width: data.videoWidth,
-        height: data.videoHeight
-      };
-    } else if (!data) {
-      size = {
-        width: width >= 0 ? width : 1,
-        height: height >= 0 ? height : 1
-      };
-    } else {
-      size = {
-        width,
-        height
-      };
+      return values;
     }
+  }, {
+    key: "setParameter",
+    value: function setParameter(pname, value) {
+      pname = (0, _constantsToKeys.getKeyValue)(this.gl, pname);
+      (0, _api.assert)(pname);
+      var parameters = this.constructor.PARAMETERS || {};
+      var parameter = parameters[pname];
 
-    (0, _utils.assert)(size, 'Could not deduced texture size');
-    (0, _utils.assert)(width === undefined || size.width === width, 'Deduced texture width does not match supplied width');
-    (0, _utils.assert)(height === undefined || size.height === height, 'Deduced texture height does not match supplied height');
-    return size;
-  }
+      if (parameter) {
+        var isWebgl2 = (0, _webglChecks.isWebGL2)(this.gl);
+        var parameterAvailable = (!('webgl2' in parameter) || isWebgl2) && (!('extension' in parameter) || this.gl.getExtension(parameter.extension));
 
-  getParameter(pname, props = {}) {
-    pname = (0, _webglUtils.getKeyValue)(this.gl, pname);
-    (0, _utils.assert)(pname);
-    const parameters = this.constructor.PARAMETERS || {};
-    const parameter = parameters[pname];
-
-    if (parameter) {
-      const isWebgl2 = (0, _gltools.isWebGL2)(this.gl);
-      const parameterAvailable = (!('webgl2' in parameter) || isWebgl2) && (!('extension' in parameter) || this.gl.getExtension(parameter.extension));
-
-      if (!parameterAvailable) {
-        const webgl1Default = parameter.webgl1;
-        const webgl2Default = 'webgl2' in parameter ? parameter.webgl2 : parameter.webgl1;
-        const defaultValue = isWebgl2 ? webgl2Default : webgl1Default;
-        return defaultValue;
-      }
-    }
-
-    return this._getParameter(pname, props);
-  }
+        if (!parameterAvailable) {
+          throw new Error('Parameter not available on this platform');
+        }
 
-  getParameters(options = {}) {
-    const {
-      parameters,
-      keys
-    } = options;
-    const PARAMETERS = this.constructor.PARAMETERS || {};
-    const isWebgl2 = (0, _gltools.isWebGL2)(this.gl);
-    const values = {};
-    const parameterKeys = parameters || Object.keys(PARAMETERS);
-
-    for (const pname of parameterKeys) {
-      const parameter = PARAMETERS[pname];
-      const parameterAvailable = parameter && (!('webgl2' in parameter) || isWebgl2) && (!('extension' in parameter) || this.gl.getExtension(parameter.extension));
-
-      if (parameterAvailable) {
-        const key = keys ? (0, _webglUtils.getKey)(this.gl, pname) : pname;
-        values[key] = this.getParameter(pname, options);
-
-        if (keys && parameter.type === 'GLenum') {
-          values[key] = (0, _webglUtils.getKey)(this.gl, values[key]);
+        if (parameter.type === 'GLenum') {
+          value = (0, _constantsToKeys.getKeyValue)(value);
         }
       }
-    }
 
-    return values;
-  }
+      this._setParameter(pname, value);
 
-  setParameter(pname, value) {
-    pname = (0, _webglUtils.getKeyValue)(this.gl, pname);
-    (0, _utils.assert)(pname);
-    const parameters = this.constructor.PARAMETERS || {};
-    const parameter = parameters[pname];
-
-    if (parameter) {
-      const isWebgl2 = (0, _gltools.isWebGL2)(this.gl);
-      const parameterAvailable = (!('webgl2' in parameter) || isWebgl2) && (!('extension' in parameter) || this.gl.getExtension(parameter.extension));
-
-      if (!parameterAvailable) {
-        throw new Error('Parameter not available on this platform');
+      return this;
+    }
+  }, {
+    key: "setParameters",
+    value: function setParameters(parameters) {
+      for (var pname in parameters) {
+        this.setParameter(pname, parameters[pname]);
       }
 
-      if (parameter.type === 'GLenum') {
-        value = (0, _webglUtils.getKeyValue)(value);
-      }
+      return this;
     }
+  }, {
+    key: "_getParameter",
+    value: function _getParameter(pname, props) {
+      switch (pname) {
+        case _constants.default.TEXTURE_WIDTH:
+          return this.width;
 
-    this._setParameter(pname, value);
-
-    return this;
-  }
+        case _constants.default.TEXTURE_HEIGHT:
+          return this.height;
 
-  setParameters(parameters) {
-    for (const pname in parameters) {
-      this.setParameter(pname, parameters[pname]);
+        default:
+          this.gl.bindTexture(this.target, this.handle);
+          var value = this.gl.getTexParameter(this.target, pname);
+          this.gl.bindTexture(this.target, null);
+          return value;
+      }
     }
+  }, {
+    key: "_setParameter",
+    value: function _setParameter(pname, param) {
+      this.gl.bindTexture(this.target, this.handle);
+      param = this._getNPOTParam(pname, param);
 
-    return this;
-  }
+      switch (pname) {
+        case _constants.default.TEXTURE_MIN_LOD:
+        case _constants.default.TEXTURE_MAX_LOD:
+          this.gl.texParameterf(this.target, pname, param);
+          break;
 
-  _getParameter(pname, props) {
-    switch (pname) {
-      case _constants.default.TEXTURE_WIDTH:
-        return this.width;
+        case _constants.default.TEXTURE_WIDTH:
+        case _constants.default.TEXTURE_HEIGHT:
+          (0, _api.assert)(false);
+          break;
 
-      case _constants.default.TEXTURE_HEIGHT:
-        return this.height;
+        default:
+          this.gl.texParameteri(this.target, pname, param);
+          break;
+      }
 
-      default:
-        this.gl.bindTexture(this.target, this.handle);
-        const value = this.gl.getTexParameter(this.target, pname);
-        this.gl.bindTexture(this.target, null);
-        return value;
+      this.gl.bindTexture(this.target, null);
+      return this;
     }
-  }
-
-  _setParameter(pname, param) {
-    this.gl.bindTexture(this.target, this.handle);
-    param = this._getNPOTParam(pname, param);
-
-    switch (pname) {
-      case _constants.default.TEXTURE_MIN_LOD:
-      case _constants.default.TEXTURE_MAX_LOD:
-        this.gl.texParameterf(this.target, pname, param);
-        break;
+  }, {
+    key: "_isNPOT",
+    value: function _isNPOT() {
+      if ((0, _webglChecks.isWebGL2)(this.gl)) {
+        return false;
+      }
 
-      case _constants.default.TEXTURE_WIDTH:
-      case _constants.default.TEXTURE_HEIGHT:
-        (0, _utils.assert)(false);
-        break;
+      if (!this.width || !this.height) {
+        return false;
+      }
 
-      default:
-        this.gl.texParameteri(this.target, pname, param);
-        break;
+      return !(0, _api.isPowerOfTwo)(this.width) || !(0, _api.isPowerOfTwo)(this.height);
     }
+  }, {
+    key: "_updateForNPOT",
+    value: function _updateForNPOT(parameters) {
+      if (parameters[this.gl.TEXTURE_MIN_FILTER] === undefined) {
+        parameters[this.gl.TEXTURE_MIN_FILTER] = this.gl.LINEAR;
+      }
 
-    this.gl.bindTexture(this.target, null);
-    return this;
-  }
+      if (parameters[this.gl.TEXTURE_WRAP_S] === undefined) {
+        parameters[this.gl.TEXTURE_WRAP_S] = this.gl.CLAMP_TO_EDGE;
+      }
 
-  _isNPOT() {
-    if ((0, _gltools.isWebGL2)(this.gl)) {
-      return false;
+      if (parameters[this.gl.TEXTURE_WRAP_T] === undefined) {
+        parameters[this.gl.TEXTURE_WRAP_T] = this.gl.CLAMP_TO_EDGE;
+      }
     }
+  }, {
+    key: "_getNPOTParam",
+    value: function _getNPOTParam(pname, param) {
+      if (this._isNPOT()) {
+        switch (pname) {
+          case _constants.default.TEXTURE_MIN_FILTER:
+            if (NPOT_MIN_FILTERS.indexOf(param) === -1) {
+              param = _constants.default.LINEAR;
+            }
 
-    if (!this.width || !this.height) {
-      return false;
-    }
+            break;
 
-    return !(0, _utils.isPowerOfTwo)(this.width) || !(0, _utils.isPowerOfTwo)(this.height);
-  }
+          case _constants.default.TEXTURE_WRAP_S:
+          case _constants.default.TEXTURE_WRAP_T:
+            if (param !== _constants.default.CLAMP_TO_EDGE) {
+              param = _constants.default.CLAMP_TO_EDGE;
+            }
 
-  _updateForNPOT(parameters) {
-    if (parameters[this.gl.TEXTURE_MIN_FILTER] === undefined) {
-      parameters[this.gl.TEXTURE_MIN_FILTER] = this.gl.LINEAR;
-    }
+            break;
 
-    if (parameters[this.gl.TEXTURE_WRAP_S] === undefined) {
-      parameters[this.gl.TEXTURE_WRAP_S] = this.gl.CLAMP_TO_EDGE;
-    }
+          default:
+            break;
+        }
+      }
 
-    if (parameters[this.gl.TEXTURE_WRAP_T] === undefined) {
-      parameters[this.gl.TEXTURE_WRAP_T] = this.gl.CLAMP_TO_EDGE;
+      return param;
     }
-  }
+  }], [{
+    key: "isSupported",
+    value: function isSupported(device, options) {
+      var webglDevice = _webglDevice.default.attach(device);
 
-  _getNPOTParam(pname, param) {
-    if (this._isNPOT()) {
-      switch (pname) {
-        case _constants.default.TEXTURE_MIN_FILTER:
-          if (NPOT_MIN_FILTERS.indexOf(param) === -1) {
-            param = _constants.default.LINEAR;
-          }
+      var format = options.format,
+          linearFiltering = options.linearFiltering;
+      var supported = true;
 
-          break;
-
-        case _constants.default.TEXTURE_WRAP_S:
-        case _constants.default.TEXTURE_WRAP_T:
-          if (param !== _constants.default.CLAMP_TO_EDGE) {
-            param = _constants.default.CLAMP_TO_EDGE;
-          }
-
-          break;
-
-        default:
-          break;
+      if (format) {
+        supported = supported && (0, _textureFormats.isFormatSupported)(webglDevice.gl, format);
+        supported = supported && (!linearFiltering || (0, _textureFormats.isLinearFilteringSupported)(webglDevice.gl, format));
       }
-    }
 
-    return param;
-  }
-
-}
+      return supported;
+    }
+  }]);
+  return WEBGLTexture;
+}(_api.Texture);
 
 exports.default = WEBGLTexture;
 //# sourceMappingURL=texture.js.map