@luma.gl/webgl 9.0.0-alpha.14 → 9.0.0-alpha.16

package/dist/adapter/objects/webgl-vertex-array-object.js

@@ -1,84 +1,82 @@
 import { assert } from '@luma.gl/api';
 import GL from '@luma.gl/constants';
 import { getBrowser } from '@probe.gl/env';
-import WebGLResource from './webgl-resource';
+import WebGLResource from './webgl-resource.js';
 const ERR_ELEMENTS = 'elements must be GL.ELEMENT_ARRAY_BUFFER';
+/** VertexArrayObject wrapper */
 export default class WEBGLVertexArrayObject extends WebGLResource {
-  get [Symbol.toStringTag]() {
-    return 'BaseVertexArrayObject';
-  }
-
-  constructor(device, props) {
-    super(device, props, {});
-  }
-
-  _createHandle() {
-    return this.gl2.createVertexArray();
-  }
-
-  _deleteHandle() {
-    this.gl2.deleteVertexArray(this.handle);
-    return [this.elements];
-  }
-
-  _bindHandle(handle) {
-    this.gl2.bindVertexArray(handle);
-  }
-
-  setElementBuffer(elementBuffer = null, opts = {}) {
-    assert(!elementBuffer || elementBuffer.target === GL.ELEMENT_ARRAY_BUFFER, ERR_ELEMENTS);
-    this.bind(() => {
-      this.gl.bindBuffer(GL.ELEMENT_ARRAY_BUFFER, elementBuffer ? elementBuffer.handle : null);
-    });
-    return this;
-  }
-
-  setBuffer(location, buffer, accessor) {
-    if (buffer.target === GL.ELEMENT_ARRAY_BUFFER) {
-      return this.setElementBuffer(buffer, accessor);
+    get [Symbol.toStringTag]() {
+        return 'BaseVertexArrayObject';
     }
-
-    const {
-      size,
-      type,
-      stride,
-      offset,
-      normalized,
-      integer,
-      divisor
-    } = accessor;
-    const {
-      gl,
-      gl2
-    } = this;
-    location = Number(location);
-    this.bind(() => {
-      gl.bindBuffer(gl.ARRAY_BUFFER, buffer.handle);
-
-      if (integer) {
-        this.device.assertWebGL2();
-        gl2.vertexAttribIPointer(location, size, type, stride, offset);
-      } else {
-        gl.vertexAttribPointer(location, size, type, normalized, stride, offset);
-      }
-
-      gl.enableVertexAttribArray(location);
-      gl2.vertexAttribDivisor(location, divisor || 0);
-    });
-    return this;
-  }
-
-  enable(location, enable = true) {
-    const canDisableAttributeZero = this.device.isWebGL2 || getBrowser() === 'Chrome';
-    const canDisableAttribute = canDisableAttributeZero || location !== 0;
-
-    if (enable || canDisableAttribute) {
-      location = Number(location);
-      this.bind(() => enable ? this.gl.enableVertexAttribArray(location) : this.gl.disableVertexAttribArray(location));
+    constructor(device, props) {
+        // @ts-expect-error
+        super(device, props, {});
+    }
+    _createHandle() {
+        return this.gl2.createVertexArray();
+    }
+    _deleteHandle() {
+        this.gl2.deleteVertexArray(this.handle);
+        // @ts-expect-error
+        return [this.elements];
+        // return [this.elements, ...this.buffers];
+    }
+    _bindHandle(handle) {
+        this.gl2.bindVertexArray(handle);
+    }
+    // Set (bind) an elements buffer, for indexed rendering.
+    // Must be a Buffer bound to GL.ELEMENT_ARRAY_BUFFER. Constants not supported
+    setElementBuffer(elementBuffer = null, opts = {}) {
+        assert(!elementBuffer || elementBuffer.target === GL.ELEMENT_ARRAY_BUFFER, ERR_ELEMENTS);
+        // The GL.ELEMENT_ARRAY_BUFFER_BINDING is stored on the VertexArrayObject...
+        this.bind(() => {
+            this.gl.bindBuffer(GL.ELEMENT_ARRAY_BUFFER, elementBuffer ? elementBuffer.handle : null);
+        });
+        return this;
+    }
+    /** Set a location in vertex attributes array to a buffer, enables the location, sets divisor */
+    setBuffer(location, buffer, accessor) {
+        // Check target
+        if (buffer.target === GL.ELEMENT_ARRAY_BUFFER) {
+            return this.setElementBuffer(buffer, accessor);
+        }
+        const { size, type, stride, offset, normalized, integer, divisor } = accessor;
+        const { gl, gl2 } = this;
+        location = Number(location);
+        this.bind(() => {
+            // A non-zero buffer object must be bound to the GL_ARRAY_BUFFER target
+            gl.bindBuffer(gl.ARRAY_BUFFER, buffer.handle);
+            // WebGL2 supports *integer* data formats, i.e. GPU will see integer values
+            if (integer) {
+                this.device.assertWebGL2();
+                gl2.vertexAttribIPointer(location, size, type, stride, offset);
+            }
+            else {
+                // Attaches ARRAY_BUFFER with specified buffer format to location
+                gl.vertexAttribPointer(location, size, type, normalized, stride, offset);
+            }
+            gl.enableVertexAttribArray(location);
+            gl2.vertexAttribDivisor(location, divisor || 0);
+            // NOTE We don't unbind buffer here, typically another buffer will be bound just after
+        });
+        return this;
+    }
+    /**
+     * Enabling an attribute location makes it reference the currently bound buffer
+     *  Disabling an attribute location makes it reference the global constant value
+     * TODO - handle single values for size 1 attributes?
+     * TODO - convert classic arrays based on known type?
+     */
+    enable(location, enable = true) {
+        // Attribute 0 cannot be disabled in most desktop OpenGL based browsers...
+        const canDisableAttributeZero = this.device.isWebGL2 || getBrowser() === 'Chrome';
+        const canDisableAttribute = canDisableAttributeZero || location !== 0;
+        if (enable || canDisableAttribute) {
+            location = Number(location);
+            this.bind(() => enable
+                ? this.gl.enableVertexAttribArray(location)
+                : this.gl.disableVertexAttribArray(location));
+        }
+        return this;
     }
-
-    return this;
-  }
-
 }
-//# sourceMappingURL=webgl-vertex-array-object.js.map

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

@@ -1,162 +1,165 @@
-import _defineProperty from "@babel/runtime/helpers/esm/defineProperty";
 import { Buffer, assert } from '@luma.gl/api';
 import GL from '@luma.gl/constants';
 const DEBUG_DATA_LENGTH = 10;
+/** WebGL Buffer interface */
 export default class WEBGLBuffer extends Buffer {
-  constructor(device, props = {}) {
-    super(device, props);
-
-    _defineProperty(this, "device", void 0);
-
-    _defineProperty(this, "gl", void 0);
-
-    _defineProperty(this, "gl2", void 0);
-
-    _defineProperty(this, "handle", void 0);
-
-    _defineProperty(this, "target", void 0);
-
-    _defineProperty(this, "byteLength", void 0);
-
-    _defineProperty(this, "bytesUsed", void 0);
-
-    _defineProperty(this, "debugData", null);
-
-    _defineProperty(this, "webglUsage", void 0);
-
-    this.device = device;
-    this.gl = this.device.gl;
-    this.gl2 = this.device.gl2;
-    const handle = typeof props === 'object' ? props.handle : undefined;
-    this.handle = handle || this.gl.createBuffer();
-    this.handle.__SPECTOR_Metadata = { ...this.props,
-      data: typeof this.props.data
-    };
-    this.target = this.props.target || getWebGLTarget(this.props.usage);
-    this.webglUsage = this.props.webglUsage || getWebGLUsage(this.props.usage);
-    this.debugData = null;
-
-    if (props.data) {
-      this._initWithData(props.data, props.byteOffset, props.byteLength);
-    } else {
-      this._initWithByteLength(props.byteLength || 0);
+    // accessor: {};
+    constructor(device, props = {}) {
+        super(device, props);
+        this.debugData = null;
+        this.device = device;
+        this.gl = this.device.gl;
+        this.gl2 = this.device.gl2;
+        const handle = typeof props === 'object' ? props.handle : undefined;
+        this.handle = handle || this.gl.createBuffer();
+        // @ts-expect-error Add metadata for spector
+        this.handle.__SPECTOR_Metadata = { ...this.props, data: typeof this.props.data }; // {name: this.props.id};
+        // In WebGL1, need to make sure we use GL.ELEMENT_ARRAY_BUFFER when initializing element buffers
+        // otherwise buffer type will lock to generic (non-element) buffer
+        // In WebGL2, we can use GL.COPY_READ_BUFFER which avoids locking the type here
+        // @ts-expect-error Hack - Checking for subclass prop
+        this.target = this.props.target || getWebGLTarget(this.props.usage);
+        // @ts-expect-error Hack - Checking for subclass prop
+        this.webglUsage = this.props.webglUsage || getWebGLUsage(this.props.usage);
+        this.debugData = null;
+        // Set data: (re)initializes the buffer
+        if (props.data) {
+            this._initWithData(props.data, props.byteOffset, props.byteLength);
+        }
+        else {
+            this._initWithByteLength(props.byteLength || 0);
+        }
+        // Deprecated: Merge main props and accessor
+        // this.accessor = {...props.accessor};
+        // Object.seal(this);
     }
-  }
-
-  _initWithData(data, byteOffset = 0, byteLength = data.byteLength + byteOffset) {
-    assert(ArrayBuffer.isView(data));
-
-    const target = this._getWriteTarget();
-
-    this.gl.bindBuffer(target, this.handle);
-    this.gl.bufferData(target, byteLength, this.webglUsage);
-    this.gl.bufferSubData(target, byteOffset, data);
-    this.gl.bindBuffer(target, null);
-    this.debugData = data.slice(0, DEBUG_DATA_LENGTH);
-    this.bytesUsed = byteLength;
-    this.byteLength = byteLength;
-    this.trackAllocatedMemory(byteLength);
-    return this;
-  }
-
-  _initWithByteLength(byteLength) {
-    assert(byteLength >= 0);
-    let data = byteLength;
-
-    if (byteLength === 0) {
-      data = new Float32Array(0);
+    // PRIVATE METHODS
+    // Allocate a new buffer and initialize to contents of typed array
+    _initWithData(data, byteOffset = 0, byteLength = data.byteLength + byteOffset) {
+        assert(ArrayBuffer.isView(data));
+        const target = this._getWriteTarget();
+        this.gl.bindBuffer(target, this.handle);
+        this.gl.bufferData(target, byteLength, this.webglUsage);
+        this.gl.bufferSubData(target, byteOffset, data);
+        this.gl.bindBuffer(target, null);
+        this.debugData = data.slice(0, DEBUG_DATA_LENGTH);
+        this.bytesUsed = byteLength;
+        this.byteLength = byteLength;
+        this.trackAllocatedMemory(byteLength);
+        return this;
     }
-
-    const target = this._getWriteTarget();
-
-    this.gl.bindBuffer(target, this.handle);
-    this.gl.bufferData(target, data, this.webglUsage);
-    this.gl.bindBuffer(target, null);
-    this.debugData = null;
-    this.bytesUsed = byteLength;
-    this.byteLength = byteLength;
-    return this;
-  }
-
-  destroy() {
-    if (!this.destroyed && this.handle) {
-      this.removeStats();
-      this.trackDeallocatedMemory();
-      this.gl.deleteBuffer(this.handle);
-      this.destroyed = true;
+    // Allocate a GPU buffer of specified size.
+    _initWithByteLength(byteLength) {
+        assert(byteLength >= 0);
+        // Workaround needed for Safari (#291):
+        // gl.bufferData with size equal to 0 crashes. Instead create zero sized array.
+        let data = byteLength;
+        if (byteLength === 0) {
+            // @ts-expect-error
+            data = new Float32Array(0);
+        }
+        const target = this._getWriteTarget();
+        this.gl.bindBuffer(target, this.handle);
+        this.gl.bufferData(target, data, this.webglUsage);
+        this.gl.bindBuffer(target, null);
+        this.debugData = null;
+        this.bytesUsed = byteLength;
+        this.byteLength = byteLength;
+        return this;
     }
-  }
-
-  write(data, byteOffset = 0) {
-    const srcOffset = 0;
-    const byteLength = data.byteLength;
-    const target = this.device.isWebGL2 ? GL.COPY_WRITE_BUFFER : this.target;
-    this.gl.bindBuffer(target, this.handle);
-
-    if (srcOffset !== 0 || byteLength !== undefined) {
-      this.device.assertWebGL2();
-      this.gl.bufferSubData(this.target, offset, data, srcOffset, byteLength);
-    } else {
-      this.gl.bufferSubData(target, byteOffset, data);
+    destroy() {
+        if (!this.destroyed && this.handle) {
+            this.removeStats();
+            this.trackDeallocatedMemory();
+            this.gl.deleteBuffer(this.handle);
+            this.destroyed = true;
+            // this.handle = null;
+        }
+    }
+    write(data, byteOffset = 0) {
+        const srcOffset = 0;
+        const byteLength = data.byteLength;
+        // Create the buffer - binding it here for the first time locks the type
+        // In WebGL2, use GL.COPY_WRITE_BUFFER to avoid locking the type
+        const target = this.device.isWebGL2 ? GL.COPY_WRITE_BUFFER : this.target;
+        this.gl.bindBuffer(target, this.handle);
+        // WebGL2: subData supports additional srcOffset and length parameters
+        if (srcOffset !== 0 || byteLength !== undefined) {
+            this.device.assertWebGL2();
+            // @ts-expect-error
+            this.gl.bufferSubData(this.target, offset, data, srcOffset, byteLength);
+        }
+        else {
+            this.gl.bufferSubData(target, byteOffset, data);
+        }
+        this.gl.bindBuffer(target, null);
+        // TODO - update local `data` if offsets are right
+        // this.debugData = data.slice(byteOffset, 40);
+    }
+    /** Read data from the buffer */
+    async readAsync(byteOffset = 0, byteLength) {
+        this.device.assertWebGL2();
+        const data = new Uint8Array(byteLength);
+        const dstOffset = 0;
+        // Use GL.COPY_READ_BUFFER to avoid disturbing other targets and locking type
+        this.gl.bindBuffer(GL.COPY_READ_BUFFER, this.handle);
+        this.gl2.getBufferSubData(GL.COPY_READ_BUFFER, byteOffset, data, dstOffset, byteLength);
+        this.gl.bindBuffer(GL.COPY_READ_BUFFER, null);
+        // TODO - update local `data` if offsets are 0
+        // this.debugData = null;
+        return data;
+    }
+    // PROTECTED METHODS (INTENDED FOR USE BY OTHER FRAMEWORK CODE ONLY)
+    _invalidateDebugData() {
+        this.debugData = null;
+    }
+    _getWriteTarget() {
+        return this.target;
+        // return this.device.isWebGL2 ? GL.COPY_WRITE_BUFFER : this.target;
+    }
+    _getReadTarget() {
+        return this.target;
+        return this.device.isWebGL2 ? GL.COPY_READ_BUFFER : this.target;
     }
-
-    this.gl.bindBuffer(target, null);
-  }
-
-  async readAsync(byteOffset = 0, byteLength) {
-    this.device.assertWebGL2();
-    const data = new Uint8Array(byteLength);
-    const dstOffset = 0;
-    this.gl.bindBuffer(GL.COPY_READ_BUFFER, this.handle);
-    this.gl2.getBufferSubData(GL.COPY_READ_BUFFER, byteOffset, data, dstOffset, byteLength);
-    this.gl.bindBuffer(GL.COPY_READ_BUFFER, null);
-    return data;
-  }
-
-  _invalidateDebugData() {
-    this.debugData = null;
-  }
-
-  _getWriteTarget() {
-    return this.target;
-  }
-
-  _getReadTarget() {
-    return this.target;
-    return this.device.isWebGL2 ? GL.COPY_READ_BUFFER : this.target;
-  }
-
 }
-
+// static MAP_READ = 0x01;
+// static MAP_WRITE = 0x02;
+// static COPY_SRC = 0x0004;
+// static COPY_DST = 0x0008;
+// static INDEX = 0x0010;
+// static VERTEX = 0x0020;
+// static UNIFORM = 0x0040;
+// static STORAGE = 0x0080;
+// static INDIRECT = 0x0100;
+// static QUERY_RESOLVE = 0x0200;
 function getWebGLTarget(usage) {
-  if (usage & Buffer.INDEX) {
-    return GL.ELEMENT_ARRAY_BUFFER;
-  }
-
-  if (usage & Buffer.VERTEX) {
+    if (usage & Buffer.INDEX) {
+        return GL.ELEMENT_ARRAY_BUFFER;
+    }
+    if (usage & Buffer.VERTEX) {
+        return GL.ARRAY_BUFFER;
+    }
+    if (usage & Buffer.UNIFORM) {
+        return GL.UNIFORM_BUFFER;
+    }
+    // gl.COPY_READ_BUFFER: Buffer for copying from one buffer object to another.
+    // gl.COPY_WRITE_BUFFER: Buffer for copying from one buffer object to another.
+    // gl.TRANSFORM_FEEDBACK_BUFFER: Buffer for transform feedback operations.
+    // gl.PIXEL_PACK_BUFFER: Buffer used for pixel transfer operations.
+    // gl.PIXEL_UNPACK_BUFFER: Buffer used for pixel transfer operations.
+    // Binding a buffer for the first time locks the type
+    // In WebGL2, use GL.COPY_WRITE_BUFFER to avoid locking the type
     return GL.ARRAY_BUFFER;
-  }
-
-  if (usage & Buffer.UNIFORM) {
-    return GL.UNIFORM_BUFFER;
-  }
-
-  return GL.ARRAY_BUFFER;
 }
-
 function getWebGLUsage(usage) {
-  if (usage & Buffer.INDEX) {
-    return GL.STATIC_DRAW;
-  }
-
-  if (usage & Buffer.VERTEX) {
-    return GL.STATIC_DRAW;
-  }
-
-  if (usage & Buffer.UNIFORM) {
+    if (usage & Buffer.INDEX) {
+        return GL.STATIC_DRAW;
+    }
+    if (usage & Buffer.VERTEX) {
+        return GL.STATIC_DRAW;
+    }
+    if (usage & Buffer.UNIFORM) {
+        return GL.DYNAMIC_DRAW;
+    }
     return GL.DYNAMIC_DRAW;
-  }
-
-  return GL.DYNAMIC_DRAW;
 }
-//# sourceMappingURL=webgl-buffer.js.map

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

@@ -1,22 +1,22 @@
 import type { CopyBufferToBufferOptions, CopyBufferToTextureOptions, CopyTextureToBufferOptions, CopyTextureToTextureOptions } from '@luma.gl/api';
 import WebGLDevice from '../webgl-device';
-declare type CopyBufferToBufferCommand = {
+type CopyBufferToBufferCommand = {
     name: 'copy-buffer-to-buffer';
     options: CopyBufferToBufferOptions;
 };
-declare type CopyBufferToTextureCommand = {
+type CopyBufferToTextureCommand = {
     name: 'copy-buffer-to-texture';
     options: CopyBufferToTextureOptions;
 };
-declare type CopyTextureToBufferCommand = {
+type CopyTextureToBufferCommand = {
     name: 'copy-texture-to-buffer';
     options: CopyTextureToBufferOptions;
 };
-declare type CopyTextureToTextureCommand = {
+type CopyTextureToTextureCommand = {
     name: 'copy-texture-to-texture';
     options: CopyTextureToTextureOptions;
 };
-declare type Command = CopyBufferToBufferCommand | CopyBufferToTextureCommand | CopyTextureToBufferCommand | CopyTextureToTextureCommand;
+type Command = CopyBufferToBufferCommand | CopyBufferToTextureCommand | CopyTextureToBufferCommand | CopyTextureToTextureCommand;
 export default class CommandBuffer {
     commands: Command[];
 }

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

@@ -1 +1 @@
-{"version":3,"file":"webgl-command-buffer.d.ts","sourceRoot":"","sources":["../../../src/adapter/resources/webgl-command-buffer.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EACV,yBAAyB,EACzB,0BAA0B,EAC1B,0BAA0B,EAC1B,2BAA2B,EAC5B,MAAM,cAAc,CAAC;AAEtB,OAAO,WAAW,MAAM,iBAAiB,CAAC;AAO1C,aAAK,yBAAyB,GAAG;IAC/B,IAAI,EAAE,uBAAuB,CAAC;IAC9B,OAAO,EAAE,yBAAyB,CAAC;CACpC,CAAC;AAEF,aAAK,0BAA0B,GAAG;IAChC,IAAI,EAAE,wBAAwB,CAAC;IAC/B,OAAO,EAAE,0BAA0B,CAAC;CACrC,CAAC;AAEF,aAAK,0BAA0B,GAAG;IAChC,IAAI,EAAE,wBAAwB,CAAC;IAC/B,OAAO,EAAE,0BAA0B,CAAC;CACrC,CAAC;AAEF,aAAK,2BAA2B,GAAG;IACjC,IAAI,EAAE,yBAAyB,CAAC;IAChC,OAAO,EAAE,2BAA2B,CAAC;CACtC,CAAC;AAEF,aAAK,OAAO,GACR,yBAAyB,GACzB,0BAA0B,GAC1B,0BAA0B,GAC1B,2BAA2B,CAAC;AAEhC,MAAM,CAAC,OAAO,OAAO,aAAa;IAChC,QAAQ,EAAE,OAAO,EAAE,CAAM;CAC1B;AAED,wBAAgB,cAAc,CAAC,MAAM,EAAE,WAAW,EAAE,QAAQ,GAAE,OAAO,EAAO,QAiB3E"}
+{"version":3,"file":"webgl-command-buffer.d.ts","sourceRoot":"","sources":["../../../src/adapter/resources/webgl-command-buffer.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EACV,yBAAyB,EACzB,0BAA0B,EAC1B,0BAA0B,EAC1B,2BAA2B,EAC5B,MAAM,cAAc,CAAC;AAEtB,OAAO,WAAW,MAAM,iBAAiB,CAAC;AAO1C,KAAK,yBAAyB,GAAG;IAC/B,IAAI,EAAE,uBAAuB,CAAC;IAC9B,OAAO,EAAE,yBAAyB,CAAC;CACpC,CAAC;AAEF,KAAK,0BAA0B,GAAG;IAChC,IAAI,EAAE,wBAAwB,CAAC;IAC/B,OAAO,EAAE,0BAA0B,CAAC;CACrC,CAAC;AAEF,KAAK,0BAA0B,GAAG;IAChC,IAAI,EAAE,wBAAwB,CAAC;IAC/B,OAAO,EAAE,0BAA0B,CAAC;CACrC,CAAC;AAEF,KAAK,2BAA2B,GAAG;IACjC,IAAI,EAAE,yBAAyB,CAAC;IAChC,OAAO,EAAE,2BAA2B,CAAC;CACtC,CAAC;AAEF,KAAK,OAAO,GACR,yBAAyB,GACzB,0BAA0B,GAC1B,0BAA0B,GAC1B,2BAA2B,CAAC;AAEhC,MAAM,CAAC,OAAO,OAAO,aAAa;IAChC,QAAQ,EAAE,OAAO,EAAE,CAAM;CAC1B;AAED,wBAAgB,cAAc,CAAC,MAAM,EAAE,WAAW,EAAE,QAAQ,GAAE,OAAO,EAAO,QAiB3E"}

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

@@ -1,65 +1,49 @@
-import _defineProperty from "@babel/runtime/helpers/esm/defineProperty";
 import GL from '@luma.gl/constants';
-
 function cast(value) {
-  return value;
+    return value;
 }
-
 export default class CommandBuffer {
-  constructor() {
-    _defineProperty(this, "commands", []);
-  }
-
+    constructor() {
+        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;
+    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;
+        }
     }
-  }
 }
-
 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);
+    const { gl2 } = device;
+    if (gl2) {
+        // In WebGL2 we can perform the copy on the GPU
+        // Use GL.COPY_READ_BUFFER+GL.COPY_WRITE_BUFFER avoid disturbing other targets and locking type
+        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 ?? 0, options.destinationOffset ?? 0, options.size);
+        gl2.bindBuffer(GL.COPY_READ_BUFFER, null);
+        gl2.bindBuffer(GL.COPY_WRITE_BUFFER, null);
+    }
+    else {
+        // TODO - in WebGL1 we would have to read back to CPU
+        // read / write buffer from / to CPU
+        throw new Error('copyBufferToBuffer not implemented in WebGL1');
+    }
 }
-
-function _copyBufferToTexture(device, options) {}
-
-function _copyTextureToBuffer(device, options) {}
-
-function _copyTextureToTexture(device, options) {}
-//# sourceMappingURL=webgl-command-buffer.js.map
+function _copyBufferToTexture(device, options) { }
+function _copyTextureToBuffer(device, options) { }
+function _copyTextureToTexture(device, options) { }