@luma.gl/webgl 9.0.0-alpha.9 → 9.0.0-beta.10

package/src/adapter/resources/webgl-texture.ts

@@ -1,4 +1,7 @@
-// luma.gl, MIT license
+// luma.gl
+// SPDX-License-Identifier: MIT
+// Copyright (c) vis.gl contributors
+
 // Texture class.
 // @todo
 // - [ ] cube texture init params
@@ -7,39 +10,61 @@
 import {
   Device,
   TextureProps,
+  TextureViewProps,
   Sampler,
   SamplerProps,
   SamplerParameters,
-  TypedArray,
-  isObjectEmpty
-} from '@luma.gl/api';
-import {Texture, cast, log, assert, isPowerOfTwo, loadImage} from '@luma.gl/api';
-import GL from '@luma.gl/constants';
-import type {GLSamplerParameters} from '../../types/webgl';
-import {withParameters} from '../../context/state-tracker/with-parameters';
+  TypedArray
+} from '@luma.gl/core';
+import {Texture, log, assert, loadImage, isObjectEmpty} from '@luma.gl/core';
+import {GL, GLSamplerParameters} from '@luma.gl/constants';
+import {withGLParameters} from '../../context/state-tracker/with-parameters';
 import {
-  getWebGLTextureFormat,
+  convertTextureFormatToGL,
   getWebGLTextureParameters,
   getTextureFormatBytesPerPixel
 } from '../converters/texture-formats';
-import {
-  convertSamplerParametersToWebGL,
-  updateSamplerParametersForNPOT
-} from '../converters/sampler-parameters';
-import WebGLDevice from '../webgl-device';
-import WEBGLBuffer from './webgl-buffer';
-import WEBGLSampler from './webgl-sampler';
-
-export type {TextureProps};
-
-export type TextureSourceData = 
-  TypedArray |
-  ImageData |
-  HTMLImageElement |
-  HTMLCanvasElement |
-  ImageBitmap |
-  HTMLVideoElement
-  ;
+import {convertSamplerParametersToWebGL} from '../converters/sampler-parameters';
+import {WebGLDevice} from '../webgl-device';
+import {WEBGLBuffer} from './webgl-buffer';
+import {WEBGLSampler} from './webgl-sampler';
+import {WEBGLTextureView} from './webgl-texture-view';
+
+export type WEBGLTextureProps = TextureProps & {
+  /** @deprecated use props.sampler */
+  parameters?: Record<number, number>;
+  /** @deprecated use props.data */
+  pixels?: any;
+  /** @deprecated use props.format */
+  dataFormat?: number | null;
+  /** @deprecated rarely supported */
+  border?: number;
+  /** @deprecated WebGL only. */
+  pixelStore?: object;
+  /** @deprecated WebGL only. */
+  textureUnit?: number;
+  /** @deprecated WebGL only. Use dimension. */
+  target?: number;
+};
+
+export const DEFAULT_WEBGL_TEXTURE_PROPS = {
+  // deprecated
+  parameters: {},
+  pixelStore: {},
+  pixels: null,
+  border: 0,
+  dataFormat: undefined!,
+  textureUnit: undefined!,
+  target: undefined!
+};
+
+export type TextureSourceData =
+  | TypedArray
+  | ImageData
+  | HTMLImageElement
+  | HTMLCanvasElement
+  | ImageBitmap
+  | HTMLVideoElement;
 
 type SetImageDataOptions = {
   target?: number;
@@ -48,7 +73,7 @@ type SetImageDataOptions = {
   width?: number;
   height?: number;
   depth?: number;
-  format?: any;
+  glFormat?: GL;
   type?: any;
   offset?: number;
   data: any; // TextureSourceData;
@@ -56,7 +81,7 @@ type SetImageDataOptions = {
   parameters?: Record<GL, any>;
   /** @deprecated */
   pixels?: any;
-}
+};
 
 /**
  * @param {*} pixels, data -
@@ -87,7 +112,7 @@ type SetSubImageDataOptions = {
   width?: number;
   height?: number;
   depth?: number;
-  format?: any;
+  glFormat?: any;
   type?: any;
   offset?: number;
   data: any;
@@ -112,9 +137,8 @@ type SetImageData3DOptions = {
   parameters?: Record<GL, any>;
 };
 
-
 // Polyfill
-export default class WEBGLTexture extends Texture {
+export class WEBGLTexture extends Texture<WEBGLTextureProps> {
   // TODO - remove?
   static FACES: number[] = [
     GL.TEXTURE_CUBE_MAP_POSITIVE_X,
@@ -127,17 +151,17 @@ export default class WEBGLTexture extends Texture {
 
   readonly MAX_ATTRIBUTES: number;
   readonly device: WebGLDevice;
-  readonly gl: WebGLRenderingContext;
-  readonly gl2: WebGL2RenderingContext | null;
+  readonly gl: WebGL2RenderingContext;
   readonly handle: WebGLTexture;
 
-  data;
+  // (TODO - currently unused in WebGL, but WebGL 2 does support sampler objects) */
+  sampler: WEBGLSampler = undefined;
 
-  width: number = undefined;
-  height: number = undefined;
-  depth: number = undefined;
+  view: WEBGLTextureView = undefined;
 
-  format: GL = undefined;
+  // data;
+
+  glFormat: GL = undefined;
   type: GL = undefined;
   dataFormat: GL = undefined;
   mipmaps: boolean = undefined;
@@ -154,9 +178,6 @@ export default class WEBGLTexture extends Texture {
   target: GL;
   textureUnit: number = undefined;
 
-  /** Sampler object (currently unused) */
-  sampler: WEBGLSampler = undefined;
-
   /**
    * Program.draw() checks the loaded flag of all textures to avoid
    * Textures that are still loading from promises
@@ -169,16 +190,15 @@ export default class WEBGLTexture extends Texture {
     lastTime: number;
   };
 
-  constructor(device: Device, props: TextureProps) {
-    super(device, {format: GL.RGBA, ...props});
+  constructor(device: Device, props: WEBGLTextureProps) {
+    super(device, {...DEFAULT_WEBGL_TEXTURE_PROPS, format: 'rgba8unorm', ...props});
 
-    this.device = cast<WebGLDevice>(device);
+    this.device = device as WebGLDevice;
     this.gl = this.device.gl;
-    this.gl2 = this.device.gl2;
     this.handle = this.props.handle || this.gl.createTexture();
-    // @ts-expect-error Per SPECTOR docs
-    this.handle.__SPECTOR_Metadata = {...this.props, data: typeof this.props.data}; // {name: this.props.id};
+    this.device.setSpectorMetadata(this.handle, {...this.props, data: typeof this.props.data}); // {name: this.props.id};
 
+    this.glFormat = GL.RGBA;
     this.target = getWebGLTextureTarget(this.props);
 
     // Program.draw() checks the loaded flag of all textures
@@ -194,7 +214,7 @@ export default class WEBGLTexture extends Texture {
     Object.seal(this);
   }
 
-  destroy(): void {
+  override destroy(): void {
     if (this.handle) {
       this.gl.deleteTexture(this.handle);
       this.removeStats();
@@ -204,12 +224,16 @@ export default class WEBGLTexture extends Texture {
     }
   }
 
-  toString(): string {
+  override toString(): string {
     return `Texture(${this.id},${this.width}x${this.height})`;
   }
 
+  createView(props: TextureViewProps): WEBGLTextureView {
+    return new WEBGLTextureView(this.device, {...props, texture: this});
+  }
+
   // eslint-disable-next-line max-statements
-  initialize(props: TextureProps = {}): this {
+  initialize(props: WEBGLTextureProps = {}): this {
     // Cube textures
     if (this.props.dimension === 'cube') {
       return this.initializeCube(props);
@@ -218,7 +242,7 @@ export default class WEBGLTexture extends Texture {
     let data = props.data;
 
     if (data instanceof Promise) {
-      data.then((resolvedImageData) =>
+      data.then(resolvedImageData =>
         this.initialize(
           Object.assign({}, props, {
             pixels: resolvedImageData,
@@ -238,10 +262,9 @@ export default class WEBGLTexture extends Texture {
       return this;
     }
 
-    let {parameters = {}  as Record<GL, any>} = props;
+    const {parameters = {} as Record<GL, any>} = props;
 
-    const {
-      pixels = null, recreate = false, pixelStore = {}, textureUnit = undefined} = props;
+    const {pixels = null, pixelStore = {}, textureUnit = undefined, mipmaps = true} = props;
 
     // pixels variable is for API compatibility purpose
     if (!data) {
@@ -251,9 +274,11 @@ export default class WEBGLTexture extends Texture {
       data = pixels;
     }
 
-    let {width, height, dataFormat, type, compressed = false, mipmaps = true} = props;
+    let {width, height, dataFormat, type, compressed = false} = props;
     const {depth = 0} = props;
 
+    const glFormat = convertTextureFormatToGL(props.format);
+
     // Deduce width and height
     ({width, height, compressed, dataFormat, type} = this._deduceParameters({
       format: props.format,
@@ -265,13 +290,11 @@ export default class WEBGLTexture extends Texture {
       height
     }));
 
-    const format = getWebGLTextureFormat(this.gl, props.format);
-
     // Store opts for accessors
     this.width = width;
     this.height = height;
-    this.depth = depth;
-    this.format = format;
+    // this.depth = depth;
+    this.glFormat = glFormat;
     this.type = type;
     this.dataFormat = dataFormat;
     this.textureUnit = textureUnit;
@@ -281,11 +304,6 @@ export default class WEBGLTexture extends Texture {
       this.gl.bindTexture(this.target, this.handle);
     }
 
-    if (mipmaps && this.device.isWebGL1 && isNPOT(this.width, this.height)) {
-      log.warn(`texture: ${this} is Non-Power-Of-Two, disabling mipmaps`)();
-      mipmaps = false;
-    }
-
     this.mipmaps = mipmaps;
 
     this.setImageData({
@@ -293,10 +311,10 @@ export default class WEBGLTexture extends Texture {
       width,
       height,
       depth,
-      format,
+      format: glFormat,
       type,
       dataFormat,
-      // @ts-expect-error 
+      // @ts-expect-error
       parameters: pixelStore,
       compressed
     });
@@ -305,14 +323,12 @@ export default class WEBGLTexture extends Texture {
     this.setSampler(props.sampler);
     this._setSamplerParameters(parameters);
 
-    if (mipmaps) {
+    this.view = this.createView({...this.props, mipLevelCount: 1, arrayLayerCount: 1});
+
+    if (mipmaps && this.device.isTextureFormatFilterable(props.format)) {
       this.generateMipmap();
     }
 
-    // TODO - Store data to enable auto recreate on context loss
-    if (recreate) {
-      this.data = data;
-    }
     if (isVideo) {
       this._video = {
         video: data as HTMLVideoElement,
@@ -325,8 +341,8 @@ export default class WEBGLTexture extends Texture {
     return this;
   }
 
-  initializeCube(props?: TextureProps): this {
-    const {mipmaps = true, parameters = {}  as Record<GL, any>} = props;
+  initializeCube(props?: WEBGLTextureProps): this {
+    const {mipmaps = true, parameters = {} as Record<GL, any>} = props;
 
     // Store props for accessors
     // this.props = props;
@@ -357,7 +373,6 @@ export default class WEBGLTexture extends Texture {
       samplerProps = sampler as SamplerProps;
     }
 
-    // TODO - technically, this is only needed in WebGL1. In WebGL2 we could always use the sampler.
     const parameters = convertSamplerParametersToWebGL(samplerProps);
     this._setSamplerParameters(parameters);
     return this;
@@ -367,7 +382,7 @@ export default class WEBGLTexture extends Texture {
    * If size has changed, reinitializes with current format
    * @note note clears image and mipmaps
    */
-  resize(options: {height: number, width: number, mipmaps?: boolean}): this {
+  resize(options: {height: number; width: number; mipmaps?: boolean}): this {
     const {height, width, mipmaps = false} = options;
     if (width !== this.width || height !== this.height) {
       return this.initialize({
@@ -383,7 +398,7 @@ export default class WEBGLTexture extends Texture {
   }
 
   /** Update external texture (video frame) */
-  update(): this {
+  update(): void {
     if (this._video) {
       const {video, parameters, lastTime} = this._video;
       // @ts-expect-error
@@ -403,15 +418,10 @@ export default class WEBGLTexture extends Texture {
 
   // Call to regenerate mipmaps after modifying texture(s)
   generateMipmap(params = {}): this {
-    if (this.device.isWebGL1 && isNPOT(this.width, this.height)) {
-      log.warn(`texture: ${this} is Non-Power-Of-Two, disabling mipmaping`)();
-      return this;
-    }
-
     this.mipmaps = true;
 
     this.gl.bindTexture(this.target, this.handle);
-    withParameters(this.gl, params, () => {
+    withGLParameters(this.gl, params, () => {
       this.gl.generateMipmap(this.target);
     });
     this.gl.bindTexture(this.target, null);
@@ -440,7 +450,7 @@ export default class WEBGLTexture extends Texture {
    */
   // eslint-disable-next-line max-statements, complexity
   setImageData(options: SetImageDataOptions) {
-    if (this.props.dimension === '3d') {
+    if (this.props.dimension === '3d' || this.props.dimension === '2d-array') {
       return this.setImageData3D(options);
     }
 
@@ -450,9 +460,9 @@ export default class WEBGLTexture extends Texture {
       target = this.target,
       pixels = null,
       level = 0,
-      format = this.format,
+      glFormat = this.glFormat,
       offset = 0,
-      parameters = {}  as Record<GL, any>
+      parameters = {} as Record<GL, any>
     } = options;
 
     let {
@@ -485,63 +495,63 @@ export default class WEBGLTexture extends Texture {
     let dataType = null;
     ({data, dataType} = this._getDataType({data, compressed}));
 
-    let gl2;
-
-    withParameters(this.gl, parameters, () => {
+    withGLParameters(this.gl, parameters, () => {
       switch (dataType) {
         case 'null':
-          gl.texImage2D(target, level, format, width, height, 0 /*border*/, dataFormat, type, data);
+          gl.texImage2D(
+            target,
+            level,
+            glFormat,
+            width,
+            height,
+            0 /* border*/,
+            dataFormat,
+            type,
+            data
+          );
           break;
         case 'typed-array':
-          // Looks like this assert is not necessary, as offset is ignored under WebGL1
-          // assert((offset === 0 || this.device.isWebGL2), 'offset supported in WebGL2 only');
           gl.texImage2D(
             target,
             level,
-            format,
+            glFormat,
             width,
             height,
             0, // border (must be 0)
             dataFormat,
             type,
             data,
-            // @ts-expect-error
             offset
           );
           break;
         case 'buffer':
           // WebGL2 enables creating textures directly from a WebGL buffer
-          gl2 = this.device.assertWebGL2();
-          gl2.bindBuffer(GL.PIXEL_UNPACK_BUFFER, data.handle || data);
-          gl2.texImage2D(
+          this.device.gl.bindBuffer(GL.PIXEL_UNPACK_BUFFER, data.handle || data);
+          this.device.gl.texImage2D(
             target,
             level,
-            format,
+            glFormat,
             width,
             height,
-            0 /*border*/,
+            0 /* border*/,
             dataFormat,
             type,
             offset
           );
-          gl2.bindBuffer(GL.PIXEL_UNPACK_BUFFER, null);
+          this.device.gl.bindBuffer(GL.PIXEL_UNPACK_BUFFER, null);
           break;
         case 'browser-object':
-          if (this.device.isWebGL2) {
-            gl.texImage2D(
-              target,
-              level,
-              format,
-              width,
-              height,
-              0 /*border*/,
-              dataFormat,
-              type,
-              data
-            );
-          } else {
-            gl.texImage2D(target, level, format, dataFormat, type, data);
-          }
+          gl.texImage2D(
+            target,
+            level,
+            glFormat,
+            width,
+            height,
+            0 /* border*/,
+            dataFormat,
+            type,
+            data
+          );
           break;
         case 'compressed':
           for (const [levelIndex, levelData] of data.entries()) {
@@ -565,7 +575,7 @@ export default class WEBGLTexture extends Texture {
     if (data && data.byteLength) {
       this.trackAllocatedMemory(data.byteLength, 'Texture');
     } else {
-      const bytesPerPixel = getTextureFormatBytesPerPixel(this.gl, this.props.format);
+      const bytesPerPixel = getTextureFormatBytesPerPixel(this.props.format);
       this.trackAllocatedMemory(this.width * this.height * bytesPerPixel, 'Texture');
     }
 
@@ -588,7 +598,7 @@ export default class WEBGLTexture extends Texture {
     width = this.width,
     height = this.height,
     level = 0,
-    format = this.format,
+    glFormat = this.glFormat,
     type = this.type,
     dataFormat = this.dataFormat,
     compressed = false,
@@ -627,29 +637,23 @@ export default class WEBGLTexture extends Texture {
 
     this.gl.bindTexture(this.target, this.handle);
 
-    withParameters(this.gl, parameters, () => {
+    withGLParameters(this.gl, parameters, () => {
       // TODO - x,y parameters
       if (compressed) {
-        this.gl.compressedTexSubImage2D(target, level, x, y, width, height, format, data);
+        this.gl.compressedTexSubImage2D(target, level, x, y, width, height, glFormat, data);
       } else if (data === null) {
         this.gl.texSubImage2D(target, level, x, y, width, height, dataFormat, type, null);
       } else if (ArrayBuffer.isView(data)) {
-        // const gl2 = this.device.assertWebGL2();
-        // @ts-expect-error last offset parameter is ignored under WebGL1
         this.gl.texSubImage2D(target, level, x, y, width, height, dataFormat, type, data, offset);
       } else if (typeof WebGLBuffer !== 'undefined' && data instanceof WebGLBuffer) {
         // WebGL2 allows us to create texture directly from a WebGL buffer
-        const gl2 = this.device.assertWebGL2();
         // This texImage2D signature uses currently bound GL.PIXEL_UNPACK_BUFFER
-        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 (this.device.isWebGL2) {
-        // Assume data is a browser supported object (ImageData, Canvas, ...)
-        const gl2 = this.device.assertWebGL2();
-        gl2.texSubImage2D(target, level, x, y, width, height, dataFormat, type, data);
+        this.device.gl.bindBuffer(GL.PIXEL_UNPACK_BUFFER, data);
+        this.device.gl.texSubImage2D(target, level, x, y, width, height, dataFormat, type, offset);
+        this.device.gl.bindBuffer(GL.PIXEL_UNPACK_BUFFER, null);
       } else {
-        this.gl.texSubImage2D(target, level, x, y, dataFormat, type, data);
+        // Assume data is a browser supported object (ImageData, Canvas, ...)
+        this.device.gl.texSubImage2D(target, level, x, y, width, height, dataFormat, type, data);
       }
     });
 
@@ -724,12 +728,12 @@ export default class WEBGLTexture extends Texture {
 
   // HELPER METHODS
 
-  _deduceParameters(opts: TextureProps) {
+  _deduceParameters(opts: WEBGLTextureProps) {
     const {format, data} = opts;
     let {width, height, dataFormat, type, compressed} = opts;
 
     // Deduce format and type from format
-    const parameters = getWebGLTextureParameters(this.gl, format);
+    const parameters = getWebGLTextureParameters(format);
     dataFormat = dataFormat || parameters.dataFormat;
     type = type || parameters.type;
     compressed = compressed || parameters.compressed;
@@ -802,7 +806,7 @@ export default class WEBGLTexture extends Texture {
     // ... }
 
     const resolvedFaces = await Promise.all(
-      WEBGLTexture.FACES.map((face) => {
+      WEBGLTexture.FACES.map(face => {
         const facePixels = imageDataMap[face];
         return Promise.all(Array.isArray(facePixels) ? facePixels : [facePixels]);
       })
@@ -819,7 +823,7 @@ export default class WEBGLTexture extends Texture {
       resolvedFaces[index].forEach((image, lodLevel) => {
         // TODO: adjust width & height for LOD!
         if (width && height) {
-          gl.texImage2D(face, lodLevel, format, width, height, 0 /*border*/, format, type, image);
+          gl.texImage2D(face, lodLevel, format, width, height, 0 /* border*/, format, type, image);
         } else {
           gl.texImage2D(face, lodLevel, format, format, type, image);
         }
@@ -848,7 +852,7 @@ export default class WEBGLTexture extends Texture {
 
     this.bind();
     if (imageData instanceof Promise) {
-      imageData.then((resolvedImageData) =>
+      imageData.then(resolvedImageData =>
         this.setImageDataForFace(
           Object.assign({}, options, {
             face,
@@ -858,7 +862,7 @@ export default class WEBGLTexture extends Texture {
         )
       );
     } else if (this.width || this.height) {
-      gl.texImage2D(face, 0, format, width, height, 0 /*border*/, format, type, imageData);
+      gl.texImage2D(face, 0, format, width, height, 0 /* border*/, format, type, imageData);
     } else {
       gl.texImage2D(face, 0, format, format, type, imageData);
     }
@@ -885,11 +889,10 @@ export default class WEBGLTexture extends Texture {
 
     this.gl.bindTexture(this.target, this.handle);
 
-    const webglTextureFormat = getWebGLTextureParameters(this.gl, format);
+    const webglTextureFormat = getWebGLTextureParameters(format);
 
-    withParameters(this.gl, parameters, () => {
+    withGLParameters(this.gl, parameters, () => {
       if (ArrayBuffer.isView(data)) {
-        // @ts-expect-error
         this.gl.texImage3D(
           this.target,
           level,
@@ -906,7 +909,6 @@ export default class WEBGLTexture extends Texture {
 
       if (data instanceof WEBGLBuffer) {
         this.gl.bindBuffer(GL.PIXEL_UNPACK_BUFFER, data.handle);
-        // @ts-expect-error
         this.gl.texImage3D(
           this.target,
           level,
@@ -925,7 +927,7 @@ export default class WEBGLTexture extends Texture {
     if (data && data.byteLength) {
       this.trackAllocatedMemory(data.byteLength, 'Texture');
     } else {
-      const bytesPerPixel = getTextureFormatBytesPerPixel(this.gl, this.props.format);
+      const bytesPerPixel = getTextureFormatBytesPerPixel(this.props.format);
       this.trackAllocatedMemory(this.width * this.height * this.depth * bytesPerPixel, 'Texture');
     }
 
@@ -938,14 +940,8 @@ export default class WEBGLTexture extends Texture {
 
   /**
    * Sets sampler parameters on texture
-   * @note: Applies NPOT workaround if appropriate
    */
-  _setSamplerParameters(parameters: GLSamplerParameters) {
-    // Work around WebGL1 sampling restrictions on NPOT textures
-    if (this.device.isWebGL1 && isNPOT(this.width, this.height)) {
-      parameters = updateSamplerParametersForNPOT(parameters);
-    }
-
+  _setSamplerParameters(parameters: GLSamplerParameters): void {
     // NPOT parameters may populate an empty object
     if (isObjectEmpty(parameters)) {
       return;
@@ -955,8 +951,8 @@ export default class WEBGLTexture extends Texture {
 
     this.gl.bindTexture(this.target, this.handle);
     for (const [pname, pvalue] of Object.entries(parameters)) {
-      const param = Number(pname);
-      let value = pvalue;
+      const param = Number(pname) as GL.TEXTURE_MIN_LOD | GL.TEXTURE_MAX_LOD;
+      const value = pvalue;
 
       // Apparently there are integer/float conversion issues requires two parameter setting functions in JavaScript.
       // For now, pick the float version for parameters specified as GLfloat.
@@ -972,30 +968,7 @@ export default class WEBGLTexture extends Texture {
       }
     }
     this.gl.bindTexture(this.target, null);
-    return this;
-  }
-
-  /** @deprecated For LegacyTexture subclass */
-  protected _getWebGL1NPOTParameterOverride(pname: number, value: number): number {
-    // NOTE: Apply NPOT workaround
-    const npot = this.device.isWebGL1 && isNPOT(this.width, this.height);
-    if (npot) {
-      switch (pname) {
-        case GL.TEXTURE_MIN_FILTER:
-          if (value !== GL.LINEAR && value !== GL.NEAREST) {
-            // log.warn(`texture: ${this} is Non-Power-Of-Two, forcing TEXTURE_MIN_FILTER to LINEAR`)();
-            return GL.LINEAR;
-          }
-          break;
-        case GL.TEXTURE_WRAP_S:
-        case GL.TEXTURE_WRAP_T:
-          // if (value !== GL.CLAMP_TO_EDGE) { log.warn(`texture: ${this} is Non-Power-Of-Two, ${getKey(this.gl, pname)} to CLAMP_TO_EDGE`)(); }
-          return GL.CLAMP_TO_EDGE;
-        default:
-          break;
-      }
-    }
-    return value;
+    return;
   }
 }
 
@@ -1021,16 +994,6 @@ function getWebGLTextureTarget(props: TextureProps) {
   }
 }
 
-function isNPOT(width: number, height: number): boolean {
-  // Width and height not available, avoid classifying as NPOT texture
-  if (!width || !height) {
-    return false;
-  }
-  return !isPowerOfTwo(width) || !isPowerOfTwo(height);
-}
-
 function logParameters(parameters: Record<number, GL | number>) {
   log.log(1, 'texture sampler parameters', parameters)();
-  for (const [pname, pvalue] of Object.entries(parameters)) {
-  }
 }