@luma.gl/webgpu 9.0.0-beta.3 → 9.0.0-beta.5

package/dist/adapter/helpers/webgpu-parameters.js

@@ -1,137 +1,194 @@
 function addDepthStencil(descriptor) {
-  descriptor.depthStencil = descriptor.depthStencil || {
-    format: 'depth24plus',
-    stencilFront: {},
-    stencilBack: {},
-    depthWriteEnabled: false,
-    depthCompare: 'less-equal'
-  };
-  return descriptor.depthStencil;
+    descriptor.depthStencil = descriptor.depthStencil || {
+        // required, set something
+        format: 'depth24plus',
+        stencilFront: {},
+        stencilBack: {},
+        // TODO can this cause trouble? Should we set to WebGPU defaults? Are there defaults?
+        depthWriteEnabled: false,
+        depthCompare: 'less-equal'
+    };
+    return descriptor.depthStencil;
 }
+/**
+ * Supports for luma.gl's flat parameter space
+ * Populates the corresponding sub-objects in a GPURenderPipelineDescriptor
+ */
+// @ts-expect-error
 export const PARAMETER_TABLE = {
-  cullMode: (parameter, value, descriptor) => {
-    descriptor.primitive = descriptor.primitive || {};
-    descriptor.primitive.cullMode = value;
-  },
-  frontFace: (parameter, value, descriptor) => {
-    descriptor.primitive = descriptor.primitive || {};
-    descriptor.primitive.frontFace = value;
-  },
-  depthWriteEnabled: (parameter, value, descriptor) => {
-    const depthStencil = addDepthStencil(descriptor);
-    depthStencil.depthWriteEnabled = value;
-  },
-  depthCompare: (parameter, value, descriptor) => {
-    const depthStencil = addDepthStencil(descriptor);
-    depthStencil.depthCompare = value;
-  },
-  depthFormat: (parameter, value, descriptor) => {
-    const depthStencil = addDepthStencil(descriptor);
-    depthStencil.format = value;
-  },
-  depthBias: (parameter, value, descriptor) => {
-    const depthStencil = addDepthStencil(descriptor);
-    depthStencil.depthBias = value;
-  },
-  depthBiasSlopeScale: (parameter, value, descriptor) => {
-    const depthStencil = addDepthStencil(descriptor);
-    depthStencil.depthBiasSlopeScale = value;
-  },
-  depthBiasClamp: (parameter, value, descriptor) => {
-    const depthStencil = addDepthStencil(descriptor);
-    depthStencil.depthBiasClamp = value;
-  },
-  stencilReadMask: (parameter, value, descriptor) => {
-    const depthStencil = addDepthStencil(descriptor);
-    depthStencil.stencilReadMask = value;
-  },
-  stencilWriteMask: (parameter, value, descriptor) => {
-    const depthStencil = addDepthStencil(descriptor);
-    depthStencil.stencilWriteMask = value;
-  },
-  stencilCompare: (parameter, value, descriptor) => {
-    const depthStencil = addDepthStencil(descriptor);
-    depthStencil.stencilFront.compare = value;
-    depthStencil.stencilBack.compare = value;
-  },
-  stencilPassOperation: (parameter, value, descriptor) => {
-    const depthStencil = addDepthStencil(descriptor);
-    depthStencil.stencilFront.passOp = value;
-    depthStencil.stencilBack.passOp = value;
-  },
-  stencilFailOperation: (parameter, value, descriptor) => {
-    const depthStencil = addDepthStencil(descriptor);
-    depthStencil.stencilFront.failOp = value;
-    depthStencil.stencilBack.failOp = value;
-  },
-  stencilDepthFailOperation: (parameter, value, descriptor) => {
-    const depthStencil = addDepthStencil(descriptor);
-    depthStencil.stencilFront.depthFailOp = value;
-    depthStencil.stencilBack.depthFailOp = value;
-  },
-  sampleCount: (parameter, value, descriptor) => {
-    descriptor.multisample = descriptor.multisample || {};
-    descriptor.multisample.count = value;
-  },
-  sampleMask: (parameter, value, descriptor) => {
-    descriptor.multisample = descriptor.multisample || {};
-    descriptor.multisample.mask = value;
-  },
-  sampleAlphaToCoverageEnabled: (parameter, value, descriptor) => {
-    descriptor.multisample = descriptor.multisample || {};
-    descriptor.multisample.alphaToCoverageEnabled = value;
-  },
-  colorMask: (parameter, value, descriptor) => {
-    const targets = addColorState(descriptor);
-    targets[0].writeMask = value;
-  },
-  blendColorOperation: (parameter, value, descriptor) => {
-    addColorState(descriptor);
-  }
+    // RASTERIZATION PARAMETERS
+    cullMode: (parameter, value, descriptor) => {
+        descriptor.primitive = descriptor.primitive || {};
+        descriptor.primitive.cullMode = value;
+    },
+    frontFace: (parameter, value, descriptor) => {
+        descriptor.primitive = descriptor.primitive || {};
+        descriptor.primitive.frontFace = value;
+    },
+    // DEPTH
+    depthWriteEnabled: (parameter, value, descriptor) => {
+        const depthStencil = addDepthStencil(descriptor);
+        depthStencil.depthWriteEnabled = value;
+    },
+    depthCompare: (parameter, value, descriptor) => {
+        const depthStencil = addDepthStencil(descriptor);
+        depthStencil.depthCompare = value;
+    },
+    depthFormat: (parameter, value, descriptor) => {
+        const depthStencil = addDepthStencil(descriptor);
+        depthStencil.format = value;
+    },
+    depthBias: (parameter, value, descriptor) => {
+        const depthStencil = addDepthStencil(descriptor);
+        depthStencil.depthBias = value;
+    },
+    depthBiasSlopeScale: (parameter, value, descriptor) => {
+        const depthStencil = addDepthStencil(descriptor);
+        depthStencil.depthBiasSlopeScale = value;
+    },
+    depthBiasClamp: (parameter, value, descriptor) => {
+        const depthStencil = addDepthStencil(descriptor);
+        depthStencil.depthBiasClamp = value;
+    },
+    // STENCIL
+    stencilReadMask: (parameter, value, descriptor) => {
+        const depthStencil = addDepthStencil(descriptor);
+        depthStencil.stencilReadMask = value;
+    },
+    stencilWriteMask: (parameter, value, descriptor) => {
+        const depthStencil = addDepthStencil(descriptor);
+        depthStencil.stencilWriteMask = value;
+    },
+    stencilCompare: (parameter, value, descriptor) => {
+        const depthStencil = addDepthStencil(descriptor);
+        depthStencil.stencilFront.compare = value;
+        depthStencil.stencilBack.compare = value;
+    },
+    stencilPassOperation: (parameter, value, descriptor) => {
+        const depthStencil = addDepthStencil(descriptor);
+        depthStencil.stencilFront.passOp = value;
+        depthStencil.stencilBack.passOp = value;
+    },
+    stencilFailOperation: (parameter, value, descriptor) => {
+        const depthStencil = addDepthStencil(descriptor);
+        depthStencil.stencilFront.failOp = value;
+        depthStencil.stencilBack.failOp = value;
+    },
+    stencilDepthFailOperation: (parameter, value, descriptor) => {
+        const depthStencil = addDepthStencil(descriptor);
+        depthStencil.stencilFront.depthFailOp = value;
+        depthStencil.stencilBack.depthFailOp = value;
+    },
+    // MULTISAMPLE
+    sampleCount: (parameter, value, descriptor) => {
+        descriptor.multisample = descriptor.multisample || {};
+        descriptor.multisample.count = value;
+    },
+    sampleMask: (parameter, value, descriptor) => {
+        descriptor.multisample = descriptor.multisample || {};
+        descriptor.multisample.mask = value;
+    },
+    sampleAlphaToCoverageEnabled: (parameter, value, descriptor) => {
+        descriptor.multisample = descriptor.multisample || {};
+        descriptor.multisample.alphaToCoverageEnabled = value;
+    },
+    // COLOR
+    colorMask: (parameter, value, descriptor) => {
+        const targets = addColorState(descriptor);
+        targets[0].writeMask = value;
+    },
+    blendColorOperation: (parameter, value, descriptor) => {
+        addColorState(descriptor);
+        // const targets = addColorState(descriptor);
+        // const target = targets[0];
+        // const blend: GPUBlendState = target.blend || {color: {alpha: 0}};
+        // blend.color = blend.color || {};
+        // target.blend.color.operation = value;
+    }
+    /*
+    blendColorSrcTarget: (parameter, value, descriptor: GPURenderPipelineDescriptor) => {
+      addColorState(descriptor);
+      targets[0].blend = targets[0].blend || {};
+      targets[0].blend.color = targets[0].blend.color || {};
+      targets[0].blend.color.srcTarget = value;
+    },
+  
+    blendColorDstTarget: (parameter, value, descriptor: GPURenderPipelineDescriptor) => {
+      addColorState(descriptor);
+      targets[0].blend = targets[0].blend || {};
+      targets[0].blend.color = targets[0].blend.color || {};
+      targets[0].blend.color.dstTarget = value;
+    },
+  
+    blendAlphaOperation: (parameter, value, descriptor: GPURenderPipelineDescriptor) => {
+      addColorState(descriptor);
+      targets[0].blend = targets[0].blend || {};
+      targets[0].blend.alpha = targets[0].blend.alpha || {};
+      targets[0].blend.alpha.operation = value;
+    },
+  
+    blendAlphaSrcTarget: (parameter, value, descriptor: GPURenderPipelineDescriptor) => {
+      addColorState(descriptor);
+      targets[0].blend = targets[0].blend || {};
+      targets[0].blend.alpha = targets[0].blend.alpha || {};
+      targets[0].blend.alpha.srcTarget = value;
+    },
+  
+    blendAlphaDstTarget: (parameter, value, descriptor: GPURenderPipelineDescriptor) => {
+      addColorState(descriptor);
+      targets[0].blend = targets[0].blend || {};
+      targets[0].blend.alpha = targets[0].blend.alpha || {};
+      targets[0].blend.alpha.dstTarget = value;
+    },
+    */
 };
 const DEFAULT_PIPELINE_DESCRIPTOR = {
-  primitive: {
-    cullMode: 'back',
-    topology: 'triangle-list'
-  },
-  vertex: {
-    module: undefined,
-    entryPoint: 'main'
-  },
-  fragment: {
-    module: undefined,
-    entryPoint: 'main',
-    targets: []
-  },
-  layout: 'auto'
+    // depthStencil: {
+    //   stencilFront: {},
+    //   stencilBack: {},
+    //   // depthWriteEnabled: true,
+    //   // depthCompare: 'less',
+    //   // format: 'depth24plus-stencil8',
+    // },
+    primitive: {
+        cullMode: 'back',
+        topology: 'triangle-list'
+    },
+    vertex: {
+        module: undefined,
+        entryPoint: 'main'
+    },
+    fragment: {
+        module: undefined,
+        entryPoint: 'main',
+        targets: [
+        // { format: props.color0Format || 'bgra8unorm' }
+        ]
+    },
+    layout: 'auto'
 };
-export function applyParametersToRenderPipelineDescriptor(pipelineDescriptor) {
-  let parameters = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
-  Object.assign(pipelineDescriptor, {
-    ...DEFAULT_PIPELINE_DESCRIPTOR,
-    ...pipelineDescriptor
-  });
-  setParameters(pipelineDescriptor, parameters);
+export function applyParametersToRenderPipelineDescriptor(pipelineDescriptor, parameters = {}) {
+    // Apply defaults
+    Object.assign(pipelineDescriptor, { ...DEFAULT_PIPELINE_DESCRIPTOR, ...pipelineDescriptor });
+    setParameters(pipelineDescriptor, parameters);
 }
+// Apply any supplied parameters
 function setParameters(pipelineDescriptor, parameters) {
-  for (const [key, value] of Object.entries(parameters)) {
-    const setterFunction = PARAMETER_TABLE[key];
-    if (!setterFunction) {
-      throw new Error(`Illegal parameter ${key}`);
+    for (const [key, value] of Object.entries(parameters)) {
+        const setterFunction = PARAMETER_TABLE[key];
+        if (!setterFunction) {
+            throw new Error(`Illegal parameter ${key}`);
+        }
+        setterFunction(key, value, pipelineDescriptor);
     }
-    setterFunction(key, value, pipelineDescriptor);
-  }
 }
 function addColorState(descriptor) {
-  var _descriptor$fragment, _descriptor$fragment2, _descriptor$fragment3, _descriptor$fragment4;
-  descriptor.fragment.targets = ((_descriptor$fragment = descriptor.fragment) === null || _descriptor$fragment === void 0 ? void 0 : _descriptor$fragment.targets) || [];
-  if (!Array.isArray((_descriptor$fragment2 = descriptor.fragment) === null || _descriptor$fragment2 === void 0 ? void 0 : _descriptor$fragment2.targets)) {
-    throw new Error('colorstate');
-  }
-  if (((_descriptor$fragment3 = descriptor.fragment) === null || _descriptor$fragment3 === void 0 || (_descriptor$fragment3 = _descriptor$fragment3.targets) === null || _descriptor$fragment3 === void 0 ? void 0 : _descriptor$fragment3.length) === 0) {
-    var _descriptor$fragment$;
-    (_descriptor$fragment$ = descriptor.fragment.targets) === null || _descriptor$fragment$ === void 0 ? void 0 : _descriptor$fragment$.push({});
-  }
-  return (_descriptor$fragment4 = descriptor.fragment) === null || _descriptor$fragment4 === void 0 ? void 0 : _descriptor$fragment4.targets;
+    descriptor.fragment.targets = descriptor.fragment?.targets || [];
+    if (!Array.isArray(descriptor.fragment?.targets)) {
+        throw new Error('colorstate');
+    }
+    if (descriptor.fragment?.targets?.length === 0) {
+        descriptor.fragment.targets?.push({});
+    }
+    return descriptor.fragment?.targets;
 }
-//# sourceMappingURL=webgpu-parameters.js.map

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

@@ -1,70 +1,118 @@
+// WEBGPU Buffer implementation
 import { Buffer } from '@luma.gl/core';
 function getByteLength(props) {
-  var _props$data;
-  return props.byteLength || ((_props$data = props.data) === null || _props$data === void 0 ? void 0 : _props$data.byteLength) || 0;
+    return props.byteLength || props.data?.byteLength || 0;
 }
 export class WebGPUBuffer extends Buffer {
-  constructor(device, props) {
-    super(device, props);
-    this.device = void 0;
-    this.handle = void 0;
-    this.byteLength = void 0;
-    this.device = device;
-    this.byteLength = getByteLength(props);
-    const mapBuffer = Boolean(props.data);
-    const size = Math.ceil(this.byteLength / 4) * 4;
-    this.handle = this.props.handle || this.device.handle.createBuffer({
-      size,
-      usage: this.props.usage || GPUBufferUsage.VERTEX | GPUBufferUsage.COPY_DST,
-      mappedAtCreation: this.props.mappedAtCreation || mapBuffer,
-      label: this.props.id
-    });
-    if (props.data) {
-      this._writeMapped(props.data);
+    device;
+    handle;
+    byteLength;
+    constructor(device, props) {
+        super(device, props);
+        this.device = device;
+        this.byteLength = getByteLength(props);
+        const mapBuffer = Boolean(props.data);
+        // WebGPU buffers must be aligned to 4 bytes
+        const size = Math.ceil(this.byteLength / 4) * 4;
+        this.handle = this.props.handle || this.device.handle.createBuffer({
+            size,
+            // usage defaults to vertex
+            usage: this.props.usage || (GPUBufferUsage.VERTEX | GPUBufferUsage.COPY_DST),
+            mappedAtCreation: this.props.mappedAtCreation || mapBuffer,
+            label: this.props.id
+        });
+        if (props.data) {
+            this._writeMapped(props.data);
+            // this.handle.writeAsync({data: props.data, map: false, unmap: false});
+        }
+        if (mapBuffer && !props.mappedAtCreation) {
+            this.handle.unmap();
+        }
     }
-    if (mapBuffer && !props.mappedAtCreation) {
-      this.handle.unmap();
+    destroy() {
+        this.handle.destroy();
     }
+    // WebGPU provides multiple ways to write a buffer...
+    write(data, byteOffset = 0) {
+        this.device.handle.queue.writeBuffer(this.handle, byteOffset, data.buffer, data.byteOffset, data.byteLength);
+    }
+    async readAsync(byteOffset = 0, byteLength = this.byteLength) {
+        // We need MAP_READ flag, but only COPY_DST buffers can have MAP_READ flag, so we need to create a temp buffer
+        const tempBuffer = new WebGPUBuffer(this.device, { usage: Buffer.MAP_READ | Buffer.COPY_DST, byteLength });
+        // Now do a GPU-side copy into the temp buffer we can actually read.
+        // TODO - we are spinning up an independent command queue here, what does this mean
+        const commandEncoder = this.device.handle.createCommandEncoder();
+        commandEncoder.copyBufferToBuffer(this.handle, byteOffset, tempBuffer.handle, 0, byteLength);
+        this.device.handle.queue.submit([commandEncoder.finish()]);
+        // Map the temp buffer and read the data.
+        await tempBuffer.handle.mapAsync(GPUMapMode.READ, byteOffset, byteLength);
+        const arrayBuffer = tempBuffer.handle.getMappedRange().slice(0);
+        tempBuffer.handle.unmap();
+        tempBuffer.destroy();
+        return new Uint8Array(arrayBuffer);
+    }
+    _writeMapped(typedArray) {
+        const arrayBuffer = this.handle.getMappedRange();
+        // @ts-expect-error
+        new typedArray.constructor(arrayBuffer).set(typedArray);
+    }
+    // WEBGPU API
+    mapAsync(mode, offset = 0, size) {
+        return this.handle.mapAsync(mode, offset, size);
+    }
+    getMappedRange(offset = 0, size) {
+        return this.handle.getMappedRange(offset, size);
+    }
+    unmap() {
+        this.handle.unmap();
+    }
+}
+/*
+// Convenience API
+  /** Read data from the buffer *
+  async readAsync(options: {
+    byteOffset?: number,
+    byteLength?: number,
+    map?: boolean,
+    unmap?: boolean
+  }): Promise<ArrayBuffer> {
+    if (options.map ?? true) {
+      await this.mapAsync(Buffer.MAP_READ, options.byteOffset, options.byteLength);
+    }
+    const arrayBuffer = this.getMappedRange(options.byteOffset, options.byteLength);
+    if (options.unmap ?? true) {
+      this.unmap();
+    }
+    return arrayBuffer;
   }
-  destroy() {
-    this.handle.destroy();
-  }
-  write(data) {
-    let byteOffset = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 0;
-    this.device.handle.queue.writeBuffer(this.handle, byteOffset, data.buffer, data.byteOffset, data.byteLength);
-  }
-  async readAsync() {
-    let byteOffset = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : 0;
-    let byteLength = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : this.byteLength;
-    const tempBuffer = new WebGPUBuffer(this.device, {
-      usage: Buffer.MAP_READ | Buffer.COPY_DST,
-      byteLength
-    });
-    const commandEncoder = this.device.handle.createCommandEncoder();
-    commandEncoder.copyBufferToBuffer(this.handle, byteOffset, tempBuffer.handle, 0, byteLength);
-    this.device.handle.queue.submit([commandEncoder.finish()]);
-    await tempBuffer.handle.mapAsync(GPUMapMode.READ, byteOffset, byteLength);
-    const arrayBuffer = tempBuffer.handle.getMappedRange().slice(0);
-    tempBuffer.handle.unmap();
-    tempBuffer.destroy();
-    return new Uint8Array(arrayBuffer);
-  }
-  _writeMapped(typedArray) {
-    const arrayBuffer = this.handle.getMappedRange();
-    new typedArray.constructor(arrayBuffer).set(typedArray);
-  }
-  mapAsync(mode) {
-    let offset = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 0;
-    let size = arguments.length > 2 ? arguments[2] : undefined;
-    return this.handle.mapAsync(mode, offset, size);
-  }
-  getMappedRange() {
-    let offset = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : 0;
-    let size = arguments.length > 1 ? arguments[1] : undefined;
-    return this.handle.getMappedRange(offset, size);
-  }
-  unmap() {
-    this.handle.unmap();
+
+  /** Write data to the buffer *
+  async writeAsync(options: {
+    data: ArrayBuffer,
+    byteOffset?: number,
+    byteLength?: number,
+    map?: boolean,
+    unmap?: boolean
+  }): Promise<void> {
+    if (options.map ?? true) {
+      await this.mapAsync(Buffer.MAP_WRITE, options.byteOffset, options.byteLength);
+    }
+    const arrayBuffer = this.getMappedRange(options.byteOffset, options.byteLength);
+    const destArray = new Uint8Array(arrayBuffer);
+    const srcArray = new Uint8Array(options.data);
+    destArray.set(srcArray);
+    if (options.unmap ?? true) {
+      this.unmap();
+    }
   }
-}
-//# sourceMappingURL=webgpu-buffer.js.map
+  */
+// Mapped API (WebGPU)
+/** Maps the memory so that it can be read *
+  // abstract mapAsync(mode, byteOffset, byteLength): Promise<void>
+
+  /** Get the mapped range of data for reading or writing *
+  // abstract getMappedRange(byteOffset, byteLength): ArrayBuffer;
+
+  /** unmap makes the contents of the buffer available to the GPU again *
+  // abstract unmap(): void;
+*/

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

@@ -1,52 +1,76 @@
 import { CommandEncoder } from '@luma.gl/core';
 export class WebGPUCommandEncoder extends CommandEncoder {
-  constructor(device, props) {
-    super(device, props);
-    this.device = void 0;
-    this.handle = void 0;
-    this.device = device;
-    this.handle = props.handle || this.device.handle.createCommandEncoder({});
-    this.handle.label = this.props.id;
-  }
-  destroy() {}
-  finish(options) {
-    return this.finish(options);
-  }
-  copyBufferToBuffer(options) {
-    var _options$sourceOffset, _options$destinationO, _options$size;
-    const webgpuSourceBuffer = options.source;
-    const WebGPUDestinationBuffer = options.destination;
-    this.handle.copyBufferToBuffer(webgpuSourceBuffer.handle, (_options$sourceOffset = options.sourceOffset) !== null && _options$sourceOffset !== void 0 ? _options$sourceOffset : 0, WebGPUDestinationBuffer.handle, (_options$destinationO = options.destinationOffset) !== null && _options$destinationO !== void 0 ? _options$destinationO : 0, (_options$size = options.size) !== null && _options$size !== void 0 ? _options$size : 0);
-  }
-  copyBufferToTexture(options) {
-    var _options$offset, _options$mipLevel, _options$origin;
-    const webgpuSourceBuffer = options.source;
-    const WebGPUDestinationTexture = options.destination;
-    this.handle.copyBufferToTexture({
-      buffer: webgpuSourceBuffer.handle,
-      offset: (_options$offset = options.offset) !== null && _options$offset !== void 0 ? _options$offset : 0,
-      bytesPerRow: options.bytesPerRow,
-      rowsPerImage: options.rowsPerImage
-    }, {
-      texture: WebGPUDestinationTexture.handle,
-      mipLevel: (_options$mipLevel = options.mipLevel) !== null && _options$mipLevel !== void 0 ? _options$mipLevel : 0,
-      origin: (_options$origin = options.origin) !== null && _options$origin !== void 0 ? _options$origin : {}
-    }, {
-      width: options.extent[0],
-      height: options.extent[1],
-      depthOrArrayLayers: options.extent[2]
-    });
-  }
-  copyTextureToBuffer(options) {}
-  copyTextureToTexture(options) {}
-  pushDebugGroup(groupLabel) {
-    this.handle.pushDebugGroup(groupLabel);
-  }
-  popDebugGroup() {
-    this.handle.popDebugGroup();
-  }
-  insertDebugMarker(markerLabel) {
-    this.handle.insertDebugMarker(markerLabel);
-  }
+    device;
+    handle;
+    constructor(device, props) {
+        super(device, props);
+        this.device = device;
+        this.handle =
+            props.handle ||
+                this.device.handle.createCommandEncoder({
+                // TODO was this removed in standard?
+                // measureExecutionTime: this.props.measureExecutionTime
+                });
+        this.handle.label = this.props.id;
+    }
+    destroy() { }
+    finish(options) {
+        return this.finish(options);
+    }
+    // beginRenderPass(GPURenderPassDescriptor descriptor): GPURenderPassEncoder;
+    // beginComputePass(optional GPUComputePassDescriptor descriptor = {}): GPUComputePassEncoder;
+    copyBufferToBuffer(options) {
+        const webgpuSourceBuffer = options.source;
+        const WebGPUDestinationBuffer = options.destination;
+        this.handle.copyBufferToBuffer(webgpuSourceBuffer.handle, options.sourceOffset ?? 0, WebGPUDestinationBuffer.handle, options.destinationOffset ?? 0, options.size ?? 0);
+    }
+    copyBufferToTexture(options) {
+        const webgpuSourceBuffer = options.source;
+        const WebGPUDestinationTexture = options.destination;
+        this.handle.copyBufferToTexture({
+            buffer: webgpuSourceBuffer.handle,
+            offset: options.offset ?? 0,
+            bytesPerRow: options.bytesPerRow,
+            rowsPerImage: options.rowsPerImage
+        }, {
+            texture: WebGPUDestinationTexture.handle,
+            mipLevel: options.mipLevel ?? 0,
+            origin: options.origin ?? {}
+            // aspect: options.aspect
+        }, {
+            // TODO exclamation mark hack
+            width: options.extent[0],
+            height: options.extent[1],
+            depthOrArrayLayers: options.extent[2]
+        });
+    }
+    copyTextureToBuffer(options) {
+        // this.handle.copyTextureToBuffer(
+        //   // source
+        //   {},
+        //   // destination
+        //   {},
+        //   // copySize
+        //   {}
+        // );
+    }
+    copyTextureToTexture(options) {
+        // this.handle.copyTextureToTexture(
+        //   // source
+        //   {},
+        //   // destination
+        //   {},
+        //   // copySize
+        //   {}
+        // );
+    }
+    pushDebugGroup(groupLabel) {
+        this.handle.pushDebugGroup(groupLabel);
+    }
+    popDebugGroup() {
+        this.handle.popDebugGroup();
+    }
+    insertDebugMarker(markerLabel) {
+        this.handle.insertDebugMarker(markerLabel);
+    }
 }
-//# sourceMappingURL=webgpu-command-encoder.js.map