@luma.gl/webgpu 9.0.0-beta.1 → 9.0.0-beta.10

package/src/adapter/resources/webgpu-render-pass.ts

@@ -1,10 +1,15 @@
+// luma.gl
+// SPDX-License-Identifier: MIT
+// Copyright (c) vis.gl contributors
+
 import type {RenderPassProps, RenderPassParameters, Binding, Framebuffer} from '@luma.gl/core';
 import {Buffer, RenderPass, RenderPipeline, cast, log} from '@luma.gl/core';
 import {WebGPUDevice} from '../webgpu-device';
 import {WebGPUBuffer} from './webgpu-buffer';
-import {WebGPUTexture} from './webgpu-texture';
+import {WebGPUTextureView} from './webgpu-texture-view';
 // import {WebGPUCommandEncoder} from './webgpu-command-encoder';
 import {WebGPURenderPipeline} from './webgpu-render-pipeline';
+import {WebGPUQuerySet} from './webgpu-query-set';
 
 export class WebGPURenderPass extends RenderPass {
   readonly device: WebGPUDevice;
@@ -16,13 +21,30 @@ export class WebGPURenderPass extends RenderPass {
   constructor(device: WebGPUDevice, props: RenderPassProps = {}) {
     super(device, props);
     this.device = device;
-    const framebuffer = props.framebuffer || device.canvasContext.getCurrentFramebuffer() ;
+    const framebuffer = props.framebuffer || device.canvasContext.getCurrentFramebuffer();
     const renderPassDescriptor = this.getRenderPassDescriptor(framebuffer);
+
+    const webgpuQuerySet = props.timestampQuerySet as WebGPUQuerySet;
+    if (webgpuQuerySet) {
+      renderPassDescriptor.occlusionQuerySet = webgpuQuerySet.handle;
+    }
+
+    if (device.features.has('timestamp-query')) {
+      const webgpuQuerySet = props.timestampQuerySet as WebGPUQuerySet;
+      renderPassDescriptor.timestampWrites = webgpuQuerySet
+        ? ({
+            querySet: webgpuQuerySet.handle,
+            beginningOfPassWriteIndex: props.beginTimestampIndex,
+            endOfPassWriteIndex: props.endTimestampIndex
+          } as GPUComputePassTimestampWrites)
+        : undefined;
+    }
+
+    this.handle = this.props.handle || device.commandEncoder.beginRenderPass(renderPassDescriptor);
+    this.handle.label = this.props.id;
     log.groupCollapsed(3, `new WebGPURenderPass(${this.id})`)();
     log.probe(3, JSON.stringify(renderPassDescriptor, null, 2))();
     log.groupEnd(3)();
-    this.handle = this.props.handle || device.commandEncoder.beginRenderPass(renderPassDescriptor);
-    this.handle.label = this.props.id;
   }
 
   override destroy(): void {}
@@ -124,19 +146,20 @@ export class WebGPURenderPass extends RenderPass {
     this.handle.insertDebugMarker(markerLabel);
   }
 
-  // writeTimestamp(querySet: GPUQuerySet, queryIndex: number): void;
-  // beginOcclusionQuery(queryIndex: number): void;
-  // endOcclusionQuery(): void;
-  // beginPipelineStatisticsQuery(querySet: GPUQuerySet, queryIndex: number): void;
-  // endPipelineStatisticsQuery(querySet: GPUQuerySet, queryIndex: number): void;
+  beginOcclusionQuery(queryIndex: number): void {
+    this.handle.beginOcclusionQuery(queryIndex);
+  }
+  endOcclusionQuery(): void {
+    this.handle.endOcclusionQuery();
+  }
 
   // executeBundles(bundles: Iterable<GPURenderBundle>): void;
 
   // INTERNAL
 
-  /** 
+  /**
    * Partial render pass descriptor. Used by WebGPURenderPass.
-   * @returns attachments fields of a renderpass descriptor. 
+   * @returns attachments fields of a renderpass descriptor.
    */
   protected getRenderPassDescriptor(framebuffer: Framebuffer): GPURenderPassDescriptor {
     const renderPassDescriptor: GPURenderPassDescriptor = {
@@ -147,14 +170,14 @@ export class WebGPURenderPass extends RenderPass {
       // clear values
       loadOp: this.props.clearColor !== false ? 'clear' : 'load',
       colorClearValue: this.props.clearColor || [0, 0, 0, 0],
-      storeOp: this.props.discard? 'discard': 'store',
+      storeOp: this.props.discard ? 'discard' : 'store',
       // ...colorAttachment,
-      view: (colorAttachment as WebGPUTexture).createView()
+      view: (colorAttachment as WebGPUTextureView).handle
     }));
 
     if (framebuffer.depthStencilAttachment) {
       renderPassDescriptor.depthStencilAttachment = {
-        view: (framebuffer.depthStencilAttachment as WebGPUTexture).createView()
+        view: (framebuffer.depthStencilAttachment as WebGPUTextureView).handle
       };
       const {depthStencilAttachment} = renderPassDescriptor;
 

package/src/adapter/resources/webgpu-render-pipeline.ts

@@ -1,7 +1,7 @@
 // luma.gl MIT license
 
-import type {Binding, UniformValue, RenderPass, VertexArray} from '@luma.gl/core';
-import {RenderPipeline, RenderPipelineProps, cast, log, isObjectEmpty} from '@luma.gl/core';
+import type {Binding, RenderPass, VertexArray} from '@luma.gl/core';
+import {RenderPipeline, RenderPipelineProps, cast, log} from '@luma.gl/core';
 import {applyParametersToRenderPipelineDescriptor} from '../helpers/webgpu-parameters';
 import {getWebGPUTextureFormat} from '../helpers/convert-texture-format';
 import {getBindGroup} from '../helpers/get-bind-group';
@@ -25,12 +25,8 @@ export class WebGPURenderPipeline extends RenderPipeline {
   vs: WebGPUShader;
   fs: WebGPUShader | null = null;
 
-  // private _bufferSlots: Record<string, number>;
-  // private _buffers: Buffer[];
-  // private _firstIndex: number;
-  // private _lastIndex: number;
-
   /** For internal use to create BindGroups */
+  private _bindings: Record<string, Binding>;
   private _bindGroupLayout: GPUBindGroupLayout | null = null;
   private _bindGroup: GPUBindGroup | null = null;
 
@@ -43,74 +39,30 @@ export class WebGPURenderPipeline extends RenderPipeline {
       log.groupCollapsed(1, `new WebGPURenderPipeline(${this.id})`)();
       log.probe(1, JSON.stringify(descriptor, null, 2))();
       log.groupEnd(1)();
-      this.handle = this.device.handle.createRenderPipeline(descriptor);  
+      this.handle = this.device.handle.createRenderPipeline(descriptor);
     }
     this.handle.label = this.props.id;
 
     this.vs = cast<WebGPUShader>(props.vs);
     this.fs = cast<WebGPUShader>(props.fs);
 
-    // this._bufferSlots = getBufferSlots(this.props.shaderLayout, this.props.bufferLayout);
-    // this._buffers = new Array<Buffer>(Object.keys(this._bufferSlots).length).fill(null);
+    this._bindings = {...this.props.bindings};
   }
 
   override destroy(): void {
     // WebGPURenderPipeline has no destroy method.
+    this.handle = null;
   }
 
-  // setIndexBuffer(indexBuffer: Buffer): void {
-  //   this._indexBuffer = cast<WebGPUBuffer>(indexBuffer);
-  // }
-
-  /*
-  setAttributes(attributes: Record<string, Buffer>): void {
-    for (const [name, buffer] of Object.entries(attributes)) {
-      const bufferIndex = this._bufferSlots[name];
-      if (bufferIndex >= 0) {
-        this._buffers[bufferIndex] = buffer;
-      } else {
-        throw new Error(
-          `Setting attribute '${name}' not listed in shader layout for program ${this.id}`
-        );
-      }
-    }
-    // for (let i = 0; i < this._bufferSlots.length; ++i) {
-    //   const bufferName = this._bufferSlots[i];
-    //   if (attributes[bufferName]) {
-    //     this.handle
-    //   }
-    // }
-  }
-  */
-
-  // setConstantAttributes(attributes: Record<string, TypedArray>): void {
-  //   throw new Error('not implemented');
-  // }
-
+  /**
+   * @todo Use renderpass.setBindings() ?
+   * @todo Do we want to expose BindGroups in the API and remove this?
+   */
   setBindings(bindings: Record<string, Binding>): void {
-    if (!isObjectEmpty(this.props.bindings)) {
-      // Do we want to save things on CPU side?
-      Object.assign(this.props.bindings, bindings);
-
-      // Get hold of the bind group layout. We don't want to do this unless we know there is at least one bind group
-      this._bindGroupLayout = this._bindGroupLayout || this.handle.getBindGroupLayout(0);
-
-      // Set up the bindings
-      this._bindGroup = getBindGroup(
-        this.device.handle,
-        this._bindGroupLayout,
-        this.props.shaderLayout,
-        this.props.bindings
-      );
-    }
-  }
-
-  setUniforms(uniforms: Record<string, UniformValue>): void {
-    if (!isObjectEmpty(uniforms)) {
-      throw new Error('WebGPU does not support uniforms');
-    }
+    Object.assign(this._bindings, bindings);
   }
 
+  /** @todo - should this be moved to renderpass? */
   draw(options: {
     renderPass: RenderPass;
     vertexArray: VertexArray;
@@ -121,9 +73,8 @@ export class WebGPURenderPipeline extends RenderPipeline {
     firstIndex?: number;
     firstInstance?: number;
     baseVertex?: number;
-  }): void {
-    const webgpuRenderPass: WebGPURenderPass =
-      cast<WebGPURenderPass>(options.renderPass) || this.device.getDefaultRenderPass();
+  }): boolean {
+    const webgpuRenderPass = options.renderPass as WebGPURenderPass;
 
     // Set pipeline
     webgpuRenderPass.handle.setPipeline(this.handle);
@@ -134,7 +85,6 @@ export class WebGPURenderPipeline extends RenderPipeline {
       webgpuRenderPass.handle.setBindGroup(0, bindGroup);
     }
 
-
     // Set attributes
     // Note: Rebinds constant attributes before each draw call
     options.vertexArray.bindBeforeRender(options.renderPass);
@@ -158,43 +108,55 @@ export class WebGPURenderPipeline extends RenderPipeline {
 
     // Note: Rebinds constant attributes before each draw call
     options.vertexArray.unbindAfterRender(options.renderPass);
-  }
 
-  // _getBuffers() {
-  //   return this._buffers;
-  // }
+    return true;
+  }
 
   /** Return a bind group created by setBindings */
   _getBindGroup() {
-    // assert(this._bindGroup);
+    if (this.props.shaderLayout.bindings.length === 0) {
+      return null;
+    }
+
+    // Get hold of the bind group layout. We don't want to do this unless we know there is at least one bind group
+    this._bindGroupLayout = this._bindGroupLayout || this.handle.getBindGroupLayout(0);
+
+    // Set up the bindings
+    // TODO what if bindings change? We need to rebuild the bind group!
+    this._bindGroup =
+      this._bindGroup ||
+      getBindGroup(
+        this.device.handle,
+        this._bindGroupLayout,
+        this.props.shaderLayout,
+        this._bindings
+      );
+
     return this._bindGroup;
   }
 
-  /** 
-   * Populate the complex WebGPU GPURenderPipelineDescriptor 
+  /**
+   * Populate the complex WebGPU GPURenderPipelineDescriptor
    */
   protected _getRenderPipelineDescriptor() {
     // Set up the vertex stage
     const vertex: GPUVertexState = {
       module: cast<WebGPUShader>(this.props.vs).handle,
-      entryPoint: this.props.vsEntryPoint || 'main',
+      entryPoint: this.props.vertexEntryPoint || 'main',
       buffers: getVertexBufferLayout(this.props.shaderLayout, this.props.bufferLayout)
     };
 
     // Set up the fragment stage
-    let fragment: GPUFragmentState | undefined;
-    if (this.props.fs) {
-      fragment = {
-        module: cast<WebGPUShader>(this.props.fs).handle,
-        entryPoint: this.props.fsEntryPoint || 'main',
-        targets: [
-          {
-            // TODO exclamation mark hack!
-            format: getWebGPUTextureFormat(this.device?.canvasContext?.format)
-          }
-        ]
-      };
-    }
+    const fragment: GPUFragmentState = {
+      module: cast<WebGPUShader>(this.props.fs).handle,
+      entryPoint: this.props.fragmentEntryPoint || 'main',
+      targets: [
+        {
+          // TODO exclamation mark hack!
+          format: getWebGPUTextureFormat(this.device?.canvasContext?.format)
+        }
+      ]
+    };
 
     // WebGPU has more restrictive topology support than WebGL
     switch (this.props.topology) {
@@ -219,47 +181,46 @@ export class WebGPURenderPipeline extends RenderPipeline {
 
     return descriptor;
   }
+}
+/**
+_setAttributeBuffers(webgpuRenderPass: WebGPURenderPass) {
+  if (this._indexBuffer) {
+    webgpuRenderPass.handle.setIndexBuffer(this._indexBuffer.handle, this._indexBuffer.props.indexType);
+  }
 
-  /**
-  _setAttributeBuffers(webgpuRenderPass: WebGPURenderPass) {
-    if (this._indexBuffer) {
-      webgpuRenderPass.handle.setIndexBuffer(this._indexBuffer.handle, this._indexBuffer.props.indexType);
+  const buffers = this._getBuffers();
+  for (let i = 0; i < buffers.length; ++i) {
+    const buffer = cast<WebGPUBuffer>(buffers[i]);
+    if (!buffer) {
+      const attribute = this.props.shaderLayout.attributes.find(
+        (attribute) => attribute.location === i
+      );
+      throw new Error(
+        `No buffer provided for attribute '${attribute?.name || ''}' in Model '${this.props.id}'`
+      );
     }
+    webgpuRenderPass.handle.setVertexBuffer(i, buffer.handle);
+  }
 
-    const buffers = this._getBuffers();
-    for (let i = 0; i < buffers.length; ++i) {
-      const buffer = cast<WebGPUBuffer>(buffers[i]);
-      if (!buffer) {
-        const attribute = this.props.shaderLayout.attributes.find(
-          (attribute) => attribute.location === i
-        );
-        throw new Error(
-          `No buffer provided for attribute '${attribute?.name || ''}' in Model '${this.props.id}'`
-        );
-      }
-      webgpuRenderPass.handle.setVertexBuffer(i, buffer.handle);
+  // TODO - HANDLE buffer maps
+  /*
+  for (const [bufferName, attributeMapping] of Object.entries(this.props.bufferLayout)) {
+    const buffer = cast<WebGPUBuffer>(this.props.attributes[bufferName]);
+    if (!buffer) {
+      log.warn(`Missing buffer for buffer map ${bufferName}`)();
+      continue;
     }
 
-    // TODO - HANDLE buffer maps
-    /*
-    for (const [bufferName, attributeMapping] of Object.entries(this.props.bufferLayout)) {
-      const buffer = cast<WebGPUBuffer>(this.props.attributes[bufferName]);
-      if (!buffer) {
-        log.warn(`Missing buffer for buffer map ${bufferName}`)();
-        continue;
-      }
-
-      if ('location' in attributeMapping) {
+    if ('location' in attributeMapping) {
+      // @ts-expect-error TODO model must not depend on webgpu
+      renderPass.handle.setVertexBuffer(layout.location, buffer.handle);
+    } else {
+      for (const [bufferName, mapping] of Object.entries(attributeMapping)) {
         // @ts-expect-error TODO model must not depend on webgpu
-        renderPass.handle.setVertexBuffer(layout.location, buffer.handle);
-      } else {
-        for (const [bufferName, mapping] of Object.entries(attributeMapping)) {
-          // @ts-expect-error TODO model must not depend on webgpu
-          renderPass.handle.setVertexBuffer(field.location, buffer.handle);
-        }
+        renderPass.handle.setVertexBuffer(field.location, buffer.handle);
       }
     }
-    *
   }
-  */
+  *
 }
+*/

package/src/adapter/resources/webgpu-sampler.ts

@@ -3,7 +3,7 @@ import type {WebGPUDevice} from '../webgpu-device';
 
 export type WebGPUSamplerProps = SamplerProps & {
   handle?: GPUSampler;
-}
+};
 
 /**
  *
@@ -27,6 +27,9 @@ export class WebGPUSampler extends Sampler {
   }
 
   override destroy(): void {
+    // GPUSampler does not have a destroy method
     // this.handle.destroy();
+    // @ts-expect-error readonly
+    this.handle = null;
   }
 }

package/src/adapter/resources/webgpu-shader.ts

@@ -1,14 +1,11 @@
-// luma.gl, MIT license
+// luma.gl
+// SPDX-License-Identifier: MIT
 // Copyright (c) vis.gl contributors
 
 import type {ShaderProps, CompilerMessage} from '@luma.gl/core';
 import {Shader, log} from '@luma.gl/core';
 import type {WebGPUDevice} from '../webgpu-device';
 
-export type WebGPUShaderProps = ShaderProps & {
-  handle?: GPUShaderModule;
-};
-
 /**
  * Immutable shader
  */
@@ -16,7 +13,7 @@ export class WebGPUShader extends Shader {
   readonly device: WebGPUDevice;
   readonly handle: GPUShaderModule;
 
-  constructor(device: WebGPUDevice, props: WebGPUShaderProps) {
+  constructor(device: WebGPUDevice, props: ShaderProps) {
     super(device, props);
     this.device = device;
 
@@ -29,8 +26,11 @@ export class WebGPUShader extends Shader {
   }
 
   async _checkCompilationError(errorScope: Promise<GPUError | null>): Promise<void> {
-    const error = await errorScope as GPUValidationError;
+    const error = (await errorScope) as GPUValidationError;
     if (error) {
+      // The `Shader` base class will determine if debug window should be opened based on props
+      this.debugShader();
+
       const shaderLog = await this.getCompilationInfo();
       log.error(`Shader compilation error: ${error.message}`, shaderLog)();
       // Note: Even though this error is asynchronous and thrown after the constructor completes,
@@ -42,6 +42,8 @@ export class WebGPUShader extends Shader {
   override destroy(): void {
     // Note: WebGPU does not offer a method to destroy shaders
     // this.handle.destroy();
+    // @ts-expect-error readonly
+    this.handle = null;
   }
 
   /** Returns compilation info for this shader */
@@ -53,26 +55,13 @@ export class WebGPUShader extends Shader {
   // PRIVATE METHODS
 
   protected createHandle(): GPUShaderModule {
-    const {source, stage} = this.props;
+    const {source} = this.props;
 
-    let language = this.props.language;
-    // Compile from src
-    if (language === 'auto') {
-      // wgsl uses C++ "auto" style arrow notation
-      language = source.includes('->') ? 'wgsl' : 'glsl';
+    const isGLSL = source.includes('#version');
+    if (this.props.language === 'glsl' || isGLSL) {
+      throw new Error('GLSL shaders are not supported in WebGPU');
     }
 
-    switch(language) {
-      case 'wgsl':
-        return this.device.handle.createShaderModule({code: source});
-      case 'glsl':
-        return this.device.handle.createShaderModule({
-          code: source,
-          // @ts-expect-error
-          transform: (glsl) => this.device.glslang.compileGLSL(glsl, stage)
-        });
-      default:
-        throw new Error(language);
-    }
+    return this.device.handle.createShaderModule({code: source});
   }
 }

package/src/adapter/resources/webgpu-texture-view.ts

@@ -0,0 +1,46 @@
+// luma.gl
+// SPDX-License-Identifier: MIT
+// Copyright (c) vis.gl contributors
+
+import {TextureView, TextureViewProps} from '@luma.gl/core';
+import type {WebGPUDevice} from '../webgpu-device';
+import type {WebGPUTexture} from './webgpu-texture';
+
+export type WebGPUTextureViewProps = TextureViewProps & {
+  handle?: GPUTextureView;
+};
+
+/**
+ *
+ */
+export class WebGPUTextureView extends TextureView {
+  readonly device: WebGPUDevice;
+  readonly handle: GPUTextureView;
+  readonly texture: WebGPUTexture;
+
+  constructor(device: WebGPUDevice, props: WebGPUTextureViewProps & {texture: WebGPUTexture}) {
+    super(device, props);
+    this.device = device;
+    this.texture = props.texture;
+
+    this.handle =
+      this.handle ||
+      this.texture.handle.createView({
+        format: (props.format || this.texture.format) as GPUTextureFormat,
+        dimension: props.dimension || this.texture.dimension,
+        aspect: props.aspect,
+        baseMipLevel: props.baseMipLevel,
+        mipLevelCount: props.mipLevelCount, // GPUIntegerCoordinate;
+        baseArrayLayer: props.baseArrayLayer, // GPUIntegerCoordinate;
+        arrayLayerCount: props.arrayLayerCount // GPUIntegerCoordinate;
+      });
+    this.handle.label = this.props.id;
+  }
+
+  override destroy(): void {
+    // GPUTextureView does not have a destroy method
+    // this.handle.destroy();
+    // @ts-expect-error readonly
+    this.handle = null;
+  }
+}

package/src/adapter/resources/webgpu-texture.ts

@@ -1,14 +1,18 @@
-// luma.gl, MIT license
-import {Texture, TextureProps, Sampler, SamplerProps} from '@luma.gl/core';
+// luma.gl
+// SPDX-License-Identifier: MIT
+// Copyright (c) vis.gl contributors
+
+import {Texture, TextureProps, TextureViewProps, Sampler, SamplerProps} from '@luma.gl/core';
 import {getWebGPUTextureFormat} from '../helpers/convert-texture-format';
 import type {WebGPUDevice} from '../webgpu-device';
 import {WebGPUSampler} from './webgpu-sampler';
+import {WebGPUTextureView} from './webgpu-texture-view';
 
 const BASE_DIMENSIONS: Record<string, '1d' | '2d' | '3d'> = {
   '1d': '1d',
   '2d': '2d',
   '2d-array': '2d',
-  'cube': '2d',
+  cube: '2d',
   'cube-array': '2d',
   '3d': '3d'
 };
@@ -16,12 +20,13 @@ const BASE_DIMENSIONS: Record<string, '1d' | '2d' | '3d'> = {
 export class WebGPUTexture extends Texture {
   readonly device: WebGPUDevice;
   readonly handle: GPUTexture;
-  readonly view: GPUTextureView;
-  sampler: WebGPUSampler;
 
   override height: number = 1;
   override width: number = 1;
 
+  sampler: WebGPUSampler;
+  view: WebGPUTextureView;
+
   // static async createFromImageURL(src, usage = 0) {
   //   const img = document.createElement('img');
   //   img.src = src;
@@ -46,6 +51,16 @@ export class WebGPUTexture extends Texture {
     this.initialize(props);
   }
 
+  override destroy(): void {
+    this.handle?.destroy();
+    // @ts-expect-error readonly
+    this.handle = null;
+  }
+
+  createView(props: TextureViewProps): WebGPUTextureView {
+    return new WebGPUTextureView(this.device, {...props, texture: this});
+  }
+
   protected initialize(props: TextureProps): void {
     // @ts-expect-error
     this.handle = this.props.handle || this.createHandle();
@@ -67,12 +82,16 @@ export class WebGPUTexture extends Texture {
 
     // Create a default sampler. This mimics the WebGL1 API where sampler props are stored on the texture
     // this.setSampler(props.sampler);
-    this.sampler = props.sampler instanceof WebGPUSampler ? props.sampler : new WebGPUSampler(this.device, props.sampler);
+    this.sampler =
+      props.sampler instanceof WebGPUSampler
+        ? props.sampler
+        : new WebGPUSampler(this.device, props.sampler);
 
     // TODO - To support texture arrays we need to create custom views...
     // But we are not ready to expose TextureViews to the public API.
     // @ts-expect-error
-    this.view = this.createView();
+
+    this.view = new WebGPUTextureView(this.device, {...this.props, texture: this});
     // format: this.props.format,
     // dimension: this.props.dimension,
     // aspect = "all";
@@ -104,22 +123,17 @@ export class WebGPUTexture extends Texture {
     });
   }
 
-  override destroy(): void {
-    this.handle.destroy();
-  }
-
   /**
    * Set default sampler
    * Accept a sampler instance or set of props;
    */
   setSampler(sampler: Sampler | SamplerProps): this {
-    this.sampler = sampler instanceof WebGPUSampler ? sampler : new WebGPUSampler(this.device, sampler);
+    this.sampler =
+      sampler instanceof WebGPUSampler ? sampler : new WebGPUSampler(this.device, sampler);
     return this;
   }
 
-  setData(options: {
-    data: any;
-  }) {
+  setData(options: {data: any}) {
     return this.setImage({source: options.data});
   }
 
@@ -138,7 +152,7 @@ export class WebGPUTexture extends Texture {
     aspect?: 'all' | 'stencil-only' | 'depth-only';
     colorSpace?: 'srgb';
     premultipliedAlpha?: boolean;
-  }): {width: number, height: number} {
+  }): {width: number; height: number} {
     const {
       source,
       width = options.source.width,
@@ -173,22 +187,13 @@ export class WebGPUTexture extends Texture {
         premultipliedAlpha
       },
       // copySize: GPUExtent3D
-      [
-        width,
-        height,
-        depth
-      ]
+      [width, height, depth]
     );
     return {width, height};
   }
 
-  // WebGPU specific 
-  
-  /** TODO - intention is to expose TextureViews in the public API */
-  createView(): GPUTextureView {
-    return this.handle.createView({label: this.id});
-  }
-  
+  // WebGPU specific
+
   /*
   async readPixels() {
     const readbackBuffer = device.createBuffer({