@luma.gl/webgl 9.0.0-beta.4 → 9.0.0-beta.6

package/dist/adapter/resources/webgl-command-buffer.js

@@ -1,192 +1,290 @@
+// luma.gl
+// SPDX-License-Identifier: MIT
+// Copyright (c) vis.gl contributors
 import { CommandBuffer, Texture } from '@luma.gl/core';
+import { GL } from '@luma.gl/constants';
 import { WEBGLTexture } from "./webgl-texture.js";
 import { getWebGLTextureParameters } from "../converters/texture-formats.js";
 function cast(value) {
-  return value;
+    return value;
 }
 export class WEBGLCommandBuffer extends CommandBuffer {
-  constructor(device) {
-    super(device, {});
-    this.device = void 0;
-    this.commands = [];
-    this.device = device;
-  }
-  submitCommands() {
-    let commands = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : this.commands;
-    for (const command of commands) {
-      switch (command.name) {
-        case 'copy-buffer-to-buffer':
-          _copyBufferToBuffer(this.device, command.options);
-          break;
-        case 'copy-buffer-to-texture':
-          _copyBufferToTexture(this.device, command.options);
-          break;
-        case 'copy-texture-to-buffer':
-          _copyTextureToBuffer(this.device, command.options);
-          break;
-        case 'copy-texture-to-texture':
-          _copyTextureToTexture(this.device, command.options);
-          break;
-      }
+    device;
+    commands = [];
+    constructor(device) {
+        super(device, {});
+        this.device = device;
+    }
+    submitCommands(commands = this.commands) {
+        for (const command of commands) {
+            switch (command.name) {
+                case 'copy-buffer-to-buffer':
+                    _copyBufferToBuffer(this.device, command.options);
+                    break;
+                case 'copy-buffer-to-texture':
+                    _copyBufferToTexture(this.device, command.options);
+                    break;
+                case 'copy-texture-to-buffer':
+                    _copyTextureToBuffer(this.device, command.options);
+                    break;
+                case 'copy-texture-to-texture':
+                    _copyTextureToTexture(this.device, command.options);
+                    break;
+            }
+        }
     }
-  }
 }
 function _copyBufferToBuffer(device, options) {
-  const source = cast(options.source);
-  const destination = cast(options.destination);
-  const gl2 = device.assertWebGL2();
-  if (gl2) {
-    var _options$sourceOffset, _options$destinationO;
-    gl2.bindBuffer(36662, source.handle);
-    gl2.bindBuffer(36663, destination.handle);
-    gl2.copyBufferSubData(36662, 36663, (_options$sourceOffset = options.sourceOffset) !== null && _options$sourceOffset !== void 0 ? _options$sourceOffset : 0, (_options$destinationO = options.destinationOffset) !== null && _options$destinationO !== void 0 ? _options$destinationO : 0, options.size);
-    gl2.bindBuffer(36662, null);
-    gl2.bindBuffer(36663, null);
-  } else {
-    throw new Error('copyBufferToBuffer not implemented in WebGL1');
-  }
+    const source = cast(options.source);
+    const destination = cast(options.destination);
+    // {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
+    device.gl.bindBuffer(GL.COPY_READ_BUFFER, source.handle);
+    device.gl.bindBuffer(GL.COPY_WRITE_BUFFER, destination.handle);
+    device.gl.copyBufferSubData(GL.COPY_READ_BUFFER, GL.COPY_WRITE_BUFFER, options.sourceOffset ?? 0, options.destinationOffset ?? 0, options.size);
+    device.gl.bindBuffer(GL.COPY_READ_BUFFER, null);
+    device.gl.bindBuffer(GL.COPY_WRITE_BUFFER, null);
 }
+/**
+ * Copies data from a Buffer object into a Texture object
+ * NOTE: doesn't wait for copy to be complete
+ */
 function _copyBufferToTexture(device, options) {
-  throw new Error('Not implemented');
+    throw new Error('Not implemented');
 }
+/**
+ * Copies data from a Texture object into a Buffer object.
+ * NOTE: doesn't wait for copy to be complete
+ */
 function _copyTextureToBuffer(device, options) {
-  const {
-    source,
-    mipLevel = 0,
-    aspect = 'all',
-    width = options.source.width,
-    height = options.source.height,
-    depthOrArrayLayers = 0,
-    origin = [0, 0],
-    destination,
-    byteOffset = 0,
-    bytesPerRow,
-    rowsPerImage
-  } = options;
-  if (aspect !== 'all') {
-    throw new Error('not supported');
-  }
-  if (mipLevel !== 0 || depthOrArrayLayers !== 0 || bytesPerRow || rowsPerImage) {
-    throw new Error('not implemented');
-  }
-  const gl2 = device.assertWebGL2();
-  const {
-    framebuffer,
-    destroyFramebuffer
-  } = getFramebuffer(source);
-  try {
-    const webglBuffer = destination;
-    const sourceWidth = width || framebuffer.width;
-    const sourceHeight = height || framebuffer.height;
-    const sourceParams = getWebGLTextureParameters(framebuffer.texture.format, true);
-    const sourceFormat = sourceParams.dataFormat;
-    const sourceType = sourceParams.type;
-    gl2.bindBuffer(35051, webglBuffer.handle);
-    gl2.bindFramebuffer(36160, framebuffer.handle);
-    gl2.readPixels(origin[0], origin[1], sourceWidth, sourceHeight, sourceFormat, sourceType, byteOffset);
-  } finally {
-    gl2.bindBuffer(35051, null);
-    gl2.bindFramebuffer(36160, null);
-    if (destroyFramebuffer) {
-      framebuffer.destroy();
+    const { 
+    /** Texture to copy to/from. */
+    source, 
+    /**  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, 
+    /** Height to copy */
+    height = options.source.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, 
+    /** Offset, in bytes, from the beginning of the buffer to the start of the image data (default 0) */
+    byteOffset = 0, 
+    /**
+     * The stride, in bytes, between the beginning of each block row and the subsequent block row.
+     * Required if there are multiple block rows (i.e. the copy height or depth is more than one block).
+     */
+    bytesPerRow, 
+    /**
+     * Number of block rows per single image of the texture.
+     * rowsPerImage × bytesPerRow is the stride, in bytes, between the beginning of each image of data and the subsequent image.
+     * Required if there are multiple images (i.e. the copy depth is more than one).
+     */
+    rowsPerImage } = options;
+    // TODO - Not possible to read just stencil or depth part in WebGL?
+    if (aspect !== 'all') {
+        throw new Error('not supported');
+    }
+    // TODO - mipLevels are set when attaching texture to framebuffer
+    if (mipLevel !== 0 || depthOrArrayLayers !== 0 || bytesPerRow || rowsPerImage) {
+        throw new Error('not implemented');
+    }
+    // Asynchronous read (PIXEL_PACK_BUFFER) is WebGL2 only feature
+    const { framebuffer, destroyFramebuffer } = getFramebuffer(source);
+    try {
+        const webglBuffer = destination;
+        const sourceWidth = width || framebuffer.width;
+        const sourceHeight = height || framebuffer.height;
+        const sourceParams = getWebGLTextureParameters(framebuffer.texture.props.format);
+        const sourceFormat = sourceParams.dataFormat;
+        const sourceType = sourceParams.type;
+        // if (!target) {
+        //   // Create new buffer with enough size
+        //   const components = glFormatToComponents(sourceFormat);
+        //   const byteCount = glTypeToBytes(sourceType);
+        //   const byteLength = byteOffset + sourceWidth * sourceHeight * components * byteCount;
+        //   target = device.createBuffer({byteLength});
+        // }
+        device.gl.bindBuffer(GL.PIXEL_PACK_BUFFER, webglBuffer.handle);
+        device.gl.bindFramebuffer(GL.FRAMEBUFFER, framebuffer.handle);
+        device.gl.readPixels(origin[0], origin[1], sourceWidth, sourceHeight, sourceFormat, sourceType, byteOffset);
+    }
+    finally {
+        device.gl.bindBuffer(GL.PIXEL_PACK_BUFFER, null);
+        device.gl.bindFramebuffer(GL.FRAMEBUFFER, null);
+        if (destroyFramebuffer) {
+            framebuffer.destroy();
+        }
     }
-  }
 }
+/**
+ * Copies data from a Framebuffer or a Texture object into a Buffer object.
+ * NOTE: doesn't wait for copy to be complete, it programs GPU to perform a DMA transfer.
+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;
+  }
+): Buffer
+ */
+/**
+ * Copy a rectangle from a Framebuffer or Texture object into a texture (at an offset)
+ */
+// eslint-disable-next-line complexity, max-statements
 function _copyTextureToTexture(device, options) {
-  const {
-    source,
-    origin = [0, 0],
+    const { 
+    /** Texture to copy to/from. */
+    source, 
+    /**  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',
+    /** Defines the origin of the copy - the minimum corner of the texture sub-region to copy to/from. */
+    origin = [0, 0], 
+    /** Texture to copy to/from. */
     destination
-  } = options;
-  let {
-    width = options.destination.width,
-    height = options.destination.width
-  } = options;
-  const destinationMipmaplevel = 0;
-  const destinationInternalFormat = 6408;
-  const {
-    framebuffer,
-    destroyFramebuffer
-  } = getFramebuffer(source);
-  const [sourceX, sourceY] = origin;
-  const isSubCopy = false;
-  device.gl.bindFramebuffer(36160, framebuffer.handle);
-  let texture = null;
-  let textureTarget;
-  if (destination instanceof WEBGLTexture) {
-    texture = destination;
-    width = Number.isFinite(width) ? width : texture.width;
-    height = Number.isFinite(height) ? height : texture.height;
-    texture.bind(0);
-    textureTarget = texture.destination;
-  } else {
-    throw new Error('whoops');
-  }
-  if (!isSubCopy) {
-    device.gl.copyTexImage2D(textureTarget, destinationMipmaplevel, destinationInternalFormat, sourceX, sourceY, width, height, 0);
-  } else {}
-  if (texture) {
-    texture.unbind();
-  }
-  if (destroyFramebuffer) {
-    framebuffer.destroy();
-  }
-  return texture;
+    /**  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. */
+    // destinationOrigin = [0, 0],
+    /** Defines which aspects of the texture to copy to/from. */
+    // destinationAspect = options.aspect,
+     } = options;
+    let { width = options.destination.width, height = options.destination.width
+    // depthOrArrayLayers = 0
+     } = options;
+    const destinationMipmaplevel = 0;
+    const destinationInternalFormat = GL.RGBA;
+    const { framebuffer, destroyFramebuffer } = getFramebuffer(source);
+    const [sourceX, sourceY] = origin;
+    const isSubCopy = false;
+    // typeof destinationX !== 'undefined' ||
+    // typeof destinationY !== 'undefined' ||
+    // typeof destinationZ !== 'undefined';
+    // destinationX = destinationX || 0;
+    // destinationY = destinationY || 0;
+    // destinationZ = destinationZ || 0;
+    device.gl.bindFramebuffer(GL.FRAMEBUFFER, framebuffer.handle);
+    // TODO - support gl.readBuffer (WebGL2 only)
+    // const prevBuffer = gl.readBuffer(attachment);
+    let texture = null;
+    let textureTarget;
+    if (destination instanceof WEBGLTexture) {
+        texture = destination;
+        width = Number.isFinite(width) ? width : texture.width;
+        height = Number.isFinite(height) ? height : texture.height;
+        texture.bind(0);
+        textureTarget = texture.destination;
+    }
+    else {
+        throw new Error('whoops');
+        //  textureTarget = destination;
+    }
+    if (!isSubCopy) {
+        device.gl.copyTexImage2D(textureTarget, destinationMipmaplevel, destinationInternalFormat, sourceX, sourceY, width, height, 0 /* border must be 0 */);
+    }
+    else {
+        // switch (textureTarget) {
+        //   case GL.TEXTURE_2D:
+        //   case GL.TEXTURE_CUBE_MAP:
+        //     device.gl.copyTexSubImage2D(
+        //       textureTarget,
+        //       destinationMipmaplevel,
+        //       destinationX,
+        //       destinationY,
+        //       sourceX,
+        //       sourceY,
+        //       width,
+        //       height
+        //     );
+        //     break;
+        //   case GL.TEXTURE_2D_ARRAY:
+        //   case GL.TEXTURE_3D:
+        //     device.gl.copyTexSubImage3D(
+        //       textureTarget,
+        //       destinationMipmaplevel,
+        //       destinationX,
+        //       destinationY,
+        //       destinationZ,
+        //       sourceX,
+        //       sourceY,
+        //       width,
+        //       height
+        //     );
+        //     break;
+        //   default:
+        // }
+    }
+    if (texture) {
+        texture.unbind();
+    }
+    // ts-expect-error
+    // device.gl.bindFramebuffer(GL.FRAMEBUFFER, prevHandle || null);
+    if (destroyFramebuffer) {
+        framebuffer.destroy();
+    }
+    return texture;
 }
+// Returns number of components in a specific readPixels WebGL format
 export function glFormatToComponents(format) {
-  switch (format) {
-    case 6406:
-    case 33326:
-    case 6403:
-      return 1;
-    case 33328:
-    case 33319:
-      return 2;
-    case 6407:
-    case 34837:
-      return 3;
-    case 6408:
-    case 34836:
-      return 4;
-    default:
-      throw new Error('GLFormat');
-  }
+    switch (format) {
+        case GL.ALPHA:
+        case GL.R32F:
+        case GL.RED:
+            return 1;
+        case GL.RG32F:
+        case GL.RG:
+            return 2;
+        case GL.RGB:
+        case GL.RGB32F:
+            return 3;
+        case GL.RGBA:
+        case GL.RGBA32F:
+            return 4;
+        // TODO: Add support for additional WebGL2 formats
+        default:
+            throw new Error('GLFormat');
+    }
 }
+// Return byte count for given readPixels WebGL type
 export function glTypeToBytes(type) {
-  switch (type) {
-    case 5121:
-      return 1;
-    case 33635:
-    case 32819:
-    case 32820:
-      return 2;
-    case 5126:
-      return 4;
-    default:
-      throw new Error('GLType');
-  }
+    switch (type) {
+        case GL.UNSIGNED_BYTE:
+            return 1;
+        case GL.UNSIGNED_SHORT_5_6_5:
+        case GL.UNSIGNED_SHORT_4_4_4_4:
+        case GL.UNSIGNED_SHORT_5_5_5_1:
+            return 2;
+        case GL.FLOAT:
+            return 4;
+        // TODO: Add support for additional WebGL2 types
+        default:
+            throw new Error('GLType');
+    }
 }
+// Helper methods
 function getFramebuffer(source) {
-  if (source instanceof Texture) {
-    const {
-      width,
-      height,
-      id
-    } = source;
-    const framebuffer = source.device.createFramebuffer({
-      id: `framebuffer-for-${id}`,
-      width,
-      height,
-      colorAttachments: [source]
-    });
-    return {
-      framebuffer,
-      destroyFramebuffer: true
-    };
-  }
-  return {
-    framebuffer: source,
-    destroyFramebuffer: false
-  };
+    if (source instanceof Texture) {
+        const { width, height, id } = source;
+        const framebuffer = source.device.createFramebuffer({
+            id: `framebuffer-for-${id}`,
+            width,
+            height,
+            colorAttachments: [source]
+        });
+        return { framebuffer, destroyFramebuffer: true };
+    }
+    return { framebuffer: source, destroyFramebuffer: false };
 }
-//# sourceMappingURL=webgl-command-buffer.js.map

package/dist/adapter/resources/webgl-command-encoder.d.ts

@@ -1,7 +1,7 @@
 import { CommandEncoder, CommandEncoderProps } from '@luma.gl/core';
-import type { CopyBufferToBufferOptions, CopyBufferToTextureOptions, CopyTextureToBufferOptions, CopyTextureToTextureOptions } from '@luma.gl/core';
-import { WEBGLCommandBuffer } from './webgl-command-buffer';
-import { WebGLDevice } from '../webgl-device';
+import type { CopyBufferToBufferOptions, CopyBufferToTextureOptions, CopyTextureToBufferOptions, CopyTextureToTextureOptions, QuerySet, Buffer } from '@luma.gl/core';
+import { WEBGLCommandBuffer } from "./webgl-command-buffer.js";
+import { WebGLDevice } from "../webgl-device.js";
 export declare class WEBGLCommandEncoder extends CommandEncoder {
     readonly device: WebGLDevice;
     readonly commandBuffer: WEBGLCommandBuffer;
@@ -15,5 +15,10 @@ export declare class WEBGLCommandEncoder extends CommandEncoder {
     pushDebugGroup(groupLabel: string): void;
     popDebugGroup(): void;
     insertDebugMarker(markerLabel: string): void;
+    resolveQuerySet(querySet: QuerySet, destination: Buffer, options?: {
+        firstQuery?: number;
+        queryCount?: number;
+        destinationOffset?: number;
+    }): void;
 }
 //# sourceMappingURL=webgl-command-encoder.d.ts.map

package/dist/adapter/resources/webgl-command-encoder.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"webgl-command-encoder.d.ts","sourceRoot":"","sources":["../../../src/adapter/resources/webgl-command-encoder.ts"],"names":[],"mappings":"AAGA,OAAO,EAAC,cAAc,EAAE,mBAAmB,EAAC,MAAM,eAAe,CAAC;AAClE,OAAO,KAAK,EACV,yBAAyB,EACzB,0BAA0B,EAC1B,0BAA0B,EAC1B,2BAA2B,EAC5B,MAAM,eAAe,CAAC;AAEvB,OAAO,EAAC,kBAAkB,EAAC,MAAM,wBAAwB,CAAC;AAC1D,OAAO,EAAC,WAAW,EAAC,MAAM,iBAAiB,CAAC;AAE5C,qBAAa,mBAAoB,SAAQ,cAAc;IACrD,QAAQ,CAAC,MAAM,EAAE,WAAW,CAAC;IAE7B,QAAQ,CAAC,aAAa,EAAE,kBAAkB,CAAC;gBAE/B,MAAM,EAAE,WAAW,EAAE,KAAK,EAAE,mBAAmB;IAMlD,OAAO,IAAI,IAAI;IAEf,MAAM,IAAI,IAAI;IAQvB,kBAAkB,CAAC,OAAO,EAAE,yBAAyB,GAAG,IAAI;IAI5D,mBAAmB,CAAC,OAAO,EAAE,0BAA0B;IAIvD,mBAAmB,CAAC,OAAO,EAAE,0BAA0B,GAAG,IAAI;IAI9D,oBAAoB,CAAC,OAAO,EAAE,2BAA2B,GAAG,IAAI;IAIvD,cAAc,CAAC,UAAU,EAAE,MAAM,GAAG,IAAI;IACxC,aAAa;IAEb,iBAAiB,CAAC,WAAW,EAAE,MAAM,GAAG,IAAI;CAWtD"}
+{"version":3,"file":"webgl-command-encoder.d.ts","sourceRoot":"","sources":["../../../src/adapter/resources/webgl-command-encoder.ts"],"names":[],"mappings":"AAIA,OAAO,EAAC,cAAc,EAAE,mBAAmB,EAAC,MAAM,eAAe,CAAC;AAClE,OAAO,KAAK,EACV,yBAAyB,EACzB,0BAA0B,EAC1B,0BAA0B,EAC1B,2BAA2B,EAC3B,QAAQ,EACR,MAAM,EACP,MAAM,eAAe,CAAC;AAEvB,OAAO,EAAC,kBAAkB,EAAC,kCAA+B;AAC1D,OAAO,EAAC,WAAW,EAAC,2BAAwB;AAE5C,qBAAa,mBAAoB,SAAQ,cAAc;IACrD,QAAQ,CAAC,MAAM,EAAE,WAAW,CAAC;IAE7B,QAAQ,CAAC,aAAa,EAAE,kBAAkB,CAAC;gBAE/B,MAAM,EAAE,WAAW,EAAE,KAAK,EAAE,mBAAmB;IAMlD,OAAO,IAAI,IAAI;IAEf,MAAM,IAAI,IAAI;IAQvB,kBAAkB,CAAC,OAAO,EAAE,yBAAyB,GAAG,IAAI;IAI5D,mBAAmB,CAAC,OAAO,EAAE,0BAA0B;IAIvD,mBAAmB,CAAC,OAAO,EAAE,0BAA0B,GAAG,IAAI;IAI9D,oBAAoB,CAAC,OAAO,EAAE,2BAA2B,GAAG,IAAI;IAIvD,cAAc,CAAC,UAAU,EAAE,MAAM,GAAG,IAAI;IACxC,aAAa;IAEb,iBAAiB,CAAC,WAAW,EAAE,MAAM,GAAG,IAAI;IAE5C,eAAe,CACtB,QAAQ,EAAE,QAAQ,EAClB,WAAW,EAAE,MAAM,EACnB,OAAO,CAAC,EAAE;QACR,UAAU,CAAC,EAAE,MAAM,CAAC;QACpB,UAAU,CAAC,EAAE,MAAM,CAAC;QACpB,iBAAiB,CAAC,EAAE,MAAM,CAAC;KAC5B,GACA,IAAI;CACR"}

package/dist/adapter/resources/webgl-command-encoder.js

@@ -1,43 +1,37 @@
+// luma.gl
+// SPDX-License-Identifier: MIT
+// Copyright (c) vis.gl contributors
 import { CommandEncoder } from '@luma.gl/core';
 import { WEBGLCommandBuffer } from "./webgl-command-buffer.js";
 export class WEBGLCommandEncoder extends CommandEncoder {
-  constructor(device, props) {
-    super(device, props);
-    this.device = void 0;
-    this.commandBuffer = void 0;
-    this.device = device;
-    this.commandBuffer = new WEBGLCommandBuffer(device);
-  }
-  destroy() {}
-  finish() {
-    this.commandBuffer.submitCommands();
-  }
-  copyBufferToBuffer(options) {
-    this.commandBuffer.commands.push({
-      name: 'copy-buffer-to-buffer',
-      options
-    });
-  }
-  copyBufferToTexture(options) {
-    this.commandBuffer.commands.push({
-      name: 'copy-buffer-to-texture',
-      options
-    });
-  }
-  copyTextureToBuffer(options) {
-    this.commandBuffer.commands.push({
-      name: 'copy-texture-to-buffer',
-      options
-    });
-  }
-  copyTextureToTexture(options) {
-    this.commandBuffer.commands.push({
-      name: 'copy-texture-to-texture',
-      options
-    });
-  }
-  pushDebugGroup(groupLabel) {}
-  popDebugGroup() {}
-  insertDebugMarker(markerLabel) {}
+    device;
+    commandBuffer;
+    constructor(device, props) {
+        super(device, props);
+        this.device = device;
+        this.commandBuffer = new WEBGLCommandBuffer(device);
+    }
+    destroy() { }
+    finish() {
+        this.commandBuffer.submitCommands();
+    }
+    // beginRenderPass(GPURenderPassDescriptor descriptor): GPURenderPassEncoder;
+    // beginComputePass(optional GPUComputePassDescriptor descriptor = {}): GPUComputePassEncoder;
+    // finish(options?: {id?: string}): GPUCommandBuffer;
+    copyBufferToBuffer(options) {
+        this.commandBuffer.commands.push({ name: 'copy-buffer-to-buffer', options });
+    }
+    copyBufferToTexture(options) {
+        this.commandBuffer.commands.push({ name: 'copy-buffer-to-texture', options });
+    }
+    copyTextureToBuffer(options) {
+        this.commandBuffer.commands.push({ name: 'copy-texture-to-buffer', options });
+    }
+    copyTextureToTexture(options) {
+        this.commandBuffer.commands.push({ name: 'copy-texture-to-texture', options });
+    }
+    pushDebugGroup(groupLabel) { }
+    popDebugGroup() { }
+    insertDebugMarker(markerLabel) { }
+    resolveQuerySet(querySet, destination, options) { }
 }
-//# sourceMappingURL=webgl-command-encoder.js.map

package/dist/adapter/resources/webgl-external-texture.js

@@ -1,2 +1,94 @@
+// luma.gl
+// SPDX-License-Identifier: MIT
+// Copyright (c) vis.gl contributors
+/*
+export class WEBGLExternalTexture extends WEBGLTexture {
+  readonly device: WebGLDevice;
+  readonly gl: WebGL2RenderingContext;
+  readonly handle: WebGLTexture;
 
-//# sourceMappingURL=webgl-external-texture.js.map
+  data;
+
+  width: number = undefined;
+  height: number = undefined;
+  depth: number = undefined;
+
+  format = undefined;
+  type = undefined;
+  dataFormat = undefined;
+  border = undefined;
+  mipmaps: boolean = undefined;
+
+  textureUnit: number = undefined;
+
+  sampler: WEBGLSampler;
+
+  // Program.draw() checks the loaded flag of all textures to avoid
+  // Textures that are still loading from promises
+  // Set to true as soon as texture has been initialized with valid data
+  loaded = false;
+  _video;
+
+  readonly target: GL;
+  // target cannot be modified by bind:
+  // textures are special because when you first bind them to a target,
+  // they get special information. When you first bind a texture as a
+  // GL_TEXTURE_2D, you are actually setting special state in the texture.
+  // You are saying that this texture is a 2D texture.
+  // And it will always be a 2D texture; this state cannot be changed ever.
+  // If you have a texture that was first bound as a GL_TEXTURE_2D,
+  // you must always bind it as a GL_TEXTURE_2D;
+  // attempting to bind it as GL_TEXTURE_3D will give rise to an error
+  // (while run-time).
+
+  static isSupported(device: WebGLDevice, options?: TextureSupportOptions): boolean {
+    const {format, linearFiltering} = options;
+    let supported = true;
+    if (format) {
+      supported = supported && isFormatSupported(device.gl, format);
+      supported = supported && (!linearFiltering || isTextureFormatFilterable(device.gl, format));
+    }
+    return supported;
+  }
+
+  // eslint-disable-next-line max-statements
+  constructor(device: Device | WebGL2RenderingContext, props: TextureProps) {
+    super(WebGLDevice.attach(device), {id: uid('texture'), ...props});
+
+    this.glTarget = getWebGLTextureTarget(props);
+
+    this.device = WebGLDevice.attach(device);
+    this.gl = this.device.gl;
+    this.gl2 = this.device.gl2;
+    this.handle = this.props.handle || this.gl.createTexture();
+
+    let data = props.data;
+
+    const isVideo = typeof HTMLVideoElement !== 'undefined' && data instanceof HTMLVideoElement;
+    // @ts-expect-error
+    if (isVideo && data.readyState < HTMLVideoElement.HAVE_METADATA) {
+      this._video = null; // Declare member before the object is sealed
+      data.addEventListener('loadeddata', () => this.initialize(props));
+      return this;
+    }
+
+  update(): this {
+    if (this._video) {
+      const {video, parameters, lastTime} = this._video;
+      // @ts-expect-error
+      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;
+    }
+  }
+
+
+*/