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

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

@@ -1,65 +1,290 @@
-import _defineProperty from "@babel/runtime/helpers/esm/defineProperty";
-import GL from '@luma.gl/constants';
-
+// 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 default class CommandBuffer {
-  constructor() {
-    _defineProperty(this, "commands", []);
-  }
-
-}
-export function submitCommands(device, commands = []) {
-  for (const command of commands) {
-    switch (command.name) {
-      case 'copy-buffer-to-buffer':
-        _copyBufferToBuffer(device, command.options);
-
-        break;
-
-      case 'copy-buffer-to-texture':
-        _copyBufferToTexture(device, command.options);
-
-        break;
-
-      case 'copy-texture-to-buffer':
-        _copyTextureToBuffer(device, command.options);
-
-        break;
-
-      case 'copy-texture-to-texture':
-        _copyTextureToTexture(device, command.options);
-
-        break;
+export class WEBGLCommandBuffer extends CommandBuffer {
+    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;
-
-  if (gl2) {
-    var _options$sourceOffset, _options$destinationO;
-
-    gl2.bindBuffer(GL.COPY_READ_BUFFER, source.handle);
-    gl2.bindBuffer(GL.COPY_WRITE_BUFFER, destination.handle);
-    gl2.copyBufferSubData(GL.COPY_READ_BUFFER, GL.COPY_WRITE_BUFFER, (_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(GL.COPY_READ_BUFFER, null);
-    gl2.bindBuffer(GL.COPY_WRITE_BUFFER, 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(36662, source.handle);
+    device.gl.bindBuffer(36663, destination.handle);
+    device.gl.copyBufferSubData(36662, 36663, options.sourceOffset ?? 0, options.destinationOffset ?? 0, options.size);
+    device.gl.bindBuffer(36662, null);
+    device.gl.bindBuffer(36663, 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');
+}
+/**
+ * Copies data from a Texture object into a Buffer object.
+ * NOTE: doesn't wait for copy to be complete
+ */
+function _copyTextureToBuffer(device, options) {
+    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(35051, webglBuffer.handle);
+        device.gl.bindFramebuffer(36160, framebuffer.handle);
+        device.gl.readPixels(origin[0], origin[1], sourceWidth, sourceHeight, sourceFormat, sourceType, byteOffset);
+    }
+    finally {
+        device.gl.bindBuffer(35051, null);
+        device.gl.bindFramebuffer(36160, 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 { 
+    /** 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
+    /**  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 = 6408;
+    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(36160, 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;
+        // 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;
+        // 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 };
 }
-
-function _copyBufferToTexture(device, options) {}
-
-function _copyTextureToBuffer(device, options) {}
-
-function _copyTextureToTexture(device, options) {}
-//# sourceMappingURL=webgl-command-buffer.js.map

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

@@ -1,12 +1,13 @@
-import { CommandEncoder, CommandEncoderProps } from '@luma.gl/api';
-import type { CopyBufferToBufferOptions, CopyBufferToTextureOptions, CopyTextureToBufferOptions, CopyTextureToTextureOptions } from '@luma.gl/api';
-import CommandBuffer from './webgl-command-buffer';
-import WebGLDevice from '../webgl-device';
-export default class WEBGLCommandEncoder extends CommandEncoder {
+import { CommandEncoder, CommandEncoderProps } from '@luma.gl/core';
+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: CommandBuffer;
+    readonly commandBuffer: WEBGLCommandBuffer;
     constructor(device: WebGLDevice, props: CommandEncoderProps);
     destroy(): void;
+    finish(): void;
     copyBufferToBuffer(options: CopyBufferToBufferOptions): void;
     copyBufferToTexture(options: CopyBufferToTextureOptions): void;
     copyTextureToBuffer(options: CopyTextureToBufferOptions): void;
@@ -14,5 +15,10 @@ export default 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":"AAAA,OAAO,EAAC,cAAc,EAAE,mBAAmB,EAAC,MAAM,cAAc,CAAC;AACjE,OAAO,KAAK,EACV,yBAAyB,EACzB,0BAA0B,EAC1B,0BAA0B,EAC1B,2BAA2B,EAC5B,MAAM,cAAc,CAAC;AAEtB,OAAO,aAAa,MAAM,wBAAwB,CAAC;AACnD,OAAO,WAAW,MAAM,iBAAiB,CAAC;AAE1C,MAAM,CAAC,OAAO,OAAO,mBAAoB,SAAQ,cAAc;IAC7D,QAAQ,CAAC,MAAM,EAAE,WAAW,CAAC;IAE7B,QAAQ,CAAC,aAAa,gBAAuB;gBAEjC,MAAM,EAAE,WAAW,EAAE,KAAK,EAAE,mBAAmB;IAK3D,OAAO;IAMP,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;IAIhE,cAAc,CAAC,UAAU,EAAE,MAAM,GAAG,IAAI;IACxC,aAAa;IAEb,iBAAiB,CAAC,WAAW,EAAE,MAAM,GAAG,IAAI;CAW7C"}
+{"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,53 +1,37 @@
-import _defineProperty from "@babel/runtime/helpers/esm/defineProperty";
-import { CommandEncoder } from '@luma.gl/api';
-import CommandBuffer from './webgl-command-buffer';
-export default class WEBGLCommandEncoder extends CommandEncoder {
-  constructor(device, props) {
-    super(props);
-
-    _defineProperty(this, "device", void 0);
-
-    _defineProperty(this, "commandBuffer", new CommandBuffer());
-
-    this.device = device;
-  }
-
-  destroy() {}
-
-  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) {}
-
+// 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 {
+    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 , props: TextureProps) {
+    super(device as WebGLDevice, {id: uid('texture'), ...props});
+
+    this.glTarget = getWebGLTextureTarget(props);
+
+    this.device = device as WebGLDevice;
+    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;
+    }
+  }
+
+
+*/

package/dist/adapter/resources/webgl-framebuffer.d.ts

@@ -1,41 +1,33 @@
-import type { FramebufferProps, ColorTextureFormat } from '@luma.gl/api';
-import { Framebuffer, Texture } from '@luma.gl/api';
-import GL from '@luma.gl/constants';
-import WebGLDevice from '../webgl-device';
-import WebGLTexture from './webgl-texture';
-import Renderbuffer from '../objects/webgl-renderbuffer';
-export declare type TextureAttachment = [Texture, number?, number?];
-export declare type Attachment = WebGLTexture | Renderbuffer | TextureAttachment;
+import type { FramebufferProps, TextureFormat } from '@luma.gl/core';
+import { Framebuffer, Texture } from '@luma.gl/core';
+import { GL } from '@luma.gl/constants';
+import { WebGLDevice } from "../webgl-device.js";
+import { WEBGLTexture } from "./webgl-texture.js";
+import { WEBGLTextureView } from "./webgl-texture-view.js";
+export type Attachment = WEBGLTextureView | WEBGLTexture;
 /** luma.gl Framebuffer, WebGL implementation  */
-export default class WEBGLFramebuffer extends Framebuffer {
+export declare class WEBGLFramebuffer extends Framebuffer {
     device: WebGLDevice;
-    gl: WebGLRenderingContext;
+    gl: WebGL2RenderingContext;
     handle: WebGLFramebuffer;
-    get texture(): WebGLTexture;
-    readonly colorAttachments: WebGLTexture[];
-    readonly depthStencilAttachment: WebGLTexture | null;
-    d: any;
-    protected _ownResources: (WebGLTexture | Renderbuffer)[];
+    get texture(): import("@luma.gl/core").TextureView;
     constructor(device: WebGLDevice, props: FramebufferProps);
+    /** destroys any auto created resources etc. */
     destroy(): void;
-    /** Check the status */
-    protected _checkStatus(): void;
-    _createColorAttachments(): WebGLTexture[];
-    /** Create a color attachment */
-    protected _createColorAttachment(format: ColorTextureFormat, width: number, height: number): WebGLTexture;
-    /** Create a depth stencil attachment GL.DEPTH24_STENCIL8 */
-    protected _createDepthStencilAttachment(): Renderbuffer | WebGLTexture;
-    /** Attachment resize is expected to be a noop if size is same */
-    protected _resizeAttachments(width: number, height: number): this;
+    /** In WebGL we must use renderbuffers for depth/stencil attachments (unless we have extensions) */
+    protected createDepthStencilTexture(format: TextureFormat): Texture;
+    /**
+     * Attachment resize is expected to be a noop if size is same
+     */
+    protected resizeAttachments(width: number, height: number): this;
     /** Attach one attachment */
-    protected _attachOne(attachmentPoint: GL, attachment: Attachment): WebGLTexture | Renderbuffer;
-    protected _attachRenderbuffer(attachment: GL, renderbuffer: Renderbuffer): void;
+    protected _attachOne(attachmentPoint: GL, attachment: Attachment): WEBGLTexture;
     /**
      * @param attachment
      * @param texture
-     * @param layer = 0 - index into WebGLTextureArray and Texture3D or face for `TextureCubeMap`
-     * @param level  = 0 - mipmapLevel (must be 0 in WebGL1)
+     * @param layer = 0 - index into WEBGLTextureArray and Texture3D or face for `TextureCubeMap`
+     * @param level = 0 - mipmapLevel
      */
-    protected _attachTexture(attachment: GL, texture: WebGLTexture, layer: number, level: number): void;
+    protected _attachTexture(attachment: GL, texture: WEBGLTexture, layer: number, level: number): void;
 }
 //# sourceMappingURL=webgl-framebuffer.d.ts.map

package/dist/adapter/resources/webgl-framebuffer.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"webgl-framebuffer.d.ts","sourceRoot":"","sources":["../../../src/adapter/resources/webgl-framebuffer.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAC,gBAAgB,EAA6B,kBAAkB,EAAC,MAAM,cAAc,CAAC;AAClG,OAAO,EAAC,WAAW,EAAE,OAAO,EAAc,MAAM,cAAc,CAAC;AAC/D,OAAO,EAAE,MAAM,oBAAoB,CAAC;AACpC,OAAO,WAAW,MAAM,iBAAiB,CAAC;AAC1C,OAAO,YAAY,MAAM,iBAAiB,CAAC;AAC3C,OAAO,YAAY,MAAM,+BAA+B,CAAC;AAGzD,oBAAY,iBAAiB,GAAG,CAAC,OAAO,EAAE,MAAM,CAAC,EAAE,MAAM,CAAC,CAAC,CAAC;AAC5D,oBAAY,UAAU,GAAG,YAAY,GAAG,YAAY,GAAG,iBAAiB,CAAC;AAEzE,iDAAiD;AACjD,MAAM,CAAC,OAAO,OAAO,gBAAiB,SAAQ,WAAW;IACvD,MAAM,EAAE,WAAW,CAAC;IACpB,EAAE,EAAE,qBAAqB,CAAC;IAC1B,MAAM,EAAE,gBAAgB,CAAC;IAEzB,IAAI,OAAO,iBAAuC;IAClD,QAAQ,CAAC,gBAAgB,EAAE,YAAY,EAAE,CAAM;IAC/C,QAAQ,CAAC,sBAAsB,EAAE,YAAY,GAAG,IAAI,CAAQ;IAAE,CAAC,MAAA;IAC/D,SAAS,CAAC,aAAa,EAAE,CAAC,YAAY,GAAG,YAAY,CAAC,EAAE,CAAM;gBAElD,MAAM,EAAE,WAAW,EAAE,KAAK,EAAE,gBAAgB;IAwCxD,OAAO;IAaP,uBAAuB;IACvB,SAAS,CAAC,YAAY,IAAI,IAAI;IAW9B,uBAAuB,IAAI,YAAY,EAAE;IAgBzC,gCAAgC;IAChC,SAAS,CAAC,sBAAsB,CAAC,MAAM,EAAE,kBAAkB,EAAE,KAAK,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,GAAG,YAAY;IAgCzG,4DAA4D;IAC5D,SAAS,CAAC,6BAA6B,IAAI,YAAY,GAAG,YAAY;IAyBtE,iEAAiE;IACjE,SAAS,CAAC,kBAAkB,CAAC,KAAK,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,GAAG,IAAI;IA0BjE,4BAA4B;IAC5B,SAAS,CAAC,UAAU,CAAC,eAAe,EAAE,EAAE,EAAE,UAAU,EAAE,UAAU,GAAG,YAAY,GAAG,YAAY;IAc9F,SAAS,CAAC,mBAAmB,CAAC,UAAU,EAAE,EAAE,EAAE,YAAY,EAAE,YAAY,GAAG,IAAI;IAS/E;;;;;OAKG;IACF,SAAS,CAAC,cAAc,CAAC,UAAU,EAAE,EAAE,EAAE,OAAO,EAAE,YAAY,EAAE,KAAK,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,GAAG,IAAI;CA2BrG"}
+{"version":3,"file":"webgl-framebuffer.d.ts","sourceRoot":"","sources":["../../../src/adapter/resources/webgl-framebuffer.ts"],"names":[],"mappings":"AAIA,OAAO,KAAK,EAAC,gBAAgB,EAAE,aAAa,EAAC,MAAM,eAAe,CAAC;AACnE,OAAO,EAAC,WAAW,EAAE,OAAO,EAAS,MAAM,eAAe,CAAC;AAC3D,OAAO,EAAC,EAAE,EAAC,MAAM,oBAAoB,CAAC;AACtC,OAAO,EAAC,WAAW,EAAC,2BAAwB;AAC5C,OAAO,EAAC,YAAY,EAAC,2BAAwB;AAC7C,OAAO,EAAC,gBAAgB,EAAC,gCAA6B;AAMtD,MAAM,MAAM,UAAU,GAAG,gBAAgB,GAAG,YAAY,CAAC;AAEzD,iDAAiD;AACjD,qBAAa,gBAAiB,SAAQ,WAAW;IAC/C,MAAM,EAAE,WAAW,CAAC;IACpB,EAAE,EAAE,sBAAsB,CAAC;IAC3B,MAAM,EAAE,gBAAgB,CAAC;IAEzB,IAAI,OAAO,wCAEV;gBAEW,MAAM,EAAE,WAAW,EAAE,KAAK,EAAE,gBAAgB;IAkDxD,+CAA+C;IACtC,OAAO,IAAI,IAAI;IAUxB,mGAAmG;cAChF,yBAAyB,CAAC,MAAM,EAAE,aAAa,GAAG,OAAO;IAW5E;;OAEG;cACgB,iBAAiB,CAAC,KAAK,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,GAAG,IAAI;IA2BzE,4BAA4B;IAC5B,SAAS,CAAC,UAAU,CAAC,eAAe,EAAE,EAAE,EAAE,UAAU,EAAE,UAAU,GAAG,YAAY;IAqC/E;;;;;OAKG;IACH,SAAS,CAAC,cAAc,CACtB,UAAU,EAAE,EAAE,EACd,OAAO,EAAE,YAAY,EACrB,KAAK,EAAE,MAAM,EACb,KAAK,EAAE,MAAM,GACZ,IAAI;CA2BR"}