@luma.gl/webgl 8.6.0-alpha.5 → 9.0.0-alpha.4

package/dist/es5/{classes/texture.js → adapter/resources/webgl-texture.js}

@@ -7,8 +7,14 @@ Object.defineProperty(exports, "__esModule", {
 });
 exports.default = void 0;
 
+var _regenerator = _interopRequireDefault(require("@babel/runtime/regenerator"));
+
+var _asyncToGenerator2 = _interopRequireDefault(require("@babel/runtime/helpers/asyncToGenerator"));
+
 var _slicedToArray2 = _interopRequireDefault(require("@babel/runtime/helpers/slicedToArray"));
 
+var _typeof2 = _interopRequireDefault(require("@babel/runtime/helpers/typeof"));
+
 var _classCallCheck2 = _interopRequireDefault(require("@babel/runtime/helpers/classCallCheck"));
 
 var _createClass2 = _interopRequireDefault(require("@babel/runtime/helpers/createClass"));
@@ -27,17 +33,15 @@ var _api = require("@luma.gl/api");
 
 var _constants = _interopRequireDefault(require("@luma.gl/constants"));
 
-var _webglChecks = require("../context/context/webgl-checks");
+var _withParameters = require("../../context/state-tracker/with-parameters");
 
-var _withParameters = require("../context/state-tracker/with-parameters");
+var _textureFormats = require("../converters/texture-formats");
 
-var _constantsToKeys = require("../webgl-utils/constants-to-keys");
-
-var _webglDevice = _interopRequireDefault(require("../adapter/webgl-device"));
+var _samplerParameters = require("../converters/sampler-parameters");
 
 var _webglBuffer = _interopRequireDefault(require("./webgl-buffer"));
 
-var _textureFormats = require("./texture-formats");
+var _webglSampler = _interopRequireDefault(require("./webgl-sampler"));
 
 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; } } }; }
 
@@ -45,60 +49,65 @@ function _unsupportedIterableToArray(o, minLen) { if (!o) return; if (typeof o =
 
 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 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; }
+
+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; }
+
 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$props;
+
     var _this;
 
     (0, _classCallCheck2.default)(this, WEBGLTexture);
-    _this = _super.call(this, _webglDevice.default.attach(device), props);
+    _this = _super.call(this, device, _objectSpread({
+      format: _constants.default.RGBA
+    }, 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), "width", undefined);
+    (0, _defineProperty2.default)((0, _assertThisInitialized2.default)(_this), "height", undefined);
+    (0, _defineProperty2.default)((0, _assertThisInitialized2.default)(_this), "depth", undefined);
     (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), "sampler", 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.device = (0, _api.cast)(device);
     _this.gl = _this.device.gl;
     _this.gl2 = _this.device.gl2;
     _this.handle = _this.props.handle || _this.gl.createTexture();
+    _this.handle.__SPECTOR_Metadata = _objectSpread(_objectSpread({}, _this.props), {}, {
+      data: (0, _typeof2.default)(_this.props.data)
+    });
+    _this.target = getWebGLTextureTarget(_this.props);
+    _this.loaded = false;
+
+    if (typeof ((_this$props = _this.props) === null || _this$props === void 0 ? void 0 : _this$props.data) === 'string') {
+      Object.assign(_this.props, {
+        data: (0, _api.loadImage)(_this.props.data)
+      });
+    }
+
+    _this.initialize(_this.props);
+
+    Object.seal((0, _assertThisInitialized2.default)(_this));
     return _this;
   }
 
