@luma.gl/webgpu 9.3.0-alpha.6 → 9.3.0-alpha.8

package/src/adapter/webgpu-device.ts

@@ -6,6 +6,9 @@
 // / <reference types="@webgpu/types" />
 
 import type {
+  Bindings,
+  ComputePipeline,
+  ComputeShaderLayout,
   DeviceInfo,
   DeviceLimits,
   DeviceFeature,
@@ -31,6 +34,8 @@ import type {
   DeviceProps,
   CommandEncoderProps,
   PipelineLayoutProps,
+  RenderPipeline,
+  ShaderLayout
 } from '@luma.gl/core';
 import {Device, DeviceFeatures} from '@luma.gl/core';
 import {WebGPUBuffer} from './resources/webgpu-buffer';
@@ -53,6 +58,7 @@ import {WebGPUFence} from './resources/webgpu-fence';
 
 import {getShaderLayoutFromWGSL} from '../wgsl/get-shader-layout-wgsl';
 import {generateMipmapsWebGPU} from './helpers/generate-mipmaps-webgpu';
+import {getBindGroup} from './helpers/get-bind-group';
 import {
   getCpuHotspotProfiler as getWebGPUCpuHotspotProfiler,
   getCpuHotspotSubmitReason as getWebGPUCpuHotspotSubmitReason,
@@ -240,26 +246,35 @@ export class WebGPUDevice extends Device {
     generateMipmapsWebGPU(this, texture);
   }
 
+  override _createBindGroupLayoutWebGPU(
+    pipeline: RenderPipeline | ComputePipeline,
+    group: number
+  ): GPUBindGroupLayout {
+    return (pipeline as WebGPURenderPipeline | WebGPUComputePipeline).handle.getBindGroupLayout(
+      group
+    );
+  }
+
+  override _createBindGroupWebGPU(
+    bindGroupLayout: unknown,
+    shaderLayout: ShaderLayout | ComputeShaderLayout,
+    bindings: Bindings,
+    group: number
+  ): GPUBindGroup | null {
+    if (Object.keys(bindings).length === 0) {
+      return this.handle.createBindGroup({
+        layout: bindGroupLayout as GPUBindGroupLayout,
+        entries: []
+      });
+    }
+
+    return getBindGroup(this, bindGroupLayout as GPUBindGroupLayout, shaderLayout, bindings, group);
+  }
+
   submit(commandBuffer?: WebGPUCommandBuffer): void {
     let submittedCommandEncoder: WebGPUCommandEncoder | null = null;
     if (!commandBuffer) {
-      submittedCommandEncoder = this.commandEncoder;
-      if (
-        submittedCommandEncoder.getTimeProfilingSlotCount() > 0 &&
-        submittedCommandEncoder.getTimeProfilingQuerySet() instanceof WebGPUQuerySet
-      ) {
-        const querySet = submittedCommandEncoder.getTimeProfilingQuerySet() as WebGPUQuerySet;
-        querySet._encodeResolveToReadBuffer(submittedCommandEncoder, {
-          firstQuery: 0,
-          queryCount: submittedCommandEncoder.getTimeProfilingSlotCount()
-        });
-      }
-      commandBuffer = submittedCommandEncoder.finish();
-      this.commandEncoder.destroy();
-      this.commandEncoder = this.createCommandEncoder({
-        id: submittedCommandEncoder.props.id,
-        timeProfilingQuerySet: submittedCommandEncoder.getTimeProfilingQuerySet()
-      });
+      ({submittedCommandEncoder, commandBuffer} = this._finalizeDefaultCommandEncoderForSubmit());
     }
 
     const profiler = getWebGPUCpuHotspotProfiler(this);
@@ -318,6 +333,32 @@ export class WebGPUDevice extends Device {
     }
   }
 
+  private _finalizeDefaultCommandEncoderForSubmit(): {
+    submittedCommandEncoder: WebGPUCommandEncoder;
+    commandBuffer: WebGPUCommandBuffer;
+  } {
+    const submittedCommandEncoder = this.commandEncoder;
+    if (
+      submittedCommandEncoder.getTimeProfilingSlotCount() > 0 &&
+      submittedCommandEncoder.getTimeProfilingQuerySet() instanceof WebGPUQuerySet
+    ) {
+      const querySet = submittedCommandEncoder.getTimeProfilingQuerySet() as WebGPUQuerySet;
+      querySet._encodeResolveToReadBuffer(submittedCommandEncoder, {
+        firstQuery: 0,
+        queryCount: submittedCommandEncoder.getTimeProfilingSlotCount()
+      });
+    }
+
+    const commandBuffer = submittedCommandEncoder.finish();
+    this.commandEncoder.destroy();
+    this.commandEncoder = this.createCommandEncoder({
+      id: submittedCommandEncoder.props.id,
+      timeProfilingQuerySet: submittedCommandEncoder.getTimeProfilingQuerySet()
+    });
+
+    return {submittedCommandEncoder, commandBuffer};
+  }
+
   // WebGPU specific
 
   pushErrorScope(scope: 'validation' | 'out-of-memory'): void {
@@ -339,11 +380,22 @@ export class WebGPUDevice extends Device {
     }
     const profiler = getWebGPUCpuHotspotProfiler(this);
     const startTime = profiler ? getTimestamp() : 0;
-    this.handle.popErrorScope().then((error: GPUError | null) => {
-      if (error) {
-        handler(error);
-      }
-    });
+    this.handle
+      .popErrorScope()
+      .then((error: GPUError | null) => {
+        if (error) {
+          handler(error);
+        }
+      })
+      .catch((error: unknown) => {
+        if (this.shouldIgnoreDroppedInstanceError(error, 'popErrorScope')) {
+          return;
+        }
+
+        const errorMessage = error instanceof Error ? error.message : String(error);
+        this.reportError(new Error(`${this} popErrorScope failed: ${errorMessage}`), this)();
+        this.debug();
+      });
     if (profiler) {
       profiler.errorScopePopCount = (profiler.errorScopePopCount || 0) + 1;
       profiler.errorScopeTimeMs = (profiler.errorScopeTimeMs || 0) + (getTimestamp() - startTime);
@@ -359,11 +411,22 @@ export class WebGPUDevice extends Device {
     const vendor = this.adapterInfo.vendor || this.adapter.__brand || 'unknown';
     const renderer = driver || '';
     const version = driverVersion || '';
-
-    const gpu = vendor === 'apple' ? 'apple' : 'unknown'; // 'nvidia' | 'amd' | 'intel' | 'apple' | 'unknown',
+    const fallback = Boolean(
+      (this.adapterInfo as any).isFallbackAdapter ??
+        (this.adapter as any).isFallbackAdapter ??
+        false
+    );
+    const softwareRenderer = /SwiftShader/i.test(
+      `${vendor} ${renderer} ${this.adapterInfo.architecture || ''}`
+    );
+
+    const gpu =
+      vendor === 'apple' ? 'apple' : softwareRenderer || fallback ? 'software' : 'unknown'; // 'nvidia' | 'amd' | 'intel' | 'apple' | 'unknown',
     const gpuArchitecture = this.adapterInfo.architecture || 'unknown';
     const gpuBackend = (this.adapterInfo as any).backend || 'unknown';
-    const gpuType = ((this.adapterInfo as any).type || '').split(' ')[0].toLowerCase() || 'unknown';
+    const gpuType =
+      ((this.adapterInfo as any).type || '').split(' ')[0].toLowerCase() ||
+      (softwareRenderer || fallback ? 'cpu' : 'unknown');
 
     return {
       type: 'webgpu',
@@ -374,11 +437,24 @@ export class WebGPUDevice extends Device {
       gpuType,
       gpuBackend,
       gpuArchitecture,
+      fallback,
       shadingLanguage: 'wgsl',
       shadingLanguageVersion: 100
     };
   }
 
+  shouldIgnoreDroppedInstanceError(error: unknown, operation?: string): boolean {
+    const errorMessage = error instanceof Error ? error.message : String(error);
+    return (
+      errorMessage.includes('Instance dropped') &&
+      (!operation || errorMessage.includes(operation)) &&
+      (this._isLost ||
+        this.info.gpu === 'software' ||
+        this.info.gpuType === 'cpu' ||
+        Boolean(this.info.fallback))
+    );
+  }
+
   protected _getFeatures(): DeviceFeatures {
     // Initialize with actual WebGPU Features (note that unknown features may not be in DeviceFeature type)
     const features = new Set<DeviceFeature>(this.handle.features as Set<DeviceFeature>);

package/src/wgsl/get-shader-layout-wgsl.ts

@@ -41,6 +41,15 @@ export function getShaderLayoutFromWGSL(source: string): ShaderLayout {
     });
   }
 
+  for (const storageBuffer of parsedWGSL.storage) {
+    shaderLayout.bindings.push({
+      type: storageBuffer.access === 'read' ? 'read-only-storage' : 'storage',
+      name: storageBuffer.name,
+      group: storageBuffer.group,
+      location: storageBuffer.binding
+    });
+  }
+
   for (const texture of parsedWGSL.textures) {
     const bindingDeclaration: TextureBindingLayout = {
       type: 'texture',

package/dist/adapter/helpers/accessor-to-format.d.ts

@@ -1 +0,0 @@
-//# sourceMappingURL=accessor-to-format.d.ts.map

package/dist/adapter/helpers/accessor-to-format.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"accessor-to-format.d.ts","sourceRoot":"","sources":["../../../src/adapter/helpers/accessor-to-format.ts"],"names":[],"mappings":""}

package/dist/adapter/helpers/accessor-to-format.js

@@ -1,105 +0,0 @@
-"use strict";
-// luma.gl
-// SPDX-License-Identifier: MIT
-// Copyright (c) vis.gl contributors
-/*
-import {assert} from '@luma.gl/core';
-
-type Accessor = Record<string, any>;
-
-const FORMAT_TO_ACCESSOR: Record<GPUVertexFormat, Accessor> = {
-  uchar2: {type: 'uchar', size: 2},
-  uchar4: {type: 'uchar', size: 4},
-  char2: {type: 'char', size: 2},
-  char4: {type: 'char', size: 4},
-  uchar2norm: {type: 'uchar', size: 2, normalized: true},
-  uchar4norm: {type: 'uchar', size: 4, normalized: true},
-  char2norm: {type: 'char', size: 2, normalized: true},
-  char4norm: {type: 'char', size: 4, normalized: true},
-  ushort2: {type: 'ushort', size: 2},
-  ushort4: {type: 'ushort', size: 4},
-  short2: {type: 'short', size: 2},
-  short4: {type: 'short', size: 4},
-  ushort2norm: {type: 'ushort', size: 2, normalized: true},
-  ushort4norm: {type: 'ushort', size: 4, normalized: true},
-  short2norm: {type: 'short', size: 1, normalized: true},
-  short4norm: {type: 'short', size: 1, normalized: true},
-  half2: {type: 'half', size: 2},
-  half4: {type: 'half', size: 4},
-  float: {type: 'float', size: 1},
-  float2: {type: 'float', size: 2},
-  float3: {type: 'float', size: 3},
-  float4: {type: 'float', size: 4},
-  uint: {type: 'uint', size: 1, integer: true},
-  uint2: {type: 'uint', size: 2, integer: true},
-  uint3: {type: 'uint', size: 3, integer: true},
-  uint4: {type: 'uint', size: 4, integer: true},
-  int: {type: 'int', size: 1, integer: true},
-  int2: {type: 'int', size: 2, integer: true},
-  int3: {type: 'int', size: 3, integer: true},
-  int4: {type: 'int', size: 4, integer: true}
-};
-
-/**
- * Convert from WebGPU attribute format strings to accessor {type, size, normalized, integer}
- * @param {*} format
- *
-export function mapWebGPUFormatToAccessor(format) {
-  const accessorDefinition = FORMAT_TO_ACCESSOR[format];
-  assert(accessorDefinition, 'invalid attribute format');
-  return Object.freeze(accessorDefinition);
-}
-
-/**
- * Convert from accessor {type, size, normalized, integer} to WebGPU attribute format strings
- * @param {*} format
- *
-export function mapAccessorToWebGPUFormat(accessor) {
-  const {type = GL.FLOAT, size = 1, normalized = false, integer = false} = accessor;
-  assert(size >=1 && size <=4);
-  // `norm` suffix (uchar4norm)
-  const norm = normalized ? 'norm' : '';
-  // size 1 is ommitted in format names (float vs float2)
-  const count = size === 1 ? '' : size;
-  switch (type) {
-    case GL.UNSIGNED_BYTE:
-      switch (size) {
-        case 2:
-        case 4:
-          return `uchar${count}${norm}`;
-      }
-    case GL.BYTE:
-      switch (size) {
-        case 2:
-        case 4:
-          return `char${count}${norm}`;
-      }
-    case GL.UNSIGNED_SHORT:
-      switch (size) {
-        case 2:
-        case 4:
-          return `ushort${count}${norm}`;
-      }
-    case GL.SHORT:
-      switch (size) {
-        case 2:
-        case 4:
-          return `short${count}${norm}`;
-      }
-    case GL.HALF_FLOAT:
-      switch (size) {
-        case 2:
-        case 4:
-          return `half${count}`;
-      }
-    case GL.FLOAT:
-      return `float${count}`;
-    case GL.UNSIGNED_INT:
-      return `uint${count}`;
-    case GL.INT:
-      return `int${count}`;
-  }
-  throw new Error('illegal accessor');
-}
-*/
-//# sourceMappingURL=accessor-to-format.js.map

package/dist/adapter/helpers/accessor-to-format.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"accessor-to-format.js","sourceRoot":"","sources":["../../../src/adapter/helpers/accessor-to-format.ts"],"names":[],"mappings":";AAAA,UAAU;AACV,+BAA+B;AAC/B,oCAAoC;AAEpC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAmGE"}

package/src/adapter/helpers/accessor-to-format.ts

@@ -1,104 +0,0 @@
-// luma.gl
-// SPDX-License-Identifier: MIT
-// Copyright (c) vis.gl contributors
-
-/*
-import {assert} from '@luma.gl/core';
-
-type Accessor = Record<string, any>;
-
-const FORMAT_TO_ACCESSOR: Record<GPUVertexFormat, Accessor> = {
-  uchar2: {type: 'uchar', size: 2},
-  uchar4: {type: 'uchar', size: 4},
-  char2: {type: 'char', size: 2},
-  char4: {type: 'char', size: 4},
-  uchar2norm: {type: 'uchar', size: 2, normalized: true},
-  uchar4norm: {type: 'uchar', size: 4, normalized: true},
-  char2norm: {type: 'char', size: 2, normalized: true},
-  char4norm: {type: 'char', size: 4, normalized: true},
-  ushort2: {type: 'ushort', size: 2},
-  ushort4: {type: 'ushort', size: 4},
-  short2: {type: 'short', size: 2},
-  short4: {type: 'short', size: 4},
-  ushort2norm: {type: 'ushort', size: 2, normalized: true},
-  ushort4norm: {type: 'ushort', size: 4, normalized: true},
-  short2norm: {type: 'short', size: 1, normalized: true},
-  short4norm: {type: 'short', size: 1, normalized: true},
-  half2: {type: 'half', size: 2},
-  half4: {type: 'half', size: 4},
-  float: {type: 'float', size: 1},
-  float2: {type: 'float', size: 2},
-  float3: {type: 'float', size: 3},
-  float4: {type: 'float', size: 4},
-  uint: {type: 'uint', size: 1, integer: true},
-  uint2: {type: 'uint', size: 2, integer: true},
-  uint3: {type: 'uint', size: 3, integer: true},
-  uint4: {type: 'uint', size: 4, integer: true},
-  int: {type: 'int', size: 1, integer: true},
-  int2: {type: 'int', size: 2, integer: true},
-  int3: {type: 'int', size: 3, integer: true},
-  int4: {type: 'int', size: 4, integer: true}
-};
-
-/**
- * Convert from WebGPU attribute format strings to accessor {type, size, normalized, integer}
- * @param {*} format
- *
-export function mapWebGPUFormatToAccessor(format) {
-  const accessorDefinition = FORMAT_TO_ACCESSOR[format];
-  assert(accessorDefinition, 'invalid attribute format');
-  return Object.freeze(accessorDefinition);
-}
-
-/**
- * Convert from accessor {type, size, normalized, integer} to WebGPU attribute format strings
- * @param {*} format
- *
-export function mapAccessorToWebGPUFormat(accessor) {
-  const {type = GL.FLOAT, size = 1, normalized = false, integer = false} = accessor;
-  assert(size >=1 && size <=4);
-  // `norm` suffix (uchar4norm)
-  const norm = normalized ? 'norm' : '';
-  // size 1 is ommitted in format names (float vs float2)
-  const count = size === 1 ? '' : size;
-  switch (type) {
-    case GL.UNSIGNED_BYTE:
-      switch (size) {
-        case 2:
-        case 4:
-          return `uchar${count}${norm}`;
-      }
-    case GL.BYTE:
-      switch (size) {
-        case 2:
-        case 4:
-          return `char${count}${norm}`;
-      }
-    case GL.UNSIGNED_SHORT:
-      switch (size) {
-        case 2:
-        case 4:
-          return `ushort${count}${norm}`;
-      }
-    case GL.SHORT:
-      switch (size) {
-        case 2:
-        case 4:
-          return `short${count}${norm}`;
-      }
-    case GL.HALF_FLOAT:
-      switch (size) {
-        case 2:
-        case 4:
-          return `half${count}`;
-      }
-    case GL.FLOAT:
-      return `float${count}`;
-    case GL.UNSIGNED_INT:
-      return `uint${count}`;
-    case GL.INT:
-      return `int${count}`;
-  }
-  throw new Error('illegal accessor');
-}
-*/