@luma.gl/webgpu 9.0.0-alpha.2 → 9.0.0-alpha.21

package/src/adapter/resources/webgpu-command-encoder.ts

@@ -1,26 +1,23 @@
-import {CommandEncoder, CommandEncoderProps, RenderPipeline, Buffer, Texture, cast} from '@luma.gl/api';
-import WebGPUDevice from '../webgpu-device';
-import WEBGPUBuffer from './webgpu-buffer';
-import WebGPUTexture from './webgpu-texture';
+import {CommandEncoder, CommandEncoderProps, Buffer, Texture, cast} from '@luma.gl/api';
+import {WebGPUDevice} from '../webgpu-device';
+import {WebGPUBuffer} from './webgpu-buffer';
+import {WebGPUTexture} from './webgpu-texture';
 
-export default class WebGPUCommandEncoder extends CommandEncoder {
+export class WebGPUCommandEncoder extends CommandEncoder {
   readonly device: WebGPUDevice;
   readonly handle: GPUCommandEncoder;
 
   constructor(device: WebGPUDevice, props: CommandEncoderProps) {
     super(props);
     this.device = device;
-    this.handle = this.handle || this.createHandle();
-    this.handle.label = this.props.id;
-  }
-
-  protected createHandle(): GPUCommandEncoder {
-    return this.device.handle.createCommandEncoder({
-      measureExecutionTime: this.props.measureExecutionTime
+    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() {}
+  override destroy(): void {}
 
   finish(options?: {id?: string}): GPUCommandBuffer {
     return this.finish(options);
@@ -37,9 +34,9 @@ export default class WebGPUCommandEncoder extends CommandEncoder {
     size?: number
   }): void {
     this.handle.copyBufferToBuffer(
-      cast<WEBGPUBuffer>(options.source).handle,
+      cast<WebGPUBuffer>(options.source).handle,
       options.sourceOffset ?? 0,
-      cast<WEBGPUBuffer>(options.destination).handle,
+      cast<WebGPUBuffer>(options.destination).handle,
       options.destinationOffset ?? 0,
       options.size ?? 0
     );
@@ -60,7 +57,7 @@ export default class WebGPUCommandEncoder extends CommandEncoder {
   }): void {
     this.handle.copyBufferToTexture(
       {
-        buffer: cast<WEBGPUBuffer>(options.source).handle,
+        buffer: cast<WebGPUBuffer>(options.source).handle,
         offset: options.offset ?? 0,
         bytesPerRow: options.bytesPerRow,
         rowsPerImage: options.rowsPerImage,
@@ -71,7 +68,12 @@ export default class WebGPUCommandEncoder extends CommandEncoder {
         origin: options.origin ?? {},
         // aspect: options.aspect
       },
-      options.extent // default depth?
+      {
+        // TODO exclamation mark hack
+        width: options.extent[0],
+        height: options.extent[1],
+        depthOrArrayLayers: options.extent[2]
+      }
     );
   }
 
@@ -87,15 +89,15 @@ export default class WebGPUCommandEncoder extends CommandEncoder {
     copySize: GPUExtent3D
   }): void {}
 
-  pushDebugGroup(groupLabel: string): void {
+  override pushDebugGroup(groupLabel: string): void {
     this.handle.pushDebugGroup(groupLabel);
   }
 
-  popDebugGroup(): void {
+  override popDebugGroup(): void {
     this.handle.popDebugGroup();
   }
 
-  insertDebugMarker(markerLabel: string): void {
+  override insertDebugMarker(markerLabel: string): void {
     this.handle.insertDebugMarker(markerLabel);
   }
 

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

@@ -1,29 +1,29 @@
 import {ComputePass, ComputePassProps, ComputePipeline, Buffer, Binding, cast} from '@luma.gl/api';
-import WebGPUDevice from '../webgpu-device';
-import WebGPUBuffer from './webgpu-buffer';
-// import WebGPUCommandEncoder from './webgpu-command-encoder';
-import WebGPUComputePipeline from './webgpu-compute-pipeline';
+import {WebGPUDevice} from '../webgpu-device';
+import {WebGPUBuffer} from './webgpu-buffer';
+// import {WebGPUCommandEncoder} from './webgpu-command-encoder';
+import {WebGPUComputePipeline} from './webgpu-compute-pipeline';
 
-export default class WebGPUComputePass extends ComputePass {
+export class WebGPUComputePass extends ComputePass {
   readonly device: WebGPUDevice;
   readonly handle: GPUComputePassEncoder;
-  _bindGroupLayout: GPUBindGroupLayout;
+  _bindGroupLayout: GPUBindGroupLayout | null = null;
 
   constructor(device: WebGPUDevice, props: ComputePassProps) {
     super(device, props);
     this.device = device;
 
-    this.handle = this.props.handle || device.commandEncoder.beginComputePass({
+    this.handle = this.props.handle || device.commandEncoder?.beginComputePass({
       label: this.props.id,
       // timestampWrites?: GPUComputePassTimestampWrites;
     });
   }
 
   /** @note no WebGPU destroy method, just gc */
-  destroy() {}
+  override destroy(): void {}
 
-  endPass(): void {
-    this.handle.endPass();
+  end(): void {
+    this.handle.end();
   }
 
   setPipeline(pipeline: ComputePipeline): void {
@@ -46,7 +46,7 @@ export default class WebGPUComputePass extends ComputePass {
    * @param z Z dimension of the grid of workgroups to dispatch.
    */
   dispatch(x: number, y?: number, z?: number): void {
-    this.handle.dispatch(x, y, z);
+    this.handle.dispatchWorkgroups(x, y, z);
   }
 
   /**
@@ -55,7 +55,7 @@ export default class WebGPUComputePass extends ComputePass {
    * @param indirectOffset
    */
   dispatchIndirect(indirectBuffer: Buffer, indirectOffset: number = 0): void {
-    this.handle.dispatchIndirect(cast<WebGPUBuffer>(indirectBuffer).handle, indirectOffset);
+    this.handle.dispatchWorkgroupsIndirect(cast<WebGPUBuffer>(indirectBuffer).handle, indirectOffset);
   }
 
   pushDebugGroup(groupLabel: string): void {

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

@@ -1,13 +1,13 @@
 // prettier-ignore
 import {ComputePipeline, ComputePipelineProps, cast} from '@luma.gl/api';
 
-import WebGPUDevice from '../webgpu-device';
-import WebGPUShader from './webgpu-shader';
+import {WebGPUDevice} from '../webgpu-device';
+import {WebGPUShader} from './webgpu-shader';
 
 // COMPUTE PIPELINE
 
 /** Creates a new compute pipeline when parameters change */
-export default class WebGPUComputePipeline extends ComputePipeline {
+export class WebGPUComputePipeline extends ComputePipeline {
   device: WebGPUDevice;
   handle: GPUComputePipeline;
 
@@ -22,7 +22,8 @@ export default class WebGPUComputePipeline extends ComputePipeline {
         module,
         entryPoint: this.props.csEntryPoint,
         // constants: this.props.csConstants
-      }
+      },
+      layout: 'auto'
     });
   }
 

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

@@ -1,13 +1,13 @@
 // luma.gl, MIT license
 import {ExternalTexture, ExternalTextureProps, Sampler, SamplerProps} from '@luma.gl/api';
-import type WebGPUDevice from '../webgpu-device';
-import WebGPUSampler from './webgpu-sampler';
+import type {WebGPUDevice} from '../webgpu-device';
+import {WebGPUSampler} from './webgpu-sampler';
 
 /**
  * Cheap, temporary texture view for videos
  * Only valid within same callback, destroyed automatically as a microtask.
  */
-export default class WebGPUExternalTexture extends ExternalTexture {
+export class WebGPUExternalTexture extends ExternalTexture {
   readonly device: WebGPUDevice;
   readonly handle: GPUExternalTexture;
   sampler: WebGPUSampler;
@@ -22,7 +22,7 @@ export default class WebGPUExternalTexture extends ExternalTexture {
     this.sampler = null;
   }
 
-  destroy(): void {
+  override destroy(): void {
     // External textures are destroyed automatically,
     // as a microtask, instead of manually or upon garbage collection like other resources.
     // this.handle.destroy();

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

@@ -1,23 +1,22 @@
 import type {FramebufferProps, ColorTextureFormat} from '@luma.gl/api';
 import {Framebuffer, Texture} from '@luma.gl/api';
-import WebGPUDevice from '../webgpu-device';
-// import WebGPUCanvasContext from '../webgpu-canvas-context';
-import WEBGPUTexture from './webgpu-texture';
-import WebGPUTexture from './webgpu-texture';
+import {WebGPUDevice} from '../webgpu-device';
+// import {WebGPUCanvasContext} from '../webgpu-canvas-context';
+import {WebGPUTexture} from './webgpu-texture';
 
 // const DEFAULT_DEPTH_STENCIL_FORMAT: DepthStencilTextureFormat = 'depth24plus';
 
-const MAX_COLOR_ATTACHMENTS = 8;
+// const MAX_COLOR_ATTACHMENTS = 8;
 
 /**
  * Create new textures with correct size for all attachments. 
  * @note resize() destroys existing textures (if size has changed). 
  */
-export default class WebGPUFramebuffer extends Framebuffer {
+export class WebGPUFramebuffer extends Framebuffer {
   readonly device: WebGPUDevice;
 
   colorAttachments: WebGPUTexture[] = [];
-  depthStencilAttachment: WebGPUTexture;
+  depthStencilAttachment: WebGPUTexture | null = null;
 
   /** Partial render pass descriptor. Used by WebGPURenderPass */
   renderPassDescriptor: {
@@ -43,9 +42,9 @@ export default class WebGPUFramebuffer extends Framebuffer {
       this.renderPassDescriptor.depthStencilAttachment = {
         view: this.depthStencilAttachment.handle.createView(),
         // Add default clear values
-        depthLoadValue: 1.0,
+        depthClearValue: 1.0,
         depthStoreOp: 'store',
-        stencilLoadValue: 0,
+        stencilClearValue: 0,
         stencilStoreOp: 'store',
       }
     }
@@ -53,6 +52,7 @@ export default class WebGPUFramebuffer extends Framebuffer {
     if (this.colorAttachments.length > 0) {
       this.renderPassDescriptor.colorAttachments = this.colorAttachments.map(colorAttachment => ({
         view: colorAttachment.handle.createView(),
+        loadOp: 'clear',
         loadValue: [0.0, 0.0, 0.0, 0.0],
         storeOp: 'store'
       }));
@@ -60,8 +60,8 @@ export default class WebGPUFramebuffer extends Framebuffer {
   }
 
   /** Create depth stencil texture */
-  private createDepthStencilTexture(props: FramebufferProps): WEBGPUTexture {
-    if (props.depthStencilAttachment instanceof WEBGPUTexture) {
+  private createDepthStencilTexture(props: FramebufferProps): WebGPUTexture {
+    if (props.depthStencilAttachment instanceof WebGPUTexture) {
       return props.depthStencilAttachment;
     }
 
@@ -78,8 +78,8 @@ export default class WebGPUFramebuffer extends Framebuffer {
     throw new Error('type');
   }
 
-  private createColorTexture(props: FramebufferProps, texture: Texture | ColorTextureFormat): WEBGPUTexture {
-    if (texture instanceof WEBGPUTexture) {
+  private createColorTexture(props: FramebufferProps, texture: Texture | ColorTextureFormat): WebGPUTexture {
+    if (texture instanceof WebGPUTexture) {
       return texture;
     }
 
@@ -100,7 +100,7 @@ export default class WebGPUFramebuffer extends Framebuffer {
    * Create new textures with correct size for all attachments.
    * @note destroys existing textures.
    */
-   protected _resizeAttachments(width: number, height: number): void {
+  protected _resizeAttachments(width: number, height: number): void {
     for (let i = 0; i < this.colorAttachments.length; ++i) {
       if (this.colorAttachments[i]) {
         const resizedTexture = this.device._createTexture({...this.colorAttachments[i].props, width, height})
@@ -111,10 +111,10 @@ export default class WebGPUFramebuffer extends Framebuffer {
     }
 
     if (this.depthStencilAttachment) {
-       const resizedTexture = this.device._createTexture({...this.depthStencilAttachment.props, width, height})
-       this.depthStencilAttachment.destroy();
-       this.depthStencilAttachment = resizedTexture;
-       this.renderPassDescriptor.depthStencilAttachment.view = resizedTexture.handle.createView();
+      const resizedTexture = this.device._createTexture({...this.depthStencilAttachment.props, width, height})
+      this.depthStencilAttachment.destroy();
+      this.depthStencilAttachment = resizedTexture;
+      this.renderPassDescriptor.depthStencilAttachment.view = resizedTexture.handle.createView();
     }
   }
 }

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

@@ -1,6 +1,6 @@
 /*
 import {Resource, Query, QueryProps} from '@luma.gl/api';
-import WebGPUDevice from '../webgpu-device';
+import {WebGPUDevice} from '../webgpu-device';
 
 export type WebGPUQueryProps = QueryProps & {
   handle?: any;
@@ -36,7 +36,7 @@ class WebGPUQuery extends Resource<WebGPUQueryProps> implements Query {
     });
   }
 
-  destroy() {
+  override destroy(): void {
     this.handle.destroy();
   }
 }

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

@@ -1,11 +1,11 @@
 import type {RenderPassProps, RenderPassParameters, Binding} from '@luma.gl/api';
-import {Buffer, RenderPass, RenderPipeline, cast, log} from '@luma.gl/api';
-import WebGPUDevice from '../webgpu-device';
-import WebGPUBuffer from './webgpu-buffer';
-// import WebGPUCommandEncoder from './webgpu-command-encoder';
-import WebGPURenderPipeline from './webgpu-render-pipeline';
+import {Buffer, RenderPass, RenderPipeline, cast} from '@luma.gl/api';
+import {WebGPUDevice} from '../webgpu-device';
+import {WebGPUBuffer} from './webgpu-buffer';
+// import {WebGPUCommandEncoder} from './webgpu-command-encoder';
+import {WebGPURenderPipeline} from './webgpu-render-pipeline';
 
-export default class WebGPURenderPass extends RenderPass {
+export class WebGPURenderPass extends RenderPass {
   readonly device: WebGPUDevice;
   readonly handle: GPURenderPassEncoder;
 
@@ -22,10 +22,10 @@ export default class WebGPURenderPass extends RenderPass {
     this.handle.label = this.props.id;
   }
 
-  destroy() {}
+  override destroy(): void {}
 
-  endPass(): void {
-    this.handle.endPass();
+  end(): void {
+    this.handle.end();
   }
 
   setPipeline(pipeline: RenderPipeline): void {
@@ -35,8 +35,11 @@ export default class WebGPURenderPass extends RenderPass {
 
   /** Sets an array of bindings (uniform buffers, samplers, textures, ...) */
   setBindings(bindings: Record<string, Binding>): void {
-    this.pipeline.setBindings(bindings);
-    this.handle.setBindGroup(0, this.pipeline._getBindGroup());
+    this.pipeline?.setBindings(bindings);
+    const bindGroup = this.pipeline?._getBindGroup();
+    if (bindGroup) {
+      this.handle.setBindGroup(0, bindGroup);
+    }
   }
 
   setIndexBuffer(
@@ -71,7 +74,7 @@ export default class WebGPURenderPass extends RenderPass {
       );
     } else {
       this.handle.draw(
-        options.vertexCount,
+        options.vertexCount || 0,
         options.instanceCount,
         options.firstIndex,
         options.firstInstance

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

@@ -8,27 +8,30 @@ import {getVertexBufferLayout, getBufferSlots} from '../helpers/get-vertex-buffe
 // import {mapAccessorToWebGPUFormat} from './helpers/accessor-to-format';
 // import type {BufferAccessors} from './webgpu-pipeline';
 
-import type WebGPUDevice from '../webgpu-device';
-import type WebGPUBuffer from './webgpu-buffer';
-import type WebGPUShader from './webgpu-shader';
-import type WebGPURenderPass from './webgpu-render-pass';
+import type {WebGPUDevice} from '../webgpu-device';
+import type {WebGPUBuffer} from './webgpu-buffer';
+import type {WebGPUShader} from './webgpu-shader';
+import type {WebGPURenderPass} from './webgpu-render-pass';
 
 // RENDER PIPELINE
 
 /** Creates a new render pipeline when parameters change */
-export default class WebGPURenderPipeline extends RenderPipeline {
+export class WebGPURenderPipeline extends RenderPipeline {
   device: WebGPUDevice;
   handle: GPURenderPipeline;
 
+  vs: WebGPUShader;
+  fs: WebGPUShader | null = null;
+
   private _bufferSlots: Record<string, number>;
   private _buffers: Buffer[];
-  private _indexBuffer: WebGPUBuffer;
+  private _indexBuffer: WebGPUBuffer | null = null;
   // private _firstIndex: number;
   // private _lastIndex: number;
 
   /** For internal use to create BindGroups */
   private _bindGroupLayout: GPUBindGroupLayout;
-  private _bindGroup: GPUBindGroup = null;
+  private _bindGroup: GPUBindGroup | null = null;
 
   constructor(device: WebGPUDevice, props: RenderPipelineProps) {
     super(device, props);
@@ -36,6 +39,9 @@ export default class WebGPURenderPipeline extends RenderPipeline {
     this.handle = (this.props.handle as GPURenderPipeline) || this.createHandle();
     this.handle.label = this.props.id;
 
+    this.vs = cast<WebGPUShader>(props.vs);
+    this.fs = cast<WebGPUShader>(props.fs);
+
     this._bufferSlots = getBufferSlots(this.props.layout, this.props.bufferMap);
     this._buffers = new Array<Buffer>(Object.keys(this._bufferSlots).length).fill(null);
     this._bindGroupLayout = this.handle.getBindGroupLayout(0);
@@ -50,7 +56,7 @@ export default class WebGPURenderPipeline extends RenderPipeline {
     return renderPipeline;
   }
 
-  destroy() {
+  override destroy(): void {
     // WebGPURenderPipeline has no destroy method.
   }
 
@@ -124,19 +130,29 @@ export default class WebGPURenderPipeline extends RenderPipeline {
         entryPoint: this.props.fsEntryPoint || 'main',
         targets: [
           {
-            format: getWebGPUTextureFormat(this.device.canvasContext.format)
+            // TODO exclamation mark hack!
+            format: getWebGPUTextureFormat(this.device?.canvasContext?.format)
           }
         ]
       };
     }
 
+    // WebGPU has more restrictive topology support than WebGL
+    switch (this.props.topology) {
+      case 'triangle-fan':
+      case 'line-loop':
+        throw new Error(`WebGPU does not support primitive topology ${this.props.topology}`);
+      default:
+    }
+
     // Create a partially populated descriptor
-    let descriptor: GPURenderPipelineDescriptor = {
+    const descriptor: GPURenderPipelineDescriptor = {
       vertex,
       fragment,
       primitive: {
         topology: this.props.topology
-      }
+      },
+      layout: 'auto'
     };
 
     // Set parameters on the descriptor
@@ -155,15 +171,16 @@ export default class WebGPURenderPipeline extends RenderPipeline {
     firstInstance?: number;
     baseVertex?: number;
   }): void {
-    const webgpuRenderPass =
+    const webgpuRenderPass: WebGPURenderPass =
       cast<WebGPURenderPass>(options.renderPass) || this.device.getDefaultRenderPass();
 
     // Set pipeline
     webgpuRenderPass.handle.setPipeline(this.handle);
 
     // Set bindings (uniform buffers, textures etc)
-    if (this._getBindGroup()) {
-      webgpuRenderPass.handle.setBindGroup(0, this._getBindGroup());
+    const bindGroup = this._getBindGroup();
+    if (bindGroup) {
+      webgpuRenderPass.handle.setBindGroup(0, bindGroup);
     }
 
     // Set attributes
@@ -180,7 +197,7 @@ export default class WebGPURenderPipeline extends RenderPipeline {
       );
     } else {
       webgpuRenderPass.handle.draw(
-        options.vertexCount,
+        options.vertexCount || 0,
         options.instanceCount,
         options.firstIndex,
         options.firstInstance

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

@@ -1,5 +1,5 @@
 import {Sampler, SamplerProps} from '@luma.gl/api';
-import type WebGPUDevice from '../webgpu-device';
+import type {WebGPUDevice} from '../webgpu-device';
 
 export type WebGPUSamplerProps = SamplerProps & {
   handle?: GPUSampler;
@@ -8,18 +8,25 @@ export type WebGPUSamplerProps = SamplerProps & {
 /**
  *
  */
-export default class WebGPUSampler extends Sampler {
+export class WebGPUSampler extends Sampler {
   readonly device: WebGPUDevice;
   readonly handle: GPUSampler;
 
   constructor(device: WebGPUDevice, props: WebGPUSamplerProps) {
     super(device, props);
     this.device = device;
-    this.handle = this.handle || this.device.handle.createSampler(this.props);
+
+    // Prepare sampler props
+    const samplerProps: Partial<WebGPUSamplerProps> = {...this.props};
+    if (samplerProps.type !== 'comparison-sampler') {
+      delete samplerProps.compare;
+    }
+
+    this.handle = this.handle || this.device.handle.createSampler(samplerProps);
     this.handle.label = this.props.id;
   }
 
-  destroy(): void {
+  override destroy(): void {
     // this.handle.destroy();
   }
 }

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

@@ -1,6 +1,8 @@
+// luma.gl, MIT license
+
 import type {ShaderProps, CompilerMessage} from '@luma.gl/api';
 import {Shader, log} from '@luma.gl/api';
-import type WebGPUDevice from '../webgpu-device';
+import type {WebGPUDevice} from '../webgpu-device';
 
 export type WebGPUShaderProps = ShaderProps & {
   handle?: GPUShaderModule;
@@ -9,7 +11,7 @@ export type WebGPUShaderProps = ShaderProps & {
 /**
  * Immutable shader
  */
-export default class WebGPUShader extends Shader {
+export class WebGPUShader extends Shader {
   readonly device: WebGPUDevice;
   readonly handle: GPUShaderModule;
 
@@ -25,7 +27,7 @@ export default class WebGPUShader extends Shader {
     this._checkCompilationError(this.device.handle.popErrorScope());
   }
 
-  async _checkCompilationError(errorScope: Promise<GPUError>): Promise<void> {
+  async _checkCompilationError(errorScope: Promise<GPUError | null>): Promise<void> {
     const error = await errorScope as GPUValidationError;
     if (error) {
       const shaderLog = await this.compilationInfo();
@@ -36,7 +38,7 @@ export default class WebGPUShader extends Shader {
     }
   }
 
-  destroy() {
+  override destroy(): void {
     // this.handle.destroy();
   }
 
@@ -66,7 +68,7 @@ export default class WebGPUShader extends Shader {
 
   /** Returns compilation info for this shader */
   async compilationInfo(): Promise<readonly CompilerMessage[]> {
-    const compilationInfo = await this.handle.compilationInfo();
+    const compilationInfo = await this.handle.getCompilationInfo();
     return compilationInfo.messages;
   }
 }

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

@@ -1,8 +1,8 @@
 // luma.gl, MIT license
-import {Texture, TextureProps, Sampler, SamplerProps, assert} from '@luma.gl/api';
+import {Texture, TextureProps, Sampler, SamplerProps} from '@luma.gl/api';
 import {getWebGPUTextureFormat} from '../helpers/convert-texture-format';
-import type WebGPUDevice from '../webgpu-device';
-import WebGPUSampler from './webgpu-sampler';
+import type {WebGPUDevice} from '../webgpu-device';
+import {WebGPUSampler} from './webgpu-sampler';
 
 const BASE_DIMENSIONS: Record<string, '1d' | '2d' | '3d'> = {
   '1d': '1d',
@@ -13,7 +13,7 @@ const BASE_DIMENSIONS: Record<string, '1d' | '2d' | '3d'> = {
   '3d': '3d'
 };
 
-export default class WebGPUTexture extends Texture {
+export class WebGPUTexture extends Texture {
   readonly device: WebGPUDevice;
   readonly handle: GPUTexture;
   readonly view: GPUTextureView;
@@ -41,7 +41,8 @@ export default 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.setSampler(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.
@@ -81,7 +82,7 @@ export default class WebGPUTexture extends Texture {
     });
   }
 
-  destroy(): void {
+  override destroy(): void {
     this.handle.destroy();
   }