@@ -123,6 +132,11 @@ var WEBGLTexture = function (_Texture) {
       var _this2 = this;
 
       var props = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
+
+      if (this.props.dimension === 'cube') {
+        return this.initializeCube(props);
+      }
+
       var data = props.data;
 
       if (data instanceof Promise) {
@@ -145,16 +159,12 @@ var WEBGLTexture = function (_Texture) {
         return this;
       }
 
+      var _props$parameters = props.parameters,
+          parameters = _props$parameters === void 0 ? {} : _props$parameters;
       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,
@@ -176,7 +186,7 @@ var WEBGLTexture = function (_Texture) {
           depth = _props$depth === void 0 ? 0 : _props$depth;
 
       var _this$_deduceParamete = this._deduceParameters({
-        format: format,
+        format: props.format,
         type: type,
         dataFormat: dataFormat,
         compressed: compressed,
@@ -190,13 +200,13 @@ var WEBGLTexture = function (_Texture) {
       compressed = _this$_deduceParamete.compressed;
       dataFormat = _this$_deduceParamete.dataFormat;
       type = _this$_deduceParamete.type;
+      var format = (0, _textureFormats.getWebGLTextureFormat)(this.gl, props.format);
       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)) {
@@ -204,12 +214,10 @@ var WEBGLTexture = function (_Texture) {
         this.gl.bindTexture(this.target, this.handle);
       }
 
-      if (mipmaps && this._isNPOT()) {
-        _api.log.warn("texture: ".concat(this, " is Non-Power-Of-Two, disabling mipmaping"))();
+      if (mipmaps && this.device.isWebGL1 && isNPOT(this.width, this.height)) {
+        _api.log.warn("texture: ".concat(this, " is Non-Power-Of-Two, disabling mipmaps"))();
 
         mipmaps = false;
-
-        this._updateForNPOT(parameters);
       }
 
       this.mipmaps = mipmaps;
@@ -221,18 +229,17 @@ var WEBGLTexture = function (_Texture) {
         format: format,
         type: type,
         dataFormat: dataFormat,
-        border: border,
-        mipmaps: mipmaps,
         parameters: pixelStore,
         compressed: compressed
       });
+      this.setSampler(props.sampler);
+
+      this._setSamplerParameters(parameters);
 
       if (mipmaps) {
         this.generateMipmap();
       }
 
-      this.setParameters(parameters);
-
       if (recreate) {
         this.data = data;
       }
@@ -248,29 +255,46 @@ var WEBGLTexture = function (_Texture) {
       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;
-        }
+    key: "initializeCube",
+    value: function initializeCube(props) {
+      var _this3 = this;
 
-        this.setSubImageData({
-          data: video,
-          parameters: parameters
-        });
+      var _props$mipmaps2 = props.mipmaps,
+          mipmaps = _props$mipmaps2 === void 0 ? true : _props$mipmaps2,
+          _props$parameters2 = props.parameters,
+          parameters = _props$parameters2 === void 0 ? {} : _props$parameters2;
+      this.setCubeMapImageData(props).then(function () {
+        _this3.loaded = true;
 
-        if (this.mipmaps) {
-          this.generateMipmap();
+        if (mipmaps) {
+          _this3.generateMipmap(props);
         }
 
-        this._video.lastTime = video.currentTime;
+        _this3.setSampler(props.sampler);
+
+        _this3._setSamplerParameters(parameters);
+      });
+      return this;
+    }
+  }, {
+    key: "setSampler",
+    value: function setSampler() {
+      var sampler = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
+      var samplerProps;
+
+      if (sampler instanceof _webglSampler.default) {
+        this.sampler = sampler;
+        samplerProps = sampler.props;
+      } else {
+        this.sampler = new _webglSampler.default(this.device, sampler);
+        samplerProps = sampler;
       }
+
+      var parameters = (0, _samplerParameters.convertSamplerParametersToWebGL)(samplerProps);
+
+      this._setSamplerParameters(parameters);
+
+      return this;
     }
   }, {
     key: "resize",
@@ -287,21 +311,45 @@ var WEBGLTexture = function (_Texture) {
           format: this.format,
           type: this.type,
           dataFormat: this.dataFormat,
-          border: this.border,
           mipmaps: mipmaps
         });
       }
 
       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;
+        }
+
+        this.setSubImageData({
+          data: video,
+          parameters: parameters
+        });
+
+        if (this.mipmaps) {
+          this.generateMipmap();
+        }
+
+        this._video.lastTime = video.currentTime;
+      }
+    }
   }, {
     key: "generateMipmap",
     value: function generateMipmap() {
-      var _this3 = this;
+      var _this4 = this;
 
       var params = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
 
-      if (this._isNPOT()) {
+      if (this.device.isWebGL1 && isNPOT(this.width, this.height)) {
         _api.log.warn("texture: ".concat(this, " is Non-Power-Of-Two, disabling mipmaping"))();
 
         return this;
@@ -310,7 +358,7 @@ var WEBGLTexture = function (_Texture) {
       this.mipmaps = true;
       this.gl.bindTexture(this.target, this.handle);
       (0, _withParameters.withParameters)(this.gl, params, function () {
-        _this3.gl.generateMipmap(_this3.target);
+        _this4.gl.generateMipmap(_this4.target);
       });
       this.gl.bindTexture(this.target, null);
       return this;
@@ -318,6 +366,12 @@ var WEBGLTexture = function (_Texture) {
   }, {
     key: "setImageData",
     value: function setImageData(options) {
+      var _this5 = this;
+
+      if (this.props.dimension === '3d') {
+        return this.setImageData3D(options);
+      }
+
       this.trackDeallocatedMemory('Texture');
       var _options$target = options.target,
           target = _options$target === void 0 ? this.target : _options$target,
@@ -327,8 +381,6 @@ var WEBGLTexture = function (_Texture) {
           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,
@@ -351,7 +403,7 @@ var WEBGLTexture = function (_Texture) {
       }
 
       var _this$_deduceParamete2 = this._deduceParameters({
-        format: format,
+        format: this.props.format,
         type: type,
         dataFormat: dataFormat,
         compressed: compressed,
@@ -380,23 +432,23 @@ var WEBGLTexture = function (_Texture) {
       (0, _withParameters.withParameters)(this.gl, parameters, function () {
         switch (dataType) {
           case 'null':
-            gl.texImage2D(target, level, format, width, height, border, dataFormat, type, data);
+            gl.texImage2D(target, level, format, width, height, 0, dataFormat, type, data);
             break;
 
           case 'typed-array':
-            gl.texImage2D(target, level, format, width, height, border, dataFormat, type, data, offset);
+            gl.texImage2D(target, level, format, width, height, 0, dataFormat, type, data, offset);
             break;
 
           case 'buffer':
-            gl2 = (0, _webglChecks.assertWebGL2Context)(gl);
+            gl2 = _this5.device.assertWebGL2();
             gl2.bindBuffer(_constants.default.PIXEL_UNPACK_BUFFER, data.handle || data);
-            gl2.texImage2D(target, level, format, width, height, border, dataFormat, type, offset);
+            gl2.texImage2D(target, level, format, width, height, 0, 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);
+            if (_this5.device.isWebGL2) {
+              gl.texImage2D(target, level, format, width, height, 0, dataFormat, type, data);
             } else {
               gl.texImage2D(target, level, format, dataFormat, type, data);
             }
@@ -413,7 +465,7 @@ var WEBGLTexture = function (_Texture) {
                     levelIndex = _step$value[0],
                     levelData = _step$value[1];
 
-                gl.compressedTexImage2D(target, levelIndex, levelData.format, levelData.width, levelData.height, border, levelData.data);
+                gl.compressedTexImage2D(target, levelIndex, levelData.format, levelData.width, levelData.height, 0, levelData.data);
               }
             } catch (err) {
               _iterator.e(err);
@@ -431,9 +483,8 @@ var WEBGLTexture = function (_Texture) {
       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');
+        var bytesPerPixel = (0, _textureFormats.getTextureFormatBytesPerPixel)(this.gl, this.props.format);
+        this.trackAllocatedMemory(this.width * this.height * bytesPerPixel, 'Texture');
       }
 
       this.loaded = true;
@@ -442,7 +493,7 @@ var WEBGLTexture = function (_Texture) {
   }, {
     key: "setSubImageData",
     value: function setSubImageData(_ref2) {
-      var _this4 = this;
+      var _this6 = this;
 
       var _ref2$target = _ref2.target,
           target = _ref2$target === void 0 ? this.target : _ref2$target,
@@ -470,13 +521,11 @@ var WEBGLTexture = function (_Texture) {
           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,
+        format: this.props.format,
         type: type,
         dataFormat: dataFormat,
         compressed: compressed,
@@ -490,7 +539,7 @@ var WEBGLTexture = function (_Texture) {
       compressed = _this$_deduceParamete3.compressed;
       width = _this$_deduceParamete3.width;
       height = _this$_deduceParamete3.height;
-      (0, _api.assert)(this.depth === 0, 'texSubImage not supported for 3D textures');
+      (0, _api.assert)(this.depth === 1, 'texSubImage not supported for 3D textures');
 
       if (!data) {
         data = pixels;
@@ -510,22 +559,23 @@ var WEBGLTexture = function (_Texture) {
       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);
+          _this6.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);
+          _this6.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);
+          _this6.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);
+          var gl2 = _this6.device.assertWebGL2();
+
           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);
+        } else if (_this6.device.isWebGL2) {
+          var _gl = _this6.device.assertWebGL2();
 
           _gl.texSubImage2D(target, level, x, y, width, height, dataFormat, type, data);
         } else {
-          _this4.gl.texSubImage2D(target, level, x, y, dataFormat, type, data);
+          _this6.gl.texSubImage2D(target, level, x, y, dataFormat, type, data);
         }
       });
       this.gl.bindTexture(this.target, null);
@@ -629,10 +679,10 @@ var WEBGLTexture = function (_Texture) {
           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 parameters = (0, _textureFormats.getWebGLTextureParameters)(this.gl, format);
+      dataFormat = dataFormat || parameters.dataFormat;
+      type = type || parameters.type;
+      compressed = compressed || parameters.compressed;
 
       var _this$_deduceImageSiz = this._deduceImageSize(data, width, height);
 
@@ -696,215 +746,241 @@ var WEBGLTexture = function (_Texture) {
       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;
-        }
-      }
-
-      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]);
+    key: "setCubeMapImageData",
+    value: function () {
+      var _setCubeMapImageData = (0, _asyncToGenerator2.default)(_regenerator.default.mark(function _callee(options) {
+        var _this7 = this;
+
+        var gl, width, height, pixels, data, _options$format2, format, _options$type2, type, imageDataMap, resolvedFaces;
+
+        return _regenerator.default.wrap(function _callee$(_context) {
+          while (1) {
+            switch (_context.prev = _context.next) {
+              case 0:
+                gl = this.gl;
+                width = options.width, height = options.height, pixels = options.pixels, data = options.data, _options$format2 = options.format, format = _options$format2 === void 0 ? _constants.default.RGBA : _options$format2, _options$type2 = options.type, type = _options$type2 === void 0 ? _constants.default.UNSIGNED_BYTE : _options$type2;
+                imageDataMap = pixels || data;
+                _context.next = 5;
+                return Promise.all(WEBGLTexture.FACES.map(function (face) {
+                  var facePixels = imageDataMap[face];
+                  return Promise.all(Array.isArray(facePixels) ? facePixels : [facePixels]);
+                }));
+
+              case 5:
+                resolvedFaces = _context.sent;
+                this.bind();
+                WEBGLTexture.FACES.forEach(function (face, index) {
+                  if (resolvedFaces[index].length > 1 && _this7.props.mipmaps !== false) {
+                    _api.log.warn("".concat(_this7.id, " has mipmap and multiple LODs."))();
+                  }
+
+                  resolvedFaces[index].forEach(function (image, lodLevel) {
+                    if (width && height) {
+                      gl.texImage2D(face, lodLevel, format, width, height, 0, format, type, image);
+                    } else {
+                      gl.texImage2D(face, lodLevel, format, format, type, image);
+                    }
+                  });
+                });
+                this.unbind();
+
+              case 9:
+              case "end":
+                return _context.stop();
             }
           }
-        }
-      } catch (err) {
-        _iterator2.e(err);
-      } finally {
-        _iterator2.f();
-      }
+        }, _callee, this);
+      }));
 
-      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];
-
-      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) {
-          throw new Error('Parameter not available on this platform');
-        }
-
-        if (parameter.type === 'GLenum') {
-          value = (0, _constantsToKeys.getKeyValue)(value);
-        }
+      function setCubeMapImageData(_x) {
+        return _setCubeMapImageData.apply(this, arguments);
       }
 
-      this._setParameter(pname, value);
-
-      return this;
-    }
+      return setCubeMapImageData;
+    }()
   }, {
-    key: "setParameters",
-    value: function setParameters(parameters) {
-      for (var pname in parameters) {
-        this.setParameter(pname, parameters[pname]);
+    key: "setImageDataForFace",
+    value: function setImageDataForFace(options) {
+      var _this8 = this;
+
+      var face = options.face,
+          width = options.width,
+          height = options.height,
+          pixels = options.pixels,
+          data = options.data,
+          _options$format3 = options.format,
+          format = _options$format3 === void 0 ? _constants.default.RGBA : _options$format3,
+          _options$type3 = options.type,
+          type = _options$type3 === void 0 ? _constants.default.UNSIGNED_BYTE : _options$type3;
+      var gl = this.gl;
+      var imageData = pixels || data;
+      this.bind();
+
+      if (imageData instanceof Promise) {
+        imageData.then(function (resolvedImageData) {
+          return _this8.setImageDataForFace(Object.assign({}, options, {
+            face: face,
+            data: resolvedImageData,
+            pixels: resolvedImageData
+          }));
+        });
+      } else if (this.width || this.height) {
+        gl.texImage2D(face, 0, format, width, height, 0, format, type, imageData);
+      } else {
+        gl.texImage2D(face, 0, format, format, type, imageData);
       }
 
       return this;
     }
   }, {
-    key: "_getParameter",
-    value: function _getParameter(pname, props) {
-      switch (pname) {
-        case _constants.default.TEXTURE_WIDTH:
-          return this.width;
-
-        case _constants.default.TEXTURE_HEIGHT:
-          return this.height;
-
-        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) {
+    key: "setImageData3D",
+    value: function setImageData3D(_ref4) {
+      var _this9 = this;
+
+      var _ref4$level = _ref4.level,
+          level = _ref4$level === void 0 ? 0 : _ref4$level,
+          dataFormat = _ref4.dataFormat,
+          format = _ref4.format,
+          type = _ref4.type,
+          width = _ref4.width,
+          height = _ref4.height,
+          _ref4$depth = _ref4.depth,
+          depth = _ref4$depth === void 0 ? 1 : _ref4$depth,
+          _ref4$offset = _ref4.offset,
+          offset = _ref4$offset === void 0 ? 0 : _ref4$offset,
+          data = _ref4.data,
+          _ref4$parameters = _ref4.parameters,
+          parameters = _ref4$parameters === void 0 ? {} : _ref4$parameters;
+      this.trackDeallocatedMemory('Texture');
       this.gl.bindTexture(this.target, this.handle);
-      param = this._getNPOTParam(pname, param);
+      var webglTextureFormat = (0, _textureFormats.getWebGLTextureParameters)(this.gl, format);
+      (0, _withParameters.withParameters)(this.gl, parameters, function () {
+        if (ArrayBuffer.isView(data)) {
+          _this9.gl.texImage3D(_this9.target, level, webglTextureFormat.format, width, height, depth, 0, webglTextureFormat.dataFormat, webglTextureFormat.type, data);
+        }
 
-      switch (pname) {
-        case _constants.default.TEXTURE_MIN_LOD:
-        case _constants.default.TEXTURE_MAX_LOD:
-          this.gl.texParameterf(this.target, pname, param);
-          break;
+        if (data instanceof _webglBuffer.default) {
+          _this9.gl.bindBuffer(_constants.default.PIXEL_UNPACK_BUFFER, data.handle);
 
-        case _constants.default.TEXTURE_WIDTH:
-        case _constants.default.TEXTURE_HEIGHT:
-          (0, _api.assert)(false);
-          break;
+          _this9.gl.texImage3D(_this9.target, level, dataFormat, width, height, depth, 0, format, type, offset);
+        }
+      });
 
-        default:
-          this.gl.texParameteri(this.target, pname, param);
-          break;
+      if (data && data.byteLength) {
+        this.trackAllocatedMemory(data.byteLength, 'Texture');
+      } else {
+        var bytesPerPixel = (0, _textureFormats.getTextureFormatBytesPerPixel)(this.gl, this.props.format);
+        this.trackAllocatedMemory(this.width * this.height * this.depth * bytesPerPixel, 'Texture');
       }
 
-      this.gl.bindTexture(this.target, null);
+      this.loaded = true;
       return this;
     }
   }, {
-    key: "_isNPOT",
-    value: function _isNPOT() {
-      if ((0, _webglChecks.isWebGL2)(this.gl)) {
-        return false;
+    key: "_setSamplerParameters",
+    value: function _setSamplerParameters(parameters) {
+      if (this.device.isWebGL1 && isNPOT(this.width, this.height)) {
+        parameters = (0, _samplerParameters.updateSamplerParametersForNPOT)(parameters);
       }
 
-      if (!this.width || !this.height) {
-        return false;
+      if ((0, _api.isObjectEmpty)(parameters)) {
+        return;
       }
 
-      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;
-      }
+      logParameters(parameters);
+      this.gl.bindTexture(this.target, this.handle);
 
-      if (parameters[this.gl.TEXTURE_WRAP_S] === undefined) {
-        parameters[this.gl.TEXTURE_WRAP_S] = this.gl.CLAMP_TO_EDGE;
-      }
+      for (var _i = 0, _Object$entries = Object.entries(parameters); _i < _Object$entries.length; _i++) {
+        var _Object$entries$_i = (0, _slicedToArray2.default)(_Object$entries[_i], 2),
+            pname = _Object$entries$_i[0],
+            pvalue = _Object$entries$_i[1];
 
-      if (parameters[this.gl.TEXTURE_WRAP_T] === undefined) {
-        parameters[this.gl.TEXTURE_WRAP_T] = this.gl.CLAMP_TO_EDGE;
+        var param = Number(pname);
+        var value = pvalue;
+
+        switch (param) {
+          case _constants.default.TEXTURE_MIN_LOD:
+          case _constants.default.TEXTURE_MAX_LOD:
+            this.gl.texParameterf(this.target, param, value);
+            break;
+
+          default:
+            this.gl.texParameteri(this.target, param, value);
+            break;
+        }
       }
+
+      this.gl.bindTexture(this.target, null);
+      return this;
     }
   }, {
-    key: "_getNPOTParam",
-    value: function _getNPOTParam(pname, param) {
-      if (this._isNPOT()) {
+    key: "_getWebGL1NPOTParameterOverride",
+    value: function _getWebGL1NPOTParameterOverride(pname, value) {
+      var npot = this.device.isWebGL1 && isNPOT(this.width, this.height);
+
+      if (npot) {
         switch (pname) {
           case _constants.default.TEXTURE_MIN_FILTER:
-            if (NPOT_MIN_FILTERS.indexOf(param) === -1) {
-              param = _constants.default.LINEAR;
+            if (value !== _constants.default.LINEAR && value !== _constants.default.NEAREST) {
+              return _constants.default.LINEAR;
             }
 
             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;
+            return _constants.default.CLAMP_TO_EDGE;
 
           default:
             break;
         }
       }
 
-      return param;
-    }
-  }], [{
-    key: "isSupported",
-    value: function isSupported(device, options) {
-      var webglDevice = _webglDevice.default.attach(device);
-
-      var format = options.format,
-          linearFiltering = options.linearFiltering;
-      var supported = true;
-
-      if (format) {
-        supported = supported && (0, _textureFormats.isFormatSupported)(webglDevice.gl, format);
-        supported = supported && (!linearFiltering || (0, _textureFormats.isLinearFilteringSupported)(webglDevice.gl, format));
-      }
-
-      return supported;
+      return value;
     }
   }]);
   return WEBGLTexture;
 }(_api.Texture);
 
 exports.default = WEBGLTexture;
-//# sourceMappingURL=texture.js.map
+(0, _defineProperty2.default)(WEBGLTexture, "FACES", [_constants.default.TEXTURE_CUBE_MAP_POSITIVE_X, _constants.default.TEXTURE_CUBE_MAP_NEGATIVE_X, _constants.default.TEXTURE_CUBE_MAP_POSITIVE_Y, _constants.default.TEXTURE_CUBE_MAP_NEGATIVE_Y, _constants.default.TEXTURE_CUBE_MAP_POSITIVE_Z, _constants.default.TEXTURE_CUBE_MAP_NEGATIVE_Z]);
+
+function getWebGLTextureTarget(props) {
+  switch (props.dimension) {
+    case '2d':
+      return _constants.default.TEXTURE_2D;
+
+    case 'cube':
+      return _constants.default.TEXTURE_CUBE_MAP;
+
+    case '2d-array':
+      return _constants.default.TEXTURE_2D_ARRAY;
+
+    case '3d':
+      return _constants.default.TEXTURE_3D;
+
+    case '1d':
+    case 'cube-array':
+    default:
+      throw new Error(props.dimension);
+  }
+}
+
+function isNPOT(width, height) {
+  if (!width || !height) {
+    return false;
+  }
+
+  return !(0, _api.isPowerOfTwo)(width) || !(0, _api.isPowerOfTwo)(height);
+}
+
+function logParameters(parameters) {
+  _api.log.log(1, 'texture sampler parameters', parameters)();
+
+  for (var _i2 = 0, _Object$entries2 = Object.entries(parameters); _i2 < _Object$entries2.length; _i2++) {
+    var _Object$entries2$_i = (0, _slicedToArray2.default)(_Object$entries2[_i2], 2),
+        pname = _Object$entries2$_i[0],
+        pvalue = _Object$entries2$_i[1];
+  }
+}
+//# sourceMappingURL=webgl-texture.js.map