@luma.gl/webgpu 9.0.0-alpha.52 → 9.0.0-alpha.53

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@luma.gl/webgpu",
-  "version": "9.0.0-alpha.52",
+  "version": "9.0.0-alpha.53",
   "description": "WebGPU adapter for the luma.gl API",
   "type": "module",
   "license": "MIT",
@@ -37,9 +37,9 @@
   },
   "dependencies": {
     "@babel/runtime": "^7.0.0",
-    "@luma.gl/core": "9.0.0-alpha.52",
+    "@luma.gl/core": "9.0.0-alpha.53",
     "@probe.gl/env": "^4.0.2",
     "@webgpu/types": "^0.1.34"
   },
-  "gitHead": "41fa29f78dc260e5ef4c6a48e657fb5d23c96e8f"
+  "gitHead": "f8939f1cf52a15f11ec053d4906e40f0b2a86836"
 }

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

@@ -1,9 +1,5 @@
-import {CommandEncoder, CommandEncoderProps, Buffer, Texture, cast, 
-  CopyTextureToTextureOptions, 
-  CopyTextureToBufferOptions
-  // CopyBufferToTextureOptions,
-  // CopyBufferToBufferOptions,
-} from '@luma.gl/core';
+import {CommandEncoder, CommandEncoderProps, Buffer, Texture} from '@luma.gl/core';
+import type {CopyTextureToTextureOptions, CopyTextureToBufferOptions} from '@luma.gl/core';
 import {WebGPUDevice} from '../webgpu-device';
 import {WebGPUBuffer} from './webgpu-buffer';
 import {WebGPUTexture} from './webgpu-texture';
@@ -15,10 +11,12 @@ export class WebGPUCommandEncoder extends CommandEncoder {
   constructor(device: WebGPUDevice, props: CommandEncoderProps) {
     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 =
+      props.handle ||
+      this.device.handle.createCommandEncoder({
+        // TODO was this removed in standard?
+        // measureExecutionTime: this.props.measureExecutionTime
+      });
     this.handle.label = this.props.id;
   }
 
@@ -32,49 +30,51 @@ export class WebGPUCommandEncoder extends CommandEncoder {
   // beginComputePass(optional GPUComputePassDescriptor descriptor = {}): GPUComputePassEncoder;
 
   copyBufferToBuffer(options: // CopyBufferToBufferOptions
-    {
-      source: Buffer,
-      sourceOffset?: number,
-      destination: Buffer,
-      destinationOffset?: number,
-      size?: number
-    }
-  ): void {
+  {
+    source: Buffer;
+    sourceOffset?: number;
+    destination: Buffer;
+    destinationOffset?: number;
+    size?: number;
+  }): void {
+    const webgpuSourceBuffer = options.source as WebGPUBuffer;
+    const WebGPUDestinationBuffer = options.destination as WebGPUBuffer;
     this.handle.copyBufferToBuffer(
-      cast<WebGPUBuffer>(options.source).handle,
+      webgpuSourceBuffer.handle,
       options.sourceOffset ?? 0,
-      cast<WebGPUBuffer>(options.destination).handle,
+      WebGPUDestinationBuffer.handle,
       options.destinationOffset ?? 0,
       options.size ?? 0
     );
   }
 
   copyBufferToTexture(options: // CopyBufferToTextureOptions
-    {
-    source: Buffer,
-    offset?: number,
-    bytesPerRow: number,
-    rowsPerImage: number,
+  {
+    source: Buffer;
+    offset?: number;
+    bytesPerRow: number;
+    rowsPerImage: number;
 
-    destination: Texture,
+    destination: Texture;
     mipLevel?: number;
-    aspect?: 'all' | 'stencil-only' | 'depth-only',
+    aspect?: 'all' | 'stencil-only' | 'depth-only';
 
-    origin?: number[] | [number, number, number],
-    extent?: number[] | [number, number, number]
-  }
-  ): void {
+    origin?: number[] | [number, number, number];
+    extent?: number[] | [number, number, number];
+  }): void {
+    const webgpuSourceBuffer = options.source as WebGPUBuffer;
+    const WebGPUDestinationTexture = options.destination as WebGPUTexture;
     this.handle.copyBufferToTexture(
       {
-        buffer: cast<WebGPUBuffer>(options.source).handle,
+        buffer: webgpuSourceBuffer.handle,
         offset: options.offset ?? 0,
         bytesPerRow: options.bytesPerRow,
-        rowsPerImage: options.rowsPerImage,
+        rowsPerImage: options.rowsPerImage
       },
       {
-        texture: cast<WebGPUTexture>(options.destination).handle,
+        texture: WebGPUDestinationTexture.handle,
         mipLevel: options.mipLevel ?? 0,
-        origin: options.origin ?? {},
+        origin: options.origin ?? {}
         // aspect: options.aspect
       },
       {
@@ -129,4 +129,4 @@ export class WebGPUCommandEncoder extends CommandEncoder {
   //   destination: Buffer,
   //   destinationOffset?: number;
   // }): void;
-}
+}

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

@@ -1,4 +1,4 @@
-import {ComputePass, ComputePassProps, ComputePipeline, Buffer, Binding, cast} from '@luma.gl/core';
+import {ComputePass, ComputePassProps, ComputePipeline, Buffer, Binding} from '@luma.gl/core';
 import {WebGPUDevice} from '../webgpu-device';
 import {WebGPUBuffer} from './webgpu-buffer';
 // import {WebGPUCommandEncoder} from './webgpu-command-encoder';
@@ -27,7 +27,7 @@ export class WebGPUComputePass extends ComputePass {
   }
 
   setPipeline(pipeline: ComputePipeline): void {
-    const wgpuPipeline = cast<WebGPUComputePipeline>(pipeline);
+    const wgpuPipeline = pipeline as WebGPUComputePipeline;
     this.handle.setPipeline(wgpuPipeline.handle);
     this._bindGroupLayout = wgpuPipeline._getBindGroupLayout();
   }
@@ -55,7 +55,8 @@ export class WebGPUComputePass extends ComputePass {
    * @param indirectOffset
    */
   dispatchIndirect(indirectBuffer: Buffer, indirectOffset: number = 0): void {
-    this.handle.dispatchWorkgroupsIndirect(cast<WebGPUBuffer>(indirectBuffer).handle, indirectOffset);
+    const webgpuBuffer = indirectBuffer as WebGPUBuffer;
+    this.handle.dispatchWorkgroupsIndirect(webgpuBuffer.handle, indirectOffset);
   }
 
   pushDebugGroup(groupLabel: string): void {

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

@@ -1,5 +1,5 @@
 // prettier-ignore
-import {ComputePipeline, ComputePipelineProps, cast} from '@luma.gl/core';
+import {ComputePipeline, ComputePipelineProps} from '@luma.gl/core';
 
 import {WebGPUDevice} from '../webgpu-device';
 import {WebGPUShader} from './webgpu-shader';
@@ -15,11 +15,11 @@ export class WebGPUComputePipeline extends ComputePipeline {
     super(device, props);
     this.device = device;
 
-    const module = cast<WebGPUShader>(this.props.cs).handle;
+    const webgpuShader = this.props.cs as WebGPUShader;
     this.handle = this.props.handle || this.device.handle.createComputePipeline({
       label: this.props.id,
       compute: {
-        module,
+        module: webgpuShader.handle,
         entryPoint: this.props.csEntryPoint,
         // constants: this.props.csConstants
       },

package/src/adapter/webgpu-device.ts

@@ -77,7 +77,7 @@ export class WebGPUDevice extends Device {
     }
 
     const adapterInfo = await adapter.requestAdapterInfo();
-    log.probe(1, 'Adapter available', adapterInfo)();
+    log.probe(2, 'Adapter available', adapterInfo)();
 
     const gpuDevice = await adapter.requestDevice({
       requiredFeatures: adapter.features as ReadonlySet<GPUFeatureName>
@@ -91,28 +91,42 @@ export class WebGPUDevice extends Device {
       log.probe(1, 'DOM is loaded')();
     }
 
-    const device = new WebGPUDevice(gpuDevice, adapter, props);
-    log.probe(1, 'Device created', device.info)();
+    const device = new WebGPUDevice(gpuDevice, adapter, adapterInfo, props);
+
+    log.probe(1, 'Device created. For more info, set chrome://flags/#enable-webgpu-developer-features')();
     log.table(1, device.info)();
     log.groupEnd(1)();
     return device;
   }
 
-  constructor(device: GPUDevice, adapter: GPUAdapter, props: DeviceProps) {
+  constructor(device: GPUDevice, adapter: GPUAdapter, adapterInfo: GPUAdapterInfo, props: DeviceProps) {
     super({...props, id: props.id || uid('webgpu-device')});
     this.handle = device;
     this.adapter = adapter;
 
+    const [driver, driverVersion] = ((adapterInfo as any).driver || '').split(' Version ');
+
+    // See https://developer.chrome.com/blog/new-in-webgpu-120#adapter_information_updates
+    const vendor = adapterInfo.vendor || this.adapter.__brand || 'unknown';
+    const renderer = driver || '';
+    const version = driverVersion || '';
+
+    const gpu = vendor === 'apple' ? 'apple' : 'unknown'; // 'nvidia' | 'amd' | 'intel' | 'apple' | 'unknown',
+    const gpuArchitecture = adapterInfo.architecture || 'unknown';
+    const gpuBackend = (adapterInfo as any).backend || 'unknown';
+    const gpuType = ((adapterInfo as any).type || '').split(' ')[0].toLowerCase()  || 'unknown'
+
     this._info = {
       type: 'webgpu',
-      vendor: this.adapter.__brand,
-      renderer: '',
-      version: '',
-      gpu: 'unknown', // 'nvidia' | 'amd' | 'intel' | 'apple' | 'unknown',
+      vendor,
+      renderer,
+      version,
+      gpu, 
+      gpuType,
+      gpuBackend,
+      gpuArchitecture,
       shadingLanguage: 'wgsl',
-      shadingLanguageVersion: 100,
-      vendorMasked: '',
-      rendererMasked: ''
+      shadingLanguageVersion: 100
     };
 
     // "Context" loss handling