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

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

@@ -1,33 +1,20 @@
 import _defineProperty from "@babel/runtime/helpers/esm/defineProperty";
-import { log, assert, uid, isPowerOfTwo } from '@luma.gl/api';
-import { Texture } from '@luma.gl/api';
+import { isObjectEmpty } from '@luma.gl/api';
+import { Texture, cast, log, assert, isPowerOfTwo, loadImage } from '@luma.gl/api';
 import GL from '@luma.gl/constants';
-import { isWebGL2, assertWebGL2Context } from '../context/context/webgl-checks';
-import { withParameters } from '../context/state-tracker/with-parameters';
-import { getKey, getKeyValue } from '../webgl-utils/constants-to-keys';
-import WebGLDevice from '../adapter/webgl-device';
-import Buffer from './webgl-buffer';
-import { TEXTURE_FORMATS, DATA_FORMAT_CHANNELS, TYPE_SIZES, isFormatSupported, isLinearFilteringSupported } from './texture-formats';
-const NPOT_MIN_FILTERS = [GL.LINEAR, GL.NEAREST];
+import { withParameters } from '../../context/state-tracker/with-parameters';
+import { getWebGLTextureFormat, getWebGLTextureParameters, getTextureFormatBytesPerPixel } from '../converters/texture-formats';
+import { convertSamplerParametersToWebGL, updateSamplerParametersForNPOT } from '../converters/sampler-parameters';
+import WEBGLBuffer from './webgl-buffer';
+import WEBGLSampler from './webgl-sampler';
 export default class WEBGLTexture extends Texture {
-  static isSupported(device, options) {
-    const webglDevice = WebGLDevice.attach(device);
-    const {
-      format,
-      linearFiltering
-    } = options;
-    let supported = true;
-
-    if (format) {
-      supported = supported && isFormatSupported(webglDevice.gl, format);
-      supported = supported && (!linearFiltering || isLinearFilteringSupported(webglDevice.gl, format));
-    }
-
-    return supported;
-  }
-
   constructor(device, props) {
-    super(WebGLDevice.attach(device), props);
+    var _this$props;
+
+    super(device, {
+      format: GL.RGBA,
+      ...props
+    });
 
     _defineProperty(this, "MAX_ATTRIBUTES", void 0);
 
@@ -41,11 +28,11 @@ export default class WEBGLTexture extends Texture {
 
     _defineProperty(this, "data", void 0);
 
-    _defineProperty(this, "width", void 0);
+    _defineProperty(this, "width", undefined);
 
-    _defineProperty(this, "height", void 0);
+    _defineProperty(this, "height", undefined);
 
-    _defineProperty(this, "depth", void 0);
+    _defineProperty(this, "depth", undefined);
 
     _defineProperty(this, "format", undefined);
 
@@ -53,39 +40,36 @@ export default class WEBGLTexture extends Texture {
 
     _defineProperty(this, "dataFormat", undefined);
 
-    _defineProperty(this, "border", undefined);
-
     _defineProperty(this, "mipmaps", undefined);
 
     _defineProperty(this, "target", void 0);
 
     _defineProperty(this, "textureUnit", undefined);
 
+    _defineProperty(this, "sampler", undefined);
+
     _defineProperty(this, "loaded", false);
 
     _defineProperty(this, "_video", void 0);
 
-    const {
-      id = 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.device = WebGLDevice.attach(device);
+    this.device = cast(device);
     this.gl = this.device.gl;
     this.gl2 = this.device.gl2;
     this.handle = this.props.handle || this.gl.createTexture();
+    this.handle.__SPECTOR_Metadata = { ...this.props,
+      data: typeof 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: loadImage(this.props.data)
+      });
+    }
+
+    this.initialize(this.props);
+    Object.seal(this);
   }
 
   destroy() {
@@ -102,6 +86,10 @@ export default class WEBGLTexture extends Texture {
   }
 
   initialize(props = {}) {
+    if (this.props.dimension === 'cube') {
+      return this.initializeCube(props);
+    }
+
     let data = props.data;
 
     if (data instanceof Promise) {
@@ -120,12 +108,12 @@ export default class WEBGLTexture extends Texture {
       return this;
     }
 
+    let {
+      parameters = {}
+    } = props;
     const {
       pixels = null,
-      format = GL.RGBA,
-      border = 0,
       recreate = false,
-      parameters = {},
       pixelStore = {},
       textureUnit = undefined
     } = props;
@@ -152,7 +140,7 @@ export default class WEBGLTexture extends Texture {
       dataFormat,
       type
     } = this._deduceParameters({
-      format,
+      format: props.format,
       type,
       dataFormat,
       compressed,
@@ -160,13 +148,13 @@ export default class WEBGLTexture extends Texture {
       width,
       height
     }));
+    const format = 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)) {
@@ -174,11 +162,9 @@ export default class WEBGLTexture extends Texture {
       this.gl.bindTexture(this.target, this.handle);
     }
 
-    if (mipmaps && this._isNPOT()) {
-      log.warn("texture: ".concat(this, " is Non-Power-Of-Two, disabling mipmaping"))();
+    if (mipmaps && this.device.isWebGL1 && isNPOT(this.width, this.height)) {
+      log.warn("texture: ".concat(this, " is Non-Power-Of-Two, disabling mipmaps"))();
       mipmaps = false;
-
-      this._updateForNPOT(parameters);
     }
 
     this.mipmaps = mipmaps;
@@ -190,18 +176,17 @@ export default class WEBGLTexture extends Texture {
       format,
       type,
       dataFormat,
-      border,
-      mipmaps,
       parameters: pixelStore,
       compressed
     });
+    this.setSampler(props.sampler);
+
+    this._setSamplerParameters(parameters);
 
     if (mipmaps) {
       this.generateMipmap();
     }
 
-    this.setParameters(parameters);
-
     if (recreate) {
       this.data = data;
     }
@@ -217,29 +202,41 @@ export default class WEBGLTexture extends Texture {
     return this;
   }
 
-  update() {
-    if (this._video) {
-      const {
-        video,
-        parameters,
-        lastTime
-      } = this._video;
+  initializeCube(props) {
+    const {
+      mipmaps = true,
+      parameters = {}
+    } = props;
+    this.setCubeMapImageData(props).then(() => {
+      this.loaded = true;
 
-      if (lastTime === video.currentTime || video.readyState < HTMLVideoElement.HAVE_CURRENT_DATA) {
-        return;
+      if (mipmaps) {
+        this.generateMipmap(props);
       }
 
-      this.setSubImageData({
-        data: video,
-        parameters
-      });
+      this.setSampler(props.sampler);
 
-      if (this.mipmaps) {
-        this.generateMipmap();
-      }
+      this._setSamplerParameters(parameters);
+    });
+    return this;
+  }
 
-      this._video.lastTime = video.currentTime;
+  setSampler(sampler = {}) {
+    let samplerProps;
+
+    if (sampler instanceof WEBGLSampler) {
+      this.sampler = sampler;
+      samplerProps = sampler.props;
+    } else {
+      this.sampler = new WEBGLSampler(this.device, sampler);
+      samplerProps = sampler;
     }
+
+    const parameters = convertSamplerParametersToWebGL(samplerProps);
+
+    this._setSamplerParameters(parameters);
+
+    return this;
   }
 
   resize({
@@ -254,7 +251,6 @@ export default class WEBGLTexture extends Texture {
         format: this.format,
         type: this.type,
         dataFormat: this.dataFormat,
-        border: this.border,
         mipmaps
       });
     }
@@ -262,8 +258,33 @@ export default class WEBGLTexture extends Texture {
     return this;
   }
 
+  update() {
+    if (this._video) {
+      const {
+        video,
+        parameters,
+        lastTime
+      } = this._video;
+
+      if (lastTime === video.currentTime || video.readyState < HTMLVideoElement.HAVE_CURRENT_DATA) {
+        return;
+      }
+
+      this.setSubImageData({
+        data: video,
+        parameters
+      });
+
+      if (this.mipmaps) {
+        this.generateMipmap();
+      }
+
+      this._video.lastTime = video.currentTime;
+    }
+  }
+
   generateMipmap(params = {}) {
-    if (this._isNPOT()) {
+    if (this.device.isWebGL1 && isNPOT(this.width, this.height)) {
       log.warn("texture: ".concat(this, " is Non-Power-Of-Two, disabling mipmaping"))();
       return this;
     }
@@ -278,13 +299,16 @@ export default class WEBGLTexture extends Texture {
   }
 
   setImageData(options) {
+    if (this.props.dimension === '3d') {
+      return this.setImageData3D(options);
+    }
+
     this.trackDeallocatedMemory('Texture');
     const {
       target = this.target,
       pixels = null,
       level = 0,
       format = this.format,
-      border = this.border,
       offset = 0,
       parameters = {}
     } = options;
@@ -308,7 +332,7 @@ export default class WEBGLTexture extends Texture {
       width,
       height
     } = this._deduceParameters({
-      format,
+      format: this.props.format,
       type,
       dataFormat,
       compressed,
@@ -332,23 +356,23 @@ export default class WEBGLTexture extends Texture {
     withParameters(this.gl, parameters, () => {
       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 = assertWebGL2Context(gl);
+          gl2 = this.device.assertWebGL2();
           gl2.bindBuffer(GL.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(GL.PIXEL_UNPACK_BUFFER, null);
           break;
 
         case 'browser-object':
-          if (isWebGL2(gl)) {
-            gl.texImage2D(target, level, format, width, height, border, dataFormat, type, data);
+          if (this.device.isWebGL2) {
+            gl.texImage2D(target, level, format, width, height, 0, dataFormat, type, data);
           } else {
             gl.texImage2D(target, level, format, dataFormat, type, data);
           }
@@ -357,7 +381,7 @@ export default class WEBGLTexture extends Texture {
 
         case 'compressed':
           for (const [levelIndex, levelData] of data.entries()) {
-            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);
           }
 
           break;
@@ -370,9 +394,8 @@ export default class WEBGLTexture extends Texture {
     if (data && data.byteLength) {
       this.trackAllocatedMemory(data.byteLength, 'Texture');
     } else {
-      const channels = DATA_FORMAT_CHANNELS[this.dataFormat] || 4;
-      const channelSize = TYPE_SIZES[this.type] || 1;
-      this.trackAllocatedMemory(this.width * this.height * channels * channelSize, 'Texture');
+      const bytesPerPixel = getTextureFormatBytesPerPixel(this.gl, this.props.format);
+      this.trackAllocatedMemory(this.width * this.height * bytesPerPixel, 'Texture');
     }
 
     this.loaded = true;
@@ -393,7 +416,6 @@ export default class WEBGLTexture extends Texture {
     dataFormat = this.dataFormat,
     compressed = false,
     offset = 0,
-    border = this.border,
     parameters = {}
   }) {
     ({
@@ -403,7 +425,7 @@ export default class WEBGLTexture extends Texture {
       width,
       height
     } = this._deduceParameters({
-      format,
+      format: this.props.format,
       type,
       dataFormat,
       compressed,
@@ -411,7 +433,7 @@ export default class WEBGLTexture extends Texture {
       width,
       height
     }));
-    assert(this.depth === 0, 'texSubImage not supported for 3D textures');
+    assert(this.depth === 1, 'texSubImage not supported for 3D textures');
 
     if (!data) {
       data = pixels;
@@ -424,7 +446,7 @@ export default class WEBGLTexture extends Texture {
       height = ndarray.shape[1];
     }
 
-    if (data instanceof Buffer) {
+    if (data instanceof WEBGLBuffer) {
       data = data.handle;
     }
 
@@ -437,12 +459,12 @@ export default class WEBGLTexture extends Texture {
       } else if (ArrayBuffer.isView(data)) {
         this.gl.texSubImage2D(target, level, x, y, width, height, dataFormat, type, data, offset);
       } else if (typeof WebGLBuffer !== 'undefined' && data instanceof WebGLBuffer) {
-        const gl2 = assertWebGL2Context(this.gl);
+        const gl2 = this.device.assertWebGL2();
         gl2.bindBuffer(GL.PIXEL_UNPACK_BUFFER, data);
         gl2.texSubImage2D(target, level, x, y, width, height, dataFormat, type, offset);
         gl2.bindBuffer(GL.PIXEL_UNPACK_BUFFER, null);
-      } else if (isWebGL2(this.gl)) {
-        const gl2 = assertWebGL2Context(this.gl);
+      } else if (this.device.isWebGL2) {
+        const gl2 = this.device.assertWebGL2();
         gl2.texSubImage2D(target, level, x, y, width, height, dataFormat, type, data);
       } else {
         this.gl.texSubImage2D(target, level, x, y, dataFormat, type, data);
@@ -513,7 +535,7 @@ export default class WEBGLTexture extends Texture {
       };
     }
 
-    if (data instanceof Buffer) {
+    if (data instanceof WEBGLBuffer) {
       return {
         data: data.handle,
         dataType: 'buffer'
@@ -545,10 +567,10 @@ export default class WEBGLTexture extends Texture {
       type,
       compressed
     } = opts;
-    const textureFormat = TEXTURE_FORMATS[format];
-    dataFormat = dataFormat || textureFormat && textureFormat.dataFormat;
-    type = type || textureFormat && textureFormat.types[0];
-    compressed = compressed || textureFormat && textureFormat.compressed;
+    const parameters = getWebGLTextureParameters(this.gl, format);
+    dataFormat = dataFormat || parameters.dataFormat;
+    type = type || parameters.type;
+    compressed = compressed || parameters.compressed;
     ({
       width,
       height
@@ -610,177 +632,200 @@ export default class WEBGLTexture extends Texture {
     return size;
   }
 
-  getParameter(pname, props = {}) {
-    pname = getKeyValue(this.gl, pname);
-    assert(pname);
-    const parameters = this.constructor.PARAMETERS || {};
-    const parameter = parameters[pname];
-
-    if (parameter) {
-      const isWebgl2 = 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;
+  async setCubeMapImageData(options) {
+    const {
+      gl
+    } = this;
+    const {
+      width,
+      height,
+      pixels,
+      data,
+      format = GL.RGBA,
+      type = GL.UNSIGNED_BYTE
+    } = options;
+    const imageDataMap = pixels || data;
+    const resolvedFaces = await Promise.all(WEBGLTexture.FACES.map(face => {
+      const facePixels = imageDataMap[face];
+      return Promise.all(Array.isArray(facePixels) ? facePixels : [facePixels]);
+    }));
+    this.bind();
+    WEBGLTexture.FACES.forEach((face, index) => {
+      if (resolvedFaces[index].length > 1 && this.props.mipmaps !== false) {
+        log.warn("".concat(this.id, " has mipmap and multiple LODs."))();
       }
-    }
 
-    return this._getParameter(pname, props);
+      resolvedFaces[index].forEach((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();
   }
 
-  getParameters(options = {}) {
+  setImageDataForFace(options) {
     const {
-      parameters,
-      keys
+      face,
+      width,
+      height,
+      pixels,
+      data,
+      format = GL.RGBA,
+      type = GL.UNSIGNED_BYTE
     } = options;
-    const PARAMETERS = this.constructor.PARAMETERS || {};
-    const isWebgl2 = 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 ? getKey(this.gl, pname) : pname;
-        values[key] = this.getParameter(pname, options);
-
-        if (keys && parameter.type === 'GLenum') {
-          values[key] = getKey(this.gl, values[key]);
-        }
-      }
+    const {
+      gl
+    } = this;
+    const imageData = pixels || data;
+    this.bind();
+
+    if (imageData instanceof Promise) {
+      imageData.then(resolvedImageData => this.setImageDataForFace(Object.assign({}, options, {
+        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 values;
+    return this;
   }
 
-  setParameter(pname, value) {
-    pname = getKeyValue(this.gl, pname);
-    assert(pname);
-    const parameters = this.constructor.PARAMETERS || {};
-    const parameter = parameters[pname];
-
-    if (parameter) {
-      const isWebgl2 = 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');
+  setImageData3D({
+    level = 0,
+    dataFormat,
+    format,
+    type,
+    width,
+    height,
+    depth = 1,
+    offset = 0,
+    data,
+    parameters = {}
+  }) {
+    this.trackDeallocatedMemory('Texture');
+    this.gl.bindTexture(this.target, this.handle);
+    const webglTextureFormat = getWebGLTextureParameters(this.gl, format);
+    withParameters(this.gl, parameters, () => {
+      if (ArrayBuffer.isView(data)) {
+        this.gl.texImage3D(this.target, level, webglTextureFormat.format, width, height, depth, 0, webglTextureFormat.dataFormat, webglTextureFormat.type, data);
       }
 
-      if (parameter.type === 'GLenum') {
-        value = getKeyValue(value);
+      if (data instanceof WEBGLBuffer) {
+        this.gl.bindBuffer(GL.PIXEL_UNPACK_BUFFER, data.handle);
+        this.gl.texImage3D(this.target, level, dataFormat, width, height, depth, 0, format, type, offset);
       }
-    }
-
-    this._setParameter(pname, value);
-
-    return this;
-  }
+    });
 
-  setParameters(parameters) {
-    for (const pname in parameters) {
-      this.setParameter(pname, parameters[pname]);
+    if (data && data.byteLength) {
+      this.trackAllocatedMemory(data.byteLength, 'Texture');
+    } else {
+      const bytesPerPixel = getTextureFormatBytesPerPixel(this.gl, this.props.format);
+      this.trackAllocatedMemory(this.width * this.height * this.depth * bytesPerPixel, 'Texture');
     }
 
+    this.loaded = true;
     return this;
   }
 
-  _getParameter(pname, props) {
-    switch (pname) {
-      case GL.TEXTURE_WIDTH:
-        return this.width;
-
-      case GL.TEXTURE_HEIGHT:
-        return this.height;
+  _setSamplerParameters(parameters) {
+    if (this.device.isWebGL1 && isNPOT(this.width, this.height)) {
+      parameters = updateSamplerParametersForNPOT(parameters);
+    }
 
-      default:
-        this.gl.bindTexture(this.target, this.handle);
-        const value = this.gl.getTexParameter(this.target, pname);
-        this.gl.bindTexture(this.target, null);
-        return value;
+    if (isObjectEmpty(parameters)) {
+      return;
     }
-  }
 
-  _setParameter(pname, param) {
+    logParameters(parameters);
     this.gl.bindTexture(this.target, this.handle);
-    param = this._getNPOTParam(pname, param);
 
-    switch (pname) {
-      case GL.TEXTURE_MIN_LOD:
-      case GL.TEXTURE_MAX_LOD:
-        this.gl.texParameterf(this.target, pname, param);
-        break;
+    for (const [pname, pvalue] of Object.entries(parameters)) {
+      const param = Number(pname);
+      let value = pvalue;
 
-      case GL.TEXTURE_WIDTH:
-      case GL.TEXTURE_HEIGHT:
-        assert(false);
-        break;
+      switch (param) {
+        case GL.TEXTURE_MIN_LOD:
+        case GL.TEXTURE_MAX_LOD:
+          this.gl.texParameterf(this.target, param, value);
+          break;
 
-      default:
-        this.gl.texParameteri(this.target, pname, param);
-        break;
+        default:
+          this.gl.texParameteri(this.target, param, value);
+          break;
+      }
     }
 
     this.gl.bindTexture(this.target, null);
     return this;
   }
 
-  _isNPOT() {
-    if (isWebGL2(this.gl)) {
-      return false;
-    }
-
-    if (!this.width || !this.height) {
-      return false;
-    }
-
-    return !isPowerOfTwo(this.width) || !isPowerOfTwo(this.height);
-  }
-
-  _updateForNPOT(parameters) {
-    if (parameters[this.gl.TEXTURE_MIN_FILTER] === undefined) {
-      parameters[this.gl.TEXTURE_MIN_FILTER] = this.gl.LINEAR;
-    }
-
-    if (parameters[this.gl.TEXTURE_WRAP_S] === undefined) {
-      parameters[this.gl.TEXTURE_WRAP_S] = this.gl.CLAMP_TO_EDGE;
-    }
-
-    if (parameters[this.gl.TEXTURE_WRAP_T] === undefined) {
-      parameters[this.gl.TEXTURE_WRAP_T] = this.gl.CLAMP_TO_EDGE;
-    }
-  }
+  _getWebGL1NPOTParameterOverride(pname, value) {
+    const npot = this.device.isWebGL1 && isNPOT(this.width, this.height);
 
-  _getNPOTParam(pname, param) {
-    if (this._isNPOT()) {
+    if (npot) {
       switch (pname) {
         case GL.TEXTURE_MIN_FILTER:
-          if (NPOT_MIN_FILTERS.indexOf(param) === -1) {
-            param = GL.LINEAR;
+          if (value !== GL.LINEAR && value !== GL.NEAREST) {
+            return GL.LINEAR;
           }
 
           break;
 
         case GL.TEXTURE_WRAP_S:
         case GL.TEXTURE_WRAP_T:
-          if (param !== GL.CLAMP_TO_EDGE) {
-            param = GL.CLAMP_TO_EDGE;
-          }
-
-          break;
+          return GL.CLAMP_TO_EDGE;
 
         default:
           break;
       }
     }
 
-    return param;
+    return value;
+  }
+
+}
+
+_defineProperty(WEBGLTexture, "FACES", [GL.TEXTURE_CUBE_MAP_POSITIVE_X, GL.TEXTURE_CUBE_MAP_NEGATIVE_X, GL.TEXTURE_CUBE_MAP_POSITIVE_Y, GL.TEXTURE_CUBE_MAP_NEGATIVE_Y, GL.TEXTURE_CUBE_MAP_POSITIVE_Z, GL.TEXTURE_CUBE_MAP_NEGATIVE_Z]);
+
+function getWebGLTextureTarget(props) {
+  switch (props.dimension) {
+    case '2d':
+      return GL.TEXTURE_2D;
+
+    case 'cube':
+      return GL.TEXTURE_CUBE_MAP;
+
+    case '2d-array':
+      return GL.TEXTURE_2D_ARRAY;
+
+    case '3d':
+      return GL.TEXTURE_3D;
+
+    case '1d':
+    case 'cube-array':
+    default:
+      throw new Error(props.dimension);
   }
+}
+
+function isNPOT(width, height) {
+  if (!width || !height) {
+    return false;
+  }
+
+  return !isPowerOfTwo(width) || !isPowerOfTwo(height);
+}
+
+function logParameters(parameters) {
+  log.log(1, 'texture sampler parameters', parameters)();
 
+  for (const [pname, pvalue] of Object.entries(parameters)) {}
 }
-//# sourceMappingURL=texture.js.map
+//# sourceMappingURL=webgl-texture.js.map