@luma.gl/webgl 9.1.0-alpha.15 → 9.1.0-alpha.17

package/src/adapter/helpers/webgl-texture-utils.ts

@@ -6,24 +6,24 @@
 // WebGL... the texture API from hell... hopefully made simpler
 //
 
+import {TypedArray} from '@math.gl/types';
 import type {ExternalImage} from '@luma.gl/core';
 import {Buffer, Texture, Framebuffer, FramebufferProps} from '@luma.gl/core';
-
 import {
   GL,
   GLTextureTarget,
   GLTextureCubeMapTarget,
   GLTexelDataFormat,
-  GLPixelType
+  GLPixelType,
+  GLDataType
 } from '@luma.gl/constants';
 
-import {TypedArray} from '@math.gl/types';
-
 import {WEBGLFramebuffer} from '../resources/webgl-framebuffer';
 import {getGLTypeFromTypedArray, getTypedArrayFromGLType} from './typed-array-utils';
 import {glFormatToComponents, glTypeToBytes} from './format-utils';
 import {WEBGLBuffer} from '../resources/webgl-buffer';
 import {WEBGLTexture} from '../resources/webgl-texture';
+import {withGLParameters} from '../../context/state-tracker/with-parameters';
 
 /** A "border" parameter is required in many WebGL texture APIs, but must always be 0... */
 const BORDER = 0;
@@ -120,7 +120,7 @@ export function copyExternalImageToMipLevel(
   gl: WebGL2RenderingContext,
   handle: WebGLTexture,
   image: ExternalImage,
-  options: WebGLCopyTextureOptions
+  options: WebGLCopyTextureOptions & {flipY?: boolean}
 ): void {
   const {width, height} = options;
   const {dimension, depth = 0, mipLevel = 0} = options;
@@ -129,26 +129,29 @@ export function copyExternalImageToMipLevel(
 
   const glTarget = getWebGLCubeFaceTarget(options.glTarget, dimension, depth);
 
-  switch (dimension) {
-    case '2d-array':
-    case '3d':
-      gl.bindTexture(glTarget, handle);
-      // prettier-ignore
-      gl.texSubImage3D(glTarget, mipLevel, x, y, z, width, height, depth, glFormat, glType, image);
-      gl.bindTexture(glTarget, null);
-      break;
+  const glParameters = options.flipY ? {[GL.UNPACK_FLIP_Y_WEBGL]: true} : {};
+  withGLParameters(gl, glParameters, () => {
+    switch (dimension) {
+      case '2d-array':
+      case '3d':
+        gl.bindTexture(glTarget, handle);
+        // prettier-ignore
+        gl.texSubImage3D(glTarget, mipLevel, x, y, z, width, height, depth, glFormat, glType, image);
+        gl.bindTexture(glTarget, null);
+        break;
 
-    case '2d':
-    case 'cube':
-      gl.bindTexture(glTarget, handle);
-      // prettier-ignore
-      gl.texSubImage2D(glTarget, mipLevel, x, y, width, height, glFormat, glType, image);
-      gl.bindTexture(glTarget, null);
-      break;
+      case '2d':
+      case 'cube':
+        gl.bindTexture(glTarget, handle);
+        // prettier-ignore
+        gl.texSubImage2D(glTarget, mipLevel, x, y, width, height, glFormat, glType, image);
+        gl.bindTexture(glTarget, null);
+        break;
 
-    default:
-      throw new Error(dimension);
-  }
+      default:
+        throw new Error(dimension);
+    }
+  });
 }
 
 /**
@@ -278,7 +281,7 @@ export function getWebGLCubeFaceTarget(
  * Wrapper for the messy WebGL texture API
  *
 export function clearMipLevel(gl: WebGL2RenderingContext, options: WebGLSetTextureOptions): void {
-  const {dimension, width, height, depth = 0, level = 0} = options;
+  const {dimension, width, height, depth = 0, mipLevel = 0} = options;
   const {glInternalFormat, glFormat, glType, compressed} = options;
   const glTarget = getWebGLCubeFaceTarget(options.glTarget, dimension, depth);
 
@@ -287,10 +290,10 @@ export function clearMipLevel(gl: WebGL2RenderingContext, options: WebGLSetTextu
     case '3d':
       if (compressed) {
         // prettier-ignore
-        gl.compressedTexImage3D(glTarget, level, glInternalFormat, width, height, depth, BORDER, null);
+        gl.compressedTexImage3D(glTarget, mipLevel, glInternalFormat, width, height, depth, BORDER, null);
       } else {
         // prettier-ignore
-        gl.texImage3D( glTarget, level, glInternalFormat, width, height, depth, BORDER, glFormat, glType, null);
+        gl.texImage3D( glTarget, mipLevel, glInternalFormat, width, height, depth, BORDER, glFormat, glType, null);
       }
       break;
 
@@ -298,10 +301,10 @@ export function clearMipLevel(gl: WebGL2RenderingContext, options: WebGLSetTextu
     case 'cube':
       if (compressed) {
         // prettier-ignore
-        gl.compressedTexImage2D(glTarget, level, glInternalFormat, width, height, BORDER, null);
+        gl.compressedTexImage2D(glTarget, mipLevel, glInternalFormat, width, height, BORDER, null);
       } else {
         // prettier-ignore
-        gl.texImage2D(glTarget, level, glInternalFormat, width, height, BORDER, glFormat, glType, null);
+        gl.texImage2D(glTarget, mipLevel, glInternalFormat, width, height, BORDER, glFormat, glType, null);
       }
       break;
 
@@ -309,6 +312,7 @@ export function clearMipLevel(gl: WebGL2RenderingContext, options: WebGLSetTextu
       throw new Error(dimension);
   }
 }
+  */
 
 /**
  * Set a texture mip level to the contents of an external image.
@@ -490,6 +494,30 @@ export function setMipLevelFromGPUBuffer(
   gl.bindBuffer(GL.PIXEL_UNPACK_BUFFER, null);
 }
 */
+export type ReadPixelsToArrayOptions = {
+  sourceX?: number;
+  sourceY?: number;
+  sourceFormat?: number;
+  sourceAttachment?: number;
+  target?: Uint8Array | Uint16Array | Float32Array;
+  // following parameters are auto deduced if not provided
+  sourceWidth?: number;
+  sourceHeight?: number;
+  sourceDepth?: number;
+  sourceType?: number;
+};
+
+export type ReadPixelsToBufferOptions = {
+  sourceX?: number;
+  sourceY?: number;
+  sourceFormat?: number;
+  target?: Buffer; // A new Buffer object is created when not provided.
+  targetByteOffset?: number; // byte offset in buffer object
+  // following parameters are auto deduced if not provided
+  sourceWidth?: number;
+  sourceHeight?: number;
+  sourceType?: number;
+};
 
 /**
  * Copies data from a type  or a Texture object into ArrayBuffer object.
@@ -504,23 +532,12 @@ export function setMipLevelFromGPUBuffer(
  */
 export function readPixelsToArray(
   source: Framebuffer | Texture,
-  options?: {
-    sourceX?: number;
-    sourceY?: number;
-    sourceFormat?: number;
-    sourceAttachment?: number;
-    target?: Uint8Array | Uint16Array | Float32Array;
-    // following parameters are auto deduced if not provided
-    sourceWidth?: number;
-    sourceHeight?: number;
-    sourceDepth?: number;
-    sourceType?: number;
-  }
+  options?: ReadPixelsToArrayOptions
 ): Uint8Array | Uint16Array | Float32Array {
   const {
     sourceX = 0,
     sourceY = 0,
-    sourceAttachment = GL.COLOR_ATTACHMENT0 // TODO - support gl.readBuffer
+    sourceAttachment = 0 // TODO - support gl.readBuffer
   } = options || {};
   let {
     target = null,
@@ -535,21 +552,19 @@ export function readPixelsToArray(
   const {framebuffer, deleteFramebuffer} = getFramebuffer(source);
   // assert(framebuffer);
   const {gl, handle} = framebuffer;
-  const attachment = sourceAttachment - GL.COLOR_ATTACHMENT0;
 
   sourceWidth ||= framebuffer.width;
   sourceHeight ||= framebuffer.height;
 
-  // TODO - Set and unset gl.readBuffer
-  // if (sourceAttachment === GL.COLOR_ATTACHMENT0 && handle === null) {
-  //   sourceAttachment = GL.FRONT;
-  // }
-
-  sourceDepth = framebuffer.colorAttachments[attachment]?.texture?.depth || 1;
+  const texture = framebuffer.colorAttachments[sourceAttachment]?.texture;
+  if (!texture) {
+    throw new Error(`Invalid framebuffer attachment ${sourceAttachment}`);
+  }
+  sourceDepth = texture?.depth || 1;
 
-  sourceFormat ||= framebuffer.colorAttachments[attachment]?.texture?.glFormat || GL.RGBA;
+  sourceFormat ||= texture?.glFormat || GL.RGBA;
   // Deduce the type from color attachment if not provided.
-  sourceType ||= framebuffer.colorAttachments[attachment]?.texture?.glType || GL.UNSIGNED_BYTE;
+  sourceType ||= texture?.glType || GL.UNSIGNED_BYTE;
 
   // Deduce type and allocated pixelArray if needed
   target = getPixelArray(target, sourceType, sourceFormat, sourceWidth, sourceHeight, sourceDepth);
@@ -557,13 +572,31 @@ export function readPixelsToArray(
   // Pixel array available, if necessary, deduce type from it.
   sourceType = sourceType || getGLTypeFromTypedArray(target);
 
-  const prevHandle = gl.bindFramebuffer(GL.FRAMEBUFFER, handle);
+  // Note: luma.gl overrides bindFramebuffer so that we can reliably restore the previous framebuffer (this is the only function for which we do that)
+  const prevHandle = gl.bindFramebuffer(
+    GL.FRAMEBUFFER,
+    handle
+  ) as unknown as WebGLFramebuffer | null;
+
+  // Select the color attachment to read from
+  gl.readBuffer(gl.COLOR_ATTACHMENT0 + sourceAttachment);
+
+  // There is a lot of hedging in the WebGL2 spec about what formats are guaranteed to be readable
+  // (It should always be possible to read RGBA/UNSIGNED_BYTE, but most other combinations are not guaranteed)
+  // Querying is possible but expensive:
+  // const {device} = framebuffer;
+  // texture.glReadFormat ||= gl.getParameter(gl.IMPLEMENTATION_COLOR_READ_FORMAT);
+  // texture.glReadType ||= gl.getParameter(gl.IMPLEMENTATION_COLOR_READ_TYPE);
+  // console.log('params', device.getGLKey(texture.glReadFormat), device.getGLKey(texture.glReadType));
+
   gl.readPixels(sourceX, sourceY, sourceWidth, sourceHeight, sourceFormat, sourceType, target);
-  // @ts-expect-error
+  gl.readBuffer(gl.COLOR_ATTACHMENT0);
   gl.bindFramebuffer(GL.FRAMEBUFFER, prevHandle || null);
+
   if (deleteFramebuffer) {
     framebuffer.destroy();
   }
+
   return target;
 }
 
@@ -576,17 +609,7 @@ export function readPixelsToArray(
  */
 export function readPixelsToBuffer(
   source: Framebuffer | Texture,
-  options?: {
-    sourceX?: number;
-    sourceY?: number;
-    sourceFormat?: number;
-    target?: Buffer; // A new Buffer object is created when not provided.
-    targetByteOffset?: number; // byte offset in buffer object
-    // following parameters are auto deduced if not provided
-    sourceWidth?: number;
-    sourceHeight?: number;
-    sourceType?: number;
-  }
+  options?: ReadPixelsToBufferOptions
 ): WEBGLBuffer {
   const {
     target,
@@ -620,11 +643,11 @@ export function readPixelsToBuffer(
   // TODO(donmccurdy): Do we have tests to confirm this is working?
   const commandEncoder = source.device.createCommandEncoder();
   commandEncoder.copyTextureToBuffer({
-    source: source as Texture,
+    sourceTexture: source as Texture,
     width: sourceWidth,
     height: sourceHeight,
     origin: [sourceX, sourceY],
-    destination: webglBufferTarget,
+    destinationBuffer: webglBufferTarget,
     byteOffset: targetByteOffset
   });
   commandEncoder.destroy();
@@ -642,8 +665,8 @@ export function readPixelsToBuffer(
  */
 // eslint-disable-next-line complexity, max-statements
 export function copyToTexture(
-  source: Framebuffer | Texture,
-  target: Texture | GL,
+  sourceTexture: Framebuffer | Texture,
+  destinationTexture: Texture | GL,
   options?: {
     sourceX?: number;
     sourceY?: number;
@@ -673,7 +696,7 @@ export function copyToTexture(
     height // defaults to target height
   } = options || {};
 
-  const {framebuffer, deleteFramebuffer} = getFramebuffer(source);
+  const {framebuffer, deleteFramebuffer} = getFramebuffer(sourceTexture);
   // assert(framebuffer);
   const webglFramebuffer = framebuffer;
   const {device, handle} = webglFramebuffer;
@@ -690,8 +713,8 @@ export function copyToTexture(
   // assert(target);
   let texture: WEBGLTexture | null = null;
   let textureTarget: GL;
-  if (target instanceof WEBGLTexture) {
-    texture = target;
+  if (destinationTexture instanceof WEBGLTexture) {
+    texture = destinationTexture;
     width = Number.isFinite(width) ? width : texture.width;
     height = Number.isFinite(height) ? height : texture.height;
     texture?.bind(0);
@@ -785,8 +808,8 @@ export function toFramebuffer(texture: Texture, props?: FramebufferProps): WEBGL
 // eslint-disable-next-line max-params
 function getPixelArray(
   pixelArray,
-  type,
-  format,
+  glType: GLDataType | GLPixelType,
+  glFormat: GL,
   width: number,
   height: number,
   depth?: number
@@ -794,10 +817,11 @@ function getPixelArray(
   if (pixelArray) {
     return pixelArray;
   }
+  // const formatInfo = decodeTextureFormat(format);
   // Allocate pixel array if not already available, using supplied type
-  type = type || GL.UNSIGNED_BYTE;
-  const ArrayType = getTypedArrayFromGLType(type, {clamped: false});
-  const components = glFormatToComponents(format);
+  glType ||= GL.UNSIGNED_BYTE;
+  const ArrayType = getTypedArrayFromGLType(glType, {clamped: false});
+  const components = glFormatToComponents(glFormat);
   // TODO - check for composite type (components = 1).
   return new ArrayType(width * height * components) as Uint8Array | Uint16Array | Float32Array;
 }

package/src/adapter/resources/webgl-command-buffer.ts

@@ -7,9 +7,18 @@ import type {
   CopyBufferToTextureOptions,
   CopyTextureToBufferOptions,
   CopyTextureToTextureOptions
+  // ClearTextureOptions,
+  // ReadTextureOptions
 } from '@luma.gl/core';
 import {CommandBuffer, Texture, Framebuffer} from '@luma.gl/core';
-import {GL} from '@luma.gl/constants';
+import {
+  GL,
+  GLTextureTarget,
+  GLTextureCubeMapTarget
+  // GLTexelDataFormat,
+  // GLPixelType,
+  // GLDataType
+} from '@luma.gl/constants';
 
 import {WebGLDevice} from '../webgl-device';
 import {WEBGLBuffer} from './webgl-buffer';
@@ -37,11 +46,23 @@ type CopyTextureToTextureCommand = {
   options: CopyTextureToTextureOptions;
 };
 
+type ClearTextureCommand = {
+  name: 'clear-texture';
+  options: {}; // ClearTextureOptions;
+};
+
+type ReadTextureCommand = {
+  name: 'read-texture';
+  options: {}; // ReadTextureOptions;
+};
+
 type Command =
   | CopyBufferToBufferCommand
   | CopyBufferToTextureCommand
   | CopyTextureToBufferCommand
-  | CopyTextureToTextureCommand;
+  | CopyTextureToTextureCommand
+  | ClearTextureCommand
+  | ReadTextureCommand;
 
 export class WEBGLCommandBuffer extends CommandBuffer {
   device: WebGLDevice;
@@ -67,14 +88,19 @@ export class WEBGLCommandBuffer extends CommandBuffer {
         case 'copy-texture-to-texture':
           _copyTextureToTexture(this.device, command.options);
           break;
+        // case 'clear-texture':
+        //   _clearTexture(this.device, command.options);
+        //   break;
+        default:
+          throw new Error(command.name);
       }
     }
   }
 }
 
 function _copyBufferToBuffer(device: WebGLDevice, options: CopyBufferToBufferOptions): void {
-  const source = options.source as WEBGLBuffer;
-  const destination = options.destination as WEBGLBuffer;
+  const source = options.sourceBuffer as WEBGLBuffer;
+  const destination = options.destinationBuffer as WEBGLBuffer;
 
   // {In WebGL2 we can p}erform the copy on the GPU
   // Use GL.COPY_READ_BUFFER+GL.COPY_WRITE_BUFFER avoid disturbing other targets and locking type
@@ -106,22 +132,22 @@ function _copyBufferToTexture(device: WebGLDevice, options: CopyBufferToTextureO
 function _copyTextureToBuffer(device: WebGLDevice, options: CopyTextureToBufferOptions): void {
   const {
     /** Texture to copy to/from. */
-    source,
+    sourceTexture,
     /**  Mip-map level of the texture to copy to/from. (Default 0) */
     mipLevel = 0,
     /** Defines which aspects of the texture to copy to/from. */
     aspect = 'all',
 
     /** Width to copy */
-    width = options.source.width,
+    width = options.sourceTexture.width,
     /** Height to copy */
-    height = options.source.height,
+    height = options.sourceTexture.height,
     depthOrArrayLayers = 0,
     /** Defines the origin of the copy - the minimum corner of the texture sub-region to copy to/from. */
     origin = [0, 0],
 
     /** Destination buffer */
-    destination,
+    destinationBuffer,
     /** Offset, in bytes, from the beginning of the buffer to the start of the image data (default 0) */
     byteOffset = 0,
     /**
@@ -139,7 +165,7 @@ function _copyTextureToBuffer(device: WebGLDevice, options: CopyTextureToBufferO
 
   // TODO - Not possible to read just stencil or depth part in WebGL?
   if (aspect !== 'all') {
-    throw new Error('not supported');
+    throw new Error('aspect not supported in WebGL');
   }
 
   // TODO - mipLevels are set when attaching texture to framebuffer
@@ -148,10 +174,10 @@ function _copyTextureToBuffer(device: WebGLDevice, options: CopyTextureToBufferO
   }
 
   // Asynchronous read (PIXEL_PACK_BUFFER) is WebGL2 only feature
-  const {framebuffer, destroyFramebuffer} = getFramebuffer(source);
+  const {framebuffer, destroyFramebuffer} = getFramebuffer(sourceTexture);
   let prevHandle: WebGLFramebuffer | null | undefined;
   try {
-    const webglBuffer = destination as WEBGLBuffer;
+    const webglBuffer = destinationBuffer as WEBGLBuffer;
     const sourceWidth = width || framebuffer.width;
     const sourceHeight = height || framebuffer.height;
     const sourceParams = getTextureFormatWebGL(
@@ -220,7 +246,7 @@ export function readPixelsToBuffer(
 function _copyTextureToTexture(device: WebGLDevice, options: CopyTextureToTextureOptions): void {
   const {
     /** Texture to copy to/from. */
-    source,
+    sourceTexture,
     /**  Mip-map level of the texture to copy to (Default 0) */
     destinationMipLevel = 0,
     /** Defines which aspects of the texture to copy to/from. */
@@ -232,7 +258,7 @@ function _copyTextureToTexture(device: WebGLDevice, options: CopyTextureToTextur
     destinationOrigin = [0, 0],
 
     /** Texture to copy to/from. */
-    destination
+    destinationTexture
     /**  Mip-map level of the texture to copy to/from. (Default 0) */
     // destinationMipLevel = options.mipLevel,
     /** Defines the origin of the copy - the minimum corner of the texture sub-region to copy to/from. */
@@ -242,12 +268,12 @@ function _copyTextureToTexture(device: WebGLDevice, options: CopyTextureToTextur
   } = options;
 
   let {
-    width = options.destination.width,
-    height = options.destination.height
+    width = options.destinationTexture.width,
+    height = options.destinationTexture.height
     // depthOrArrayLayers = 0
   } = options;
 
-  const {framebuffer, destroyFramebuffer} = getFramebuffer(source);
+  const {framebuffer, destroyFramebuffer} = getFramebuffer(sourceTexture);
   const [sourceX, sourceY] = origin;
   const [destinationX, destinationY, destinationZ] = destinationOrigin;
 
@@ -261,8 +287,8 @@ function _copyTextureToTexture(device: WebGLDevice, options: CopyTextureToTextur
 
   let texture: WEBGLTexture = null;
   let textureTarget: GL;
-  if (destination instanceof WEBGLTexture) {
-    texture = destination;
+  if (destinationTexture instanceof WEBGLTexture) {
+    texture = destinationTexture;
     width = Number.isFinite(width) ? width : texture.width;
     height = Number.isFinite(height) ? height : texture.height;
     texture.bind(0);
@@ -311,7 +337,82 @@ function _copyTextureToTexture(device: WebGLDevice, options: CopyTextureToTextur
   }
 }
 
-// Returns number of components in a specific readPixels WebGL format
+/** Clear one mip level of a texture *
+function _clearTexture(device: WebGLDevice, options: ClearTextureOptions) {
+  const BORDER = 0;
+  const {dimension, width, height, depth = 0, mipLevel = 0} = options;
+  const {glInternalFormat, glFormat, glType, compressed} = options;
+  const glTarget = getWebGLCubeFaceTarget(options.glTarget, dimension, depth);
+
+  switch (dimension) {
+    case '2d-array':
+    case '3d':
+      if (compressed) {
+        // prettier-ignore
+        device.gl.compressedTexImage3D(glTarget, mipLevel, glInternalFormat, width, height, depth, BORDER, null);
+      } else {
+        // prettier-ignore
+        device.gl.texImage3D( glTarget, mipLevel, glInternalFormat, width, height, depth, BORDER, glFormat, glType, null);
+      }
+      break;
+
+    case '2d':
+    case 'cube':
+      if (compressed) {
+        // prettier-ignore
+        device.gl.compressedTexImage2D(glTarget, mipLevel, glInternalFormat, width, height, BORDER, null);
+      } else {
+        // prettier-ignore
+        device.gl.texImage2D(glTarget, mipLevel, glInternalFormat, width, height, BORDER, glFormat, glType, null);
+      }
+      break;
+
+    default:
+      throw new Error(dimension);
+  }
+}
+  */
+
+// function _readTexture(device: WebGLDevice, options: CopyTextureToBufferOptions) {}
+
+// HELPERS
+
+/**
+ * In WebGL, cube maps specify faces by overriding target instead of using the depth parameter.
+ * @note We still bind the texture using GL.TEXTURE_CUBE_MAP, but we need to use the face-specific target when setting mip levels.
+ * @returns glTarget unchanged, if dimension !== 'cube'.
+ */
+export function getWebGLCubeFaceTarget(
+  glTarget: GLTextureTarget,
+  dimension: '1d' | '2d' | '2d-array' | 'cube' | 'cube-array' | '3d',
+  level: number
+): GLTextureTarget | GLTextureCubeMapTarget {
+  return dimension === 'cube' ? GL.TEXTURE_CUBE_MAP_POSITIVE_X + level : glTarget;
+}
+
+/** Wrap a texture in a framebuffer so that we can use WebGL APIs that work on framebuffers */
+function getFramebuffer(source: Texture | Framebuffer): {
+  framebuffer: WEBGLFramebuffer;
+  destroyFramebuffer: boolean;
+} {
+  if (source instanceof Texture) {
+    const {width, height, id} = source;
+    const framebuffer = source.device.createFramebuffer({
+      id: `framebuffer-for-${id}`,
+      width,
+      height,
+      colorAttachments: [source]
+    }) as unknown as WEBGLFramebuffer;
+
+    return {framebuffer, destroyFramebuffer: true};
+  }
+  return {framebuffer: source as unknown as WEBGLFramebuffer, destroyFramebuffer: false};
+}
+
+/**
+ * Returns number of components in a specific readPixels WebGL format
+ * @todo use shadertypes utils instead?
+ */
 export function glFormatToComponents(format): 1 | 2 | 3 | 4 {
   switch (format) {
     case GL.ALPHA:
@@ -333,7 +434,10 @@ export function glFormatToComponents(format): 1 | 2 | 3 | 4 {
   }
 }
 
-// Return byte count for given readPixels WebGL type
+/**
+ * Return byte count for given readPixels WebGL type
+ * @todo use shadertypes utils instead?
+ */
 export function glTypeToBytes(type: GL): 1 | 2 | 4 {
   switch (type) {
     case GL.UNSIGNED_BYTE:
@@ -349,23 +453,3 @@ export function glTypeToBytes(type: GL): 1 | 2 | 4 {
       throw new Error('GLType');
   }
 }
-
-// Helper methods
-
-function getFramebuffer(source: Texture | Framebuffer): {
-  framebuffer: WEBGLFramebuffer;
-  destroyFramebuffer: boolean;
-} {
-  if (source instanceof Texture) {
-    const {width, height, id} = source;
-    const framebuffer = source.device.createFramebuffer({
-      id: `framebuffer-for-${id}`,
-      width,
-      height,
-      colorAttachments: [source]
-    }) as unknown as WEBGLFramebuffer;
-
-    return {framebuffer, destroyFramebuffer: true};
-  }
-  return {framebuffer: source as unknown as WEBGLFramebuffer, destroyFramebuffer: false};
-}

package/src/adapter/resources/webgl-command-encoder.ts

@@ -8,6 +8,8 @@ import type {
   CopyBufferToTextureOptions,
   CopyTextureToBufferOptions,
   CopyTextureToTextureOptions,
+  // ClearTextureOptions,
+  // ReadTextureOptions,
   QuerySet,
   Buffer
 } from '@luma.gl/core';
@@ -52,6 +54,10 @@ export class WEBGLCommandEncoder extends CommandEncoder {
     this.commandBuffer.commands.push({name: 'copy-texture-to-texture', options});
   }
 
+  // clearTexture(options: ClearTextureOptions): void {
+  //   this.commandBuffer.commands.push({name: 'copy-texture-to-texture', options});
+  // }
+
   override pushDebugGroup(groupLabel: string): void {}
   override popDebugGroup() {}
 

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

@@ -72,6 +72,20 @@ export class WEBGLExternalTexture extends WEBGLTexture {
       data.addEventListener('loadeddata', () => this.initialize(props));
       return this;
     }
+  }
+
+  initialize() {
+        // TODO - Video handling, move to ExternalTexture?
+    // if (isVideo) {
+    //   this._video = {
+    //     video: data,
+    //     // TODO  - should we be using the sampler parameters here?
+    //     parameters: {},
+    //     // @ts-expect-error HTMLVideoElement.HAVE_CURRENT_DATA is not declared
+    //     lastTime: data.readyState >= HTMLVideoElement.HAVE_CURRENT_DATA ? data.currentTime : -1
+    //   };
+    // }
+  }
 
   update(): this {
     if (this._video) {

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

@@ -77,8 +77,7 @@ export class WEBGLFramebuffer extends Framebuffer {
     }
 
     /** Check the status */
-    // @ts-expect-error
-    if (this.props.check !== false) {
+    if (this.device.props.debug) {
       const status = this.gl.checkFramebufferStatus(GL.FRAMEBUFFER) as GL;
       if (status !== GL.FRAMEBUFFER_COMPLETE) {
         throw new Error(`Framebuffer ${_getFrameBufferStatus(status)}`);