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

package/src/adapter/resources/webgpu-vertex-array.ts

@@ -1,7 +1,8 @@
-// luma.gl, MIT license
+// luma.gl
+// SPDX-License-Identifier: MIT
 // Copyright (c) vis.gl contributors
 
-import type {Device, Buffer, VertexArrayProps, RenderPass, TypedArray} from '@luma.gl/core';
+import type {Device, Buffer, VertexArrayProps, RenderPass} from '@luma.gl/core';
 import {VertexArray, log} from '@luma.gl/core';
 import {getBrowser} from '@probe.gl/env';
 
@@ -20,11 +21,6 @@ export class WebGPUVertexArray extends VertexArray {
   /** Vertex Array is a helper class under WebGPU */
   readonly handle: never;
 
-  /** * Attribute 0 can not be disable on most desktop OpenGL based browsers */
-  static isConstantAttributeZeroSupported(device: Device): boolean {
-    return device.info.type === 'webgl2' || getBrowser() === 'Chrome';
-  }
-
   // Create a VertexArray
   constructor(device: WebGPUDevice, props?: VertexArrayProps) {
     super(device, props);
@@ -35,40 +31,42 @@ export class WebGPUVertexArray extends VertexArray {
 
   /**
    * Set an elements buffer, for indexed rendering.
-   * Must be a Buffer bound to buffer with usage bit Buffer.INDEX set. 
+   * Must be a Buffer bound to buffer with usage bit Buffer.INDEX set.
    */
   setIndexBuffer(buffer: Buffer | null): void {
     // assert(!elementBuffer || elementBuffer.glTarget === GL.ELEMENT_ARRAY_BUFFER, ERR_ELEMENTS);
     this.indexBuffer = buffer;
   }
 
-  /** Set a location in vertex attributes array to a buffer, enables the location, sets divisor */
-  setBuffer(location: number, buffer: Buffer): void {
+  /** Set a bufferSlot in vertex attributes array to a buffer, enables the bufferSlot, sets divisor */
+  setBuffer(bufferSlot: number, buffer: Buffer): void {
     // Sanity check target
     // if (buffer.glUsage === GL.ELEMENT_ARRAY_BUFFER) {
     //   throw new Error('Use setIndexBuffer');
     // }
 
-    this.attributes[location] = buffer;
+    this.attributes[bufferSlot] = buffer;
   }
 
-  /** Set a location in vertex attributes array to a constant value, disables the location */
-  override setConstant(location: number, value: TypedArray): void {
-    log.warn(`${this.id} constant attributes not supported on WebGPU`)
-  }
-
-  override bindBeforeRender(renderPass: RenderPass, firstIndex?: number, indexCount?: number): void {
+  override bindBeforeRender(
+    renderPass: RenderPass,
+    firstIndex?: number,
+    indexCount?: number
+  ): void {
     const webgpuRenderPass = renderPass as WebGPURenderPass;
     const webgpuIndexBuffer = this.indexBuffer as WebGPUBuffer;
     if (webgpuIndexBuffer?.handle) {
       // Note we can't unset an index buffer
       log.warn('setting index buffer', webgpuIndexBuffer?.handle, webgpuIndexBuffer?.indexType)();
-      webgpuRenderPass.handle.setIndexBuffer(webgpuIndexBuffer?.handle, webgpuIndexBuffer?.indexType);
+      webgpuRenderPass.handle.setIndexBuffer(
+        webgpuIndexBuffer?.handle,
+        webgpuIndexBuffer?.indexType
+      );
     }
     for (let location = 0; location < this.maxVertexAttributes; location++) {
       const webgpuBuffer = this.attributes[location] as WebGPUBuffer;
       if (webgpuBuffer?.handle) {
-        log.warn('setting vertex buffer', location, webgpuBuffer?.handle)();
+        log.warn(`setting vertex buffer ${location}`, webgpuBuffer?.handle)();
         webgpuRenderPass.handle.setVertexBuffer(location, webgpuBuffer?.handle);
       }
     }
@@ -76,8 +74,18 @@ export class WebGPUVertexArray extends VertexArray {
   }
 
   override unbindAfterRender(renderPass: RenderPass): void {
-    // On WebGPU we don't need to unbind. 
+    // On WebGPU we don't need to unbind.
     // In fact we can't easily do it. setIndexBuffer/setVertexBuffer don't accept null.
     // Unbinding presumably happens automatically when the render pass is ended.
   }
+
+  // DEPRECATED METHODS
+
+  /**
+   * @deprecated is this even an issue for WebGPU?
+   * Attribute 0 can not be disable on most desktop OpenGL based browsers
+   */
+  static isConstantAttributeZeroSupported(device: Device): boolean {
+    return getBrowser() === 'Chrome';
+  }
 }

package/src/adapter/webgpu-canvas-context.ts

@@ -1,4 +1,9 @@
+// luma.gl
+// SPDX-License-Identifier: MIT
+// Copyright (c) vis.gl contributors
+
 // / <reference types="@webgpu/types" />
+
 import type {Texture, TextureFormat, CanvasContextProps} from '@luma.gl/core';
 import {CanvasContext, log} from '@luma.gl/core';
 import {getWebGPUTextureFormat} from './helpers/convert-texture-format';
@@ -6,7 +11,7 @@ import {WebGPUDevice} from './webgpu-device';
 import {WebGPUFramebuffer} from './resources/webgpu-framebuffer';
 import {WebGPUTexture} from './resources/webgpu-texture';
 
-/** 
+/**
  * Holds a WebGPU Canvas Context
  * The primary job of the CanvasContext is to generate textures for rendering into the current canvas
  * It also manages canvas sizing calculations and resizing.
@@ -15,7 +20,7 @@ export class WebGPUCanvasContext extends CanvasContext {
   readonly device: WebGPUDevice;
   readonly gpuCanvasContext: GPUCanvasContext;
   /** Format of returned textures: "bgra8unorm", "rgba8unorm", "rgba16float". */
-  readonly format: TextureFormat = navigator.gpu.getPreferredCanvasFormat();
+  readonly format: TextureFormat = navigator.gpu.getPreferredCanvasFormat() as TextureFormat;
   /** Default stencil format for depth textures */
   depthStencilFormat: TextureFormat = 'depth24plus';
 
@@ -55,7 +60,7 @@ export class WebGPUCanvasContext extends CanvasContext {
     //   height: this.height
     // });
 
-    // Wrap the current canvas context texture in a luma.gl texture 
+    // Wrap the current canvas context texture in a luma.gl texture
     const currentColorAttachment = this.getCurrentTexture();
     this.width = currentColorAttachment.width;
     this.height = currentColorAttachment.height;
@@ -107,7 +112,8 @@ export class WebGPUCanvasContext extends CanvasContext {
   getCurrentTexture(): WebGPUTexture {
     return this.device._createTexture({
       id: `${this.id}#color-texture`,
-      handle: this.gpuCanvasContext.getCurrentTexture()
+      handle: this.gpuCanvasContext.getCurrentTexture(),
+      format: this.format
     });
   }
 

package/src/adapter/webgpu-device.ts

@@ -1,3 +1,7 @@
+// luma.gl
+// SPDX-License-Identifier: MIT
+// Copyright (c) vis.gl contributors
+
 // prettier-ignore
 // / <reference types="@webgpu/types" />
 
@@ -22,9 +26,11 @@ import type {
   // CommandEncoderProps,
   VertexArrayProps,
   TransformFeedback,
-  TransformFeedbackProps
+  TransformFeedbackProps,
+  QuerySet,
+  QuerySetProps
 } from '@luma.gl/core';
-import {Device, CanvasContext, log, uid} from '@luma.gl/core';
+import {Device, DeviceFeatures, CanvasContext, log, uid} from '@luma.gl/core';
 import {WebGPUBuffer} from './resources/webgpu-buffer';
 import {WebGPUTexture} from './resources/webgpu-texture';
 import {WebGPUExternalTexture} from './resources/webgpu-external-texture';
@@ -39,23 +45,33 @@ import {WebGPUComputePass} from './resources/webgpu-compute-pass';
 import {WebGPUVertexArray} from './resources/webgpu-vertex-array';
 
 import {WebGPUCanvasContext} from './webgpu-canvas-context';
-// import {loadGlslangModule} from '../glsl/glslang';
+import {WebGPUQuerySet} from './resources/webgpu-query-set';
 
 /** WebGPU Device implementation */
 export class WebGPUDevice extends Device {
+  static type: string = 'webgpu';
+
+  /** type of this device */
+  readonly type = 'webgpu';
+
+  /** The underlying WebGPU device */
   readonly handle: GPUDevice;
+  /* The underlying WebGPU adapter */
   readonly adapter: GPUAdapter;
+  /* The underlying WebGPU adapter's info */
+  readonly adapterInfo: GPUAdapterInfo;
+
+  readonly features: DeviceFeatures;
+  readonly info: DeviceInfo;
+  readonly limits: DeviceLimits;
+
   readonly lost: Promise<{reason: 'destroyed'; message: string}>;
   canvasContext: WebGPUCanvasContext | null = null;
 
+  private _isLost: boolean = false;
   commandEncoder: GPUCommandEncoder | null = null;
   renderPass: WebGPURenderPass | null = null;
 
-  private _info: DeviceInfo;
-  private _isLost: boolean = false;
-
-  static type: string = 'webgpu';
-
   /** Check if WebGPU is available */
   static isSupported(): boolean {
     return Boolean(typeof navigator !== 'undefined' && navigator.gpu);
@@ -79,11 +95,23 @@ export class WebGPUDevice extends Device {
     const adapterInfo = await adapter.requestAdapterInfo();
     log.probe(2, 'Adapter available', adapterInfo)();
 
+    const requiredFeatures: GPUFeatureName[] = [];
+    const requiredLimits: Record<string, number> = {};
+
+    if (props.requestMaxLimits) {
+      requiredFeatures.push(...(Array.from(adapter.features) as GPUFeatureName[]));
+      for (const key in adapter.limits) {
+        requiredLimits[key] = adapter.limits[key];
+      }
+      delete requiredLimits.minSubgroupSize;
+      delete requiredLimits.maxSubgroupSize;
+    }
+
     const gpuDevice = await adapter.requestDevice({
-      requiredFeatures: adapter.features as ReadonlySet<GPUFeatureName>
-      // TODO ensure we obtain best limits
-      // requiredLimits: adapter.limits
+      requiredFeatures,
+      requiredLimits
     });
+
     log.probe(1, 'GPUDevice available')();
 
     if (typeof props.canvas === 'string') {
@@ -93,41 +121,29 @@ export class WebGPUDevice extends Device {
 
     const device = new WebGPUDevice(gpuDevice, adapter, adapterInfo, props);
 
-    log.probe(1, 'Device created. For more info, set chrome://flags/#enable-webgpu-developer-features')();
+    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, adapterInfo: GPUAdapterInfo, 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;
+    this.adapterInfo = adapterInfo;
 
-    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,
-      renderer,
-      version,
-      gpu, 
-      gpuType,
-      gpuBackend,
-      gpuArchitecture,
-      shadingLanguage: 'wgsl',
-      shadingLanguageVersion: 100
-    };
+    this.info = this._getInfo();
+    this.features = this._getFeatures();
+    this.limits = this.handle.limits;
 
     // "Context" loss handling
     this.lost = new Promise<{reason: 'destroyed'; message: string}>(async resolve => {
@@ -145,8 +161,6 @@ export class WebGPUDevice extends Device {
       container: props.container
     });
     // }
-
-    this.features = this._getFeatures();
   }
 
   // TODO
@@ -158,23 +172,17 @@ export class WebGPUDevice extends Device {
     this.handle.destroy();
   }
 
-  get info(): DeviceInfo {
-    return this._info;
-  }
-
-  features: Set<DeviceFeature>;
-
-  get limits(): DeviceLimits {
-    return this.handle.limits;
-  }
-
   isTextureFormatSupported(format: TextureFormat): boolean {
     return !format.includes('webgl');
   }
 
   /** @todo implement proper check? */
   isTextureFormatFilterable(format: TextureFormat): boolean {
-    return this.isTextureFormatSupported(format);
+    return (
+      this.isTextureFormatSupported(format) &&
+      !format.startsWith('depth') &&
+      !format.startsWith('stencil')
+    );
   }
 
   /** @todo implement proper check? */
@@ -212,7 +220,7 @@ export class WebGPUDevice extends Device {
   }
 
   createFramebuffer(props: FramebufferProps): WebGPUFramebuffer {
-    throw new Error('Not implemented');
+    return new WebGPUFramebuffer(this, props);
   }
 
   createComputePipeline(props: ComputePipelineProps): WebGPUComputePipeline {
@@ -247,24 +255,12 @@ export class WebGPUDevice extends Device {
     throw new Error('Transform feedback not supported in WebGPU');
   }
 
-  createCanvasContext(props: CanvasContextProps): WebGPUCanvasContext {
-    return new WebGPUCanvasContext(this, this.adapter, props);
+  override createQuerySet(props: QuerySetProps): QuerySet {
+    return new WebGPUQuerySet(this, props);
   }
 
-  /**
-   * Gets default renderpass encoder.
-   * Creates a new encoder against default canvasContext if not already created
-   * @note Called internally by Model.
-   * @deprecated Create explicit pass with device.beginRenderPass
-   */
-  getDefaultRenderPass(): WebGPURenderPass {
-    // this.renderPass =
-    //   this.renderPass ||
-    //   this.beginRenderPass({
-    //     framebuffer: this.canvasContext?.getCurrentFramebuffer()
-    //   });
-    // return this.renderPass;
-    throw new Error('a');
+  createCanvasContext(props: CanvasContextProps): WebGPUCanvasContext {
+    return new WebGPUCanvasContext(this, this.adapter, props);
   }
 
   submit(): void {
@@ -277,10 +273,38 @@ export class WebGPUDevice extends Device {
     // this.renderPass = null;
   }
 
-  _getFeatures() {
-    // WebGPU Features
-    const features = new Set<DeviceFeature>(this.handle.features as Set<DeviceFeature>);
+  // PRIVATE METHODS
+
+  protected _getInfo(): DeviceInfo {
+    const [driver, driverVersion] = ((this.adapterInfo as any).driver || '').split(' Version ');
+
+    // See https://developer.chrome.com/blog/new-in-webgpu-120#adapter_information_updates
+    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 gpuArchitecture = this.adapterInfo.architecture || 'unknown';
+    const gpuBackend = (this.adapterInfo as any).backend || 'unknown';
+    const gpuType = ((this.adapterInfo as any).type || '').split(' ')[0].toLowerCase() || 'unknown';
+
+    return {
+      type: 'webgpu',
+      vendor,
+      renderer,
+      version,
+      gpu,
+      gpuType,
+      gpuBackend,
+      gpuArchitecture,
+      shadingLanguage: 'wgsl',
+      shadingLanguageVersion: 100
+    };
+  }
 
+  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>);
     // Fixups for pre-standard names: https://github.com/webgpu-native/webgpu-headers/issues/133
     // @ts-expect-error Chrome Canary v99
     if (features.has('depth-clamping')) {
@@ -289,47 +313,26 @@ export class WebGPUDevice extends Device {
       features.add('depth-clip-control');
     }
 
-    // Add subsets
+    // Some subsets of WebGPU extensions correspond to WebGL extensions
     if (features.has('texture-compression-bc')) {
       features.add('texture-compression-bc5-webgl');
     }
 
-    features.add('webgpu');
-
-    features.add('timer-query-webgl');
-
-    // WEBGL1 SUPPORT
-    features.add('vertex-array-object-webgl1');
-    features.add('instanced-rendering-webgl1');
-    features.add('multiple-render-targets-webgl1');
-    features.add('index-uint32-webgl1');
-    features.add('blend-minmax-webgl1');
-    features.add('texture-blend-float-webgl1');
-
-    // TEXTURES, RENDERBUFFERS
-    features.add('texture-formats-srgb-webgl1');
-
-    // TEXTURES
-    features.add('texture-formats-depth-webgl1');
-    features.add('texture-formats-float32-webgl1');
-    features.add('texture-formats-float16-webgl1');
-
-    features.add('texture-filter-linear-float32-webgl');
-    features.add('texture-filter-linear-float16-webgl');
-    features.add('texture-filter-anisotropic-webgl');
-
-    // FRAMEBUFFERS, TEXTURES AND RENDERBUFFERS
-    features.add('texture-renderable-rgba32float-webgl');
-    features.add('texture-renderable-float32-webgl');
-    features.add('texture-renderable-float16-webgl');
-
-    // GLSL extensions
-    features.add('glsl-frag-data');
-    features.add('glsl-frag-depth');
-    features.add('glsl-derivatives');
-    features.add('glsl-texture-lod');
+    const WEBGPU_ALWAYS_FEATURES: DeviceFeature[] = [
+      'timer-query-webgl',
+      'compilation-status-async-webgl',
+      'float32-renderable-webgl',
+      'float16-renderable-webgl',
+      'norm16-renderable-webgl',
+      'texture-filterable-anisotropic-webgl',
+      'shader-noperspective-interpolation-webgl'
+    ];
+
+    for (const feature of WEBGPU_ALWAYS_FEATURES) {
+      features.add(feature);
+    }
 
-    return features;
+    return new DeviceFeatures(Array.from(features), this.props.disabledFeatures);
   }
 
   copyExternalImageToTexture(options: {

package/src/index.ts

@@ -1,4 +1,5 @@
-// luma.gl, MIT license
+// luma.gl
+// SPDX-License-Identifier: MIT
 // Copyright (c) vis.gl contributors
 
 // WEBGPU ADAPTER

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

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

package/dist/adapter/helpers/convert-texture-format.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"convert-texture-format.js","names":["getWebGPUTextureFormat","format","includes","Error"],"sources":["../../../src/adapter/helpers/convert-texture-format.ts"],"sourcesContent":["// luma.gl, MIT license\nimport {TextureFormat} from '@luma.gl/core';\n\n/** Ensure a texture format is WebGPU compatible */\nexport function getWebGPUTextureFormat(format: TextureFormat): GPUTextureFormat {\n  if (format.includes('webgl')) {\n    throw new Error('webgl-only format');\n  }\n  return format as GPUTextureFormat;\n}\n"],"mappings":"AAIA,OAAO,SAASA,sBAAsBA,CAACC,MAAqB,EAAoB;EAC9E,IAAIA,MAAM,CAACC,QAAQ,CAAC,OAAO,CAAC,EAAE;IAC5B,MAAM,IAAIC,KAAK,CAAC,mBAAmB,CAAC;EACtC;EACA,OAAOF,MAAM;AACf"}

package/dist/adapter/helpers/generate-mipmaps.d.ts

@@ -1,10 +0,0 @@
-/// <reference types="dist" />
-/** WebGPU does not have built-in mipmap creation */
-export declare class WebGPUMipmapGenerator {
-    device: GPUDevice;
-    mipmapSampler: GPUSampler;
-    mipmapPipeline: GPURenderPipeline;
-    constructor(device: GPUDevice, glslang: any);
-    generateMipmappedTexture(imageBitmap: ImageBitmap): GPUTexture;
-}
-//# sourceMappingURL=generate-mipmaps.d.ts.map

package/dist/adapter/helpers/generate-mipmaps.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"generate-mipmaps.d.ts","sourceRoot":"","sources":["../../../src/adapter/helpers/generate-mipmaps.ts"],"names":[],"mappings":";AAuBA,oDAAoD;AACpD,qBAAa,qBAAqB;IAChC,MAAM,EAAE,SAAS,CAAC;IAClB,aAAa,EAAE,UAAU,CAAC;IAC1B,cAAc,EAAE,iBAAiB,CAAC;gBAEtB,MAAM,EAAE,SAAS,EAAE,OAAO,KAAA;IAyBtC,wBAAwB,CAAC,WAAW,EAAE,WAAW;CAoDlD"}

package/dist/adapter/helpers/generate-mipmaps.js

@@ -1,100 +0,0 @@
-const VS_GEN_MIPMAP = `\#version 450
-const vec2 pos[4] = vec2[4](vec2(-1.0f, 1.0f), vec2(1.0f, 1.0f), vec2(-1.0f, -1.0f), vec2(1.0f, -1.0f));
-layout(location = 0) out vec2 vTex;
-void main() {
-  gl_Position = vec4(pos[gl_VertexIndex], 0.0, 1.0);
-  vTex = gl_Position / 2.0f + vec2(0.5f);
-}`;
-const FS_GEN_MIPMAP = `#version 450
-layout(set = 0, binding = 0) uniform sampler imgSampler;
-layout(set = 0, binding = 1) uniform texture2D img;
-layout(location = 0) in vec2 vTex;
-layout(location = 0) out vec4 outColor;
-void main() {
-  outColor = texture(sampler2D(img, imgSampler), vTex);
-}`;
-export class WebGPUMipmapGenerator {
-  constructor(device, glslang) {
-    this.device = void 0;
-    this.mipmapSampler = void 0;
-    this.mipmapPipeline = void 0;
-    this.device = device;
-    this.mipmapSampler = device.createSampler({
-      minFilter: 'linear'
-    });
-    this.mipmapPipeline = device.createRenderPipeline({
-      vertexStage: {
-        module: device.createShaderModule({
-          code: glslang.compileGLSL(VS_GEN_MIPMAP, 'vertex')
-        }),
-        entryPoint: 'main'
-      },
-      fragmentStage: {
-        module: device.createShaderModule({
-          code: glslang.compileGLSL(FS_GEN_MIPMAP, 'fragment')
-        }),
-        entryPoint: 'main'
-      },
-      primitiveTopology: 'triangle-strip',
-      colorStates: [{
-        format: 'rgba8unorm'
-      }]
-    });
-  }
-  generateMipmappedTexture(imageBitmap) {
-    const textureSize = {
-      width: imageBitmap.width,
-      height: imageBitmap.height,
-      depth: 1
-    };
-    const mipLevelCount = Math.floor(Math.log2(Math.max(imageBitmap.width, imageBitmap.height))) + 1;
-    const texture = this.device.createTexture({
-      size: textureSize,
-      format: 'rgba8unorm',
-      usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.SAMPLED | GPUTextureUsage.OUTPUT_ATTACHMENT,
-      mipLevelCount
-    });
-    this.device.queue.copyImageBitmapToTexture({
-      imageBitmap
-    }, {
-      texture
-    }, textureSize);
-    const commandEncoder = this.device.createCommandEncoder({});
-    for (let i = 1; i < mipLevelCount; ++i) {
-      const passEncoder = commandEncoder.beginRenderPass({
-        colorAttachments: [{
-          attachment: texture.createView({
-            baseMipLevel: i,
-            mipLevelCount: 1
-          }),
-          loadValue: {
-            r: 1.0,
-            g: 0.0,
-            b: 0.0,
-            a: 0.0
-          }
-        }]
-      });
-      const bindGroup = this.device.createBindGroup({
-        layout: this.mipmapPipeline.getBindGroupLayout(0),
-        bindings: [{
-          binding: 0,
-          resource: this.mipmapSampler
-        }, {
-          binding: 1,
-          resource: texture.createView({
-            baseMipLevel: i - 1,
-            mipLevelCount: 1
-          })
-        }]
-      });
-      passEncoder.setPipeline(this.mipmapPipeline);
-      passEncoder.setBindGroup(0, bindGroup);
-      passEncoder.draw(4);
-      passEncoder.endPass();
-    }
-    this.device.queue.submit([commandEncoder.finish()]);
-    return texture;
-  }
-}
-//# sourceMappingURL=generate-mipmaps.js.map

package/dist/adapter/helpers/generate-mipmaps.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"generate-mipmaps.js","names":["VS_GEN_MIPMAP","FS_GEN_MIPMAP","WebGPUMipmapGenerator","constructor","device","glslang","mipmapSampler","mipmapPipeline","createSampler","minFilter","createRenderPipeline","vertexStage","module","createShaderModule","code","compileGLSL","entryPoint","fragmentStage","primitiveTopology","colorStates","format","generateMipmappedTexture","imageBitmap","textureSize","width","height","depth","mipLevelCount","Math","floor","log2","max","texture","createTexture","size","usage","GPUTextureUsage","COPY_DST","SAMPLED","OUTPUT_ATTACHMENT","queue","copyImageBitmapToTexture","commandEncoder","createCommandEncoder","i","passEncoder","beginRenderPass","colorAttachments","attachment","createView","baseMipLevel","loadValue","r","g","b","a","bindGroup","createBindGroup","layout","getBindGroupLayout","bindings","binding","resource","setPipeline","setBindGroup","draw","endPass","submit","finish"],"sources":["../../../src/adapter/helpers/generate-mipmaps.ts"],"sourcesContent":["// luma.gl, MIT license\n// Forked from Kangz/mipmapper.js under MIT license Copyright 2020 Brandon Jones\n// https://gist.github.com/Kangz/782d5f1ae502daf53910a13f55db2f83\n\n// @ts-nocheck this is written against outdated WebGPU API, needs an update pass\n\nconst VS_GEN_MIPMAP = `\\#version 450\nconst vec2 pos[4] = vec2[4](vec2(-1.0f, 1.0f), vec2(1.0f, 1.0f), vec2(-1.0f, -1.0f), vec2(1.0f, -1.0f));\nlayout(location = 0) out vec2 vTex;\nvoid main() {\n  gl_Position = vec4(pos[gl_VertexIndex], 0.0, 1.0);\n  vTex = gl_Position / 2.0f + vec2(0.5f);\n}`;\n\nconst FS_GEN_MIPMAP = `#version 450\nlayout(set = 0, binding = 0) uniform sampler imgSampler;\nlayout(set = 0, binding = 1) uniform texture2D img;\nlayout(location = 0) in vec2 vTex;\nlayout(location = 0) out vec4 outColor;\nvoid main() {\n  outColor = texture(sampler2D(img, imgSampler), vTex);\n}`;\n\n/** WebGPU does not have built-in mipmap creation */\nexport class WebGPUMipmapGenerator {\n  device: GPUDevice;\n  mipmapSampler: GPUSampler;\n  mipmapPipeline: GPURenderPipeline;\n\n  constructor(device: GPUDevice, glslang) {\n    this.device = device;\n\n    this.mipmapSampler = device.createSampler({ minFilter: 'linear' });\n\n    this.mipmapPipeline = device.createRenderPipeline({\n      vertexStage: {\n        module: device.createShaderModule({\n          code: glslang.compileGLSL(VS_GEN_MIPMAP, 'vertex')\n        }),\n        entryPoint: 'main'\n      },\n      fragmentStage: {\n        module: device.createShaderModule({\n          code: glslang.compileGLSL(FS_GEN_MIPMAP, 'fragment')\n        }),\n        entryPoint: 'main'\n      },\n      primitiveTopology: 'triangle-strip',\n      colorStates: [{\n        format: 'rgba8unorm',\n      }]\n    });\n  }\n\n  generateMipmappedTexture(imageBitmap: ImageBitmap) {\n    const textureSize = {\n      width: imageBitmap.width,\n      height: imageBitmap.height,\n      depth: 1,\n    }\n    const mipLevelCount = Math.floor(Math.log2(Math.max(imageBitmap.width, imageBitmap.height))) + 1;\n\n    // Populate the top level of the srcTexture with the imageBitmap.\n    const texture = this.device.createTexture({\n      size: textureSize,\n      format: 'rgba8unorm',\n      usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.SAMPLED | GPUTextureUsage.OUTPUT_ATTACHMENT,\n      mipLevelCount\n    });\n    this.device.queue.copyImageBitmapToTexture({ imageBitmap }, { texture }, textureSize);\n\n    const commandEncoder = this.device.createCommandEncoder({});\n    for (let i = 1; i < mipLevelCount; ++i) {\n      const passEncoder = commandEncoder.beginRenderPass({\n        colorAttachments: [{\n          attachment: texture.createView({\n            baseMipLevel: i,\n            mipLevelCount: 1\n          }),\n          loadValue: { r: 1.0, g: 0.0, b: 0.0, a: 0.0 },\n        }],\n      });\n\n      const bindGroup = this.device.createBindGroup({\n        layout: this.mipmapPipeline.getBindGroupLayout(0),\n        bindings: [{\n          binding: 0,\n          resource: this.mipmapSampler,\n        }, {\n          binding: 1,\n          resource: texture.createView({\n            baseMipLevel: i - 1,\n            mipLevelCount: 1\n          }),\n        }],\n      });\n\n      passEncoder.setPipeline(this.mipmapPipeline);\n      passEncoder.setBindGroup(0, bindGroup);\n      passEncoder.draw(4);\n      passEncoder.endPass();\n    }\n\n    this.device.queue.submit([commandEncoder.finish()]);\n    return texture;\n  }\n}\n"],"mappings":"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"}

package/dist/adapter/helpers/get-bind-group.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"get-bind-group.js","names":["Buffer","Sampler","Texture","log","cast","makeBindGroupLayout","device","layout","bindings","Error","getBindGroup","bindGroupLayout","shaderLayout","entries","getBindGroupEntries","createBindGroup","getShaderLayoutBinding","bindingName","bindingLayout","find","binding","name","warn","value","Object","push","getBindGroupEntry","location","index","resource","buffer","handle","createView","label"],"sources":["../../../src/adapter/helpers/get-bind-group.ts"],"sourcesContent":["// luma.gl, MIT license\nimport type {ShaderLayout, BindingDeclaration, Binding} from '@luma.gl/core';\nimport {Buffer, Sampler, Texture, log, cast} from '@luma.gl/core';\nimport type {WebGPUBuffer} from '../resources/webgpu-buffer';\nimport type {WebGPUSampler} from '../resources/webgpu-sampler';\nimport type {WebGPUTexture} from '../resources/webgpu-texture';\n\n/**\n * Create a WebGPU \"bind group layout\" from an array of luma.gl bindings\n * @note bind groups can be automatically generated by WebGPU.\n */\nexport function makeBindGroupLayout(\n  device: GPUDevice,\n  layout: GPUBindGroupLayout,\n  bindings: Binding[]\n): GPUBindGroupLayout {\n  throw new Error('not implemented');\n  // return device.createBindGroupLayout({\n  //   layout,\n  //   entries: getBindGroupEntries(bindings)\n  // })\n}\n\n/**\n * Create a WebGPU \"bind group\" from an array of luma.gl bindings\n */\nexport function getBindGroup(\n  device: GPUDevice,\n  bindGroupLayout: GPUBindGroupLayout,\n  shaderLayout: ShaderLayout,\n  bindings: Record<string, Binding>\n): GPUBindGroup {\n  const entries = getBindGroupEntries(bindings, shaderLayout);\n  return device.createBindGroup({\n    layout: bindGroupLayout,\n    entries\n  });\n}\n\nexport function getShaderLayoutBinding(\n  shaderLayout: ShaderLayout,\n  bindingName: string\n): BindingDeclaration {\n  const bindingLayout = shaderLayout.bindings.find(binding => binding.name === bindingName);\n  if (!bindingLayout) {\n    log.warn(`Binding ${bindingName} not set: Not found in shader layout.`)();\n  }\n  return bindingLayout;\n}\n\n/**\n * @param bindings\n * @returns\n */\nfunction getBindGroupEntries(\n  bindings: Record<string, Binding>,\n  shaderLayout: ShaderLayout\n): GPUBindGroupEntry[] {\n  const entries: GPUBindGroupEntry[] = [];\n\n  for (const [bindingName, value] of Object.entries(bindings)) {\n    const bindingLayout = getShaderLayoutBinding(shaderLayout, bindingName);\n    if (bindingLayout) {\n      entries.push(getBindGroupEntry(value, bindingLayout.location));\n    }\n  }\n\n  return entries;\n}\n\nfunction getBindGroupEntry(binding: Binding, index: number): GPUBindGroupEntry {\n  if (binding instanceof Buffer) {\n    return {\n      binding: index,\n      resource: {\n        buffer: cast<WebGPUBuffer>(binding).handle\n      }\n    };\n  }\n  if (binding instanceof Sampler) {\n    return {\n      binding: index,\n      resource: cast<WebGPUSampler>(binding).handle\n    };\n  } else if (binding instanceof Texture) {\n    return {\n      binding: index,\n      resource: cast<WebGPUTexture>(binding).handle.createView({label: 'bind-group-auto-created'})\n    };\n  }\n  throw new Error('invalid binding');\n}\n"],"mappings":"AAEA,SAAQA,MAAM,EAAEC,OAAO,EAAEC,OAAO,EAAEC,GAAG,EAAEC,IAAI,QAAO,eAAe;AASjE,OAAO,SAASC,mBAAmBA,CACjCC,MAAiB,EACjBC,MAA0B,EAC1BC,QAAmB,EACC;EACpB,MAAM,IAAIC,KAAK,CAAC,iBAAiB,CAAC;AAKpC;AAKA,OAAO,SAASC,YAAYA,CAC1BJ,MAAiB,EACjBK,eAAmC,EACnCC,YAA0B,EAC1BJ,QAAiC,EACnB;EACd,MAAMK,OAAO,GAAGC,mBAAmB,CAACN,QAAQ,EAAEI,YAAY,CAAC;EAC3D,OAAON,MAAM,CAACS,eAAe,CAAC;IAC5BR,MAAM,EAAEI,eAAe;IACvBE;EACF,CAAC,CAAC;AACJ;AAEA,OAAO,SAASG,sBAAsBA,CACpCJ,YAA0B,EAC1BK,WAAmB,EACC;EACpB,MAAMC,aAAa,GAAGN,YAAY,CAACJ,QAAQ,CAACW,IAAI,CAACC,OAAO,IAAIA,OAAO,CAACC,IAAI,KAAKJ,WAAW,CAAC;EACzF,IAAI,CAACC,aAAa,EAAE;IAClBf,GAAG,CAACmB,IAAI,CAAE,WAAUL,WAAY,uCAAsC,CAAC,CAAC,CAAC;EAC3E;EACA,OAAOC,aAAa;AACtB;AAMA,SAASJ,mBAAmBA,CAC1BN,QAAiC,EACjCI,YAA0B,EACL;EACrB,MAAMC,OAA4B,GAAG,EAAE;EAEvC,KAAK,MAAM,CAACI,WAAW,EAAEM,KAAK,CAAC,IAAIC,MAAM,CAACX,OAAO,CAACL,QAAQ,CAAC,EAAE;IAC3D,MAAMU,aAAa,GAAGF,sBAAsB,CAACJ,YAAY,EAAEK,WAAW,CAAC;IACvE,IAAIC,aAAa,EAAE;MACjBL,OAAO,CAACY,IAAI,CAACC,iBAAiB,CAACH,KAAK,EAAEL,aAAa,CAACS,QAAQ,CAAC,CAAC;IAChE;EACF;EAEA,OAAOd,OAAO;AAChB;AAEA,SAASa,iBAAiBA,CAACN,OAAgB,EAAEQ,KAAa,EAAqB;EAC7E,IAAIR,OAAO,YAAYpB,MAAM,EAAE;IAC7B,OAAO;MACLoB,OAAO,EAAEQ,KAAK;MACdC,QAAQ,EAAE;QACRC,MAAM,EAAE1B,IAAI,CAAegB,OAAO,CAAC,CAACW;MACtC;IACF,CAAC;EACH;EACA,IAAIX,OAAO,YAAYnB,OAAO,EAAE;IAC9B,OAAO;MACLmB,OAAO,EAAEQ,KAAK;MACdC,QAAQ,EAAEzB,IAAI,CAAgBgB,OAAO,CAAC,CAACW;IACzC,CAAC;EACH,CAAC,MAAM,IAAIX,OAAO,YAAYlB,OAAO,EAAE;IACrC,OAAO;MACLkB,OAAO,EAAEQ,KAAK;MACdC,QAAQ,EAAEzB,IAAI,CAAgBgB,OAAO,CAAC,CAACW,MAAM,CAACC,UAAU,CAAC;QAACC,KAAK,EAAE;MAAyB,CAAC;IAC7F,CAAC;EACH;EACA,MAAM,IAAIxB,KAAK,CAAC,iBAAiB,CAAC;AACpC"}

package/dist/adapter/helpers/get-vertex-buffer-layout.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"get-vertex-buffer-layout.js","names":["log","decodeVertexFormat","getWebGPUVertexFormat","format","endsWith","Error","getVertexBufferLayout","shaderLayout","bufferLayout","vertexBufferLayouts","usedAttributes","Set","mapping","vertexAttributes","stepMode","byteStride","attributes","attributeMapping","attributeName","attribute","attributeLayout","findAttributeLayout","push","offset","byteOffset","shaderLocation","location","byteLength","name","arrayStride","has","getBufferSlots","bufferSlot","bufferSlots","interleaved","add","attributeNames","find","warn"],"sources":["../../../src/adapter/helpers/get-vertex-buffer-layout.ts"],"sourcesContent":["// luma.gl, MIT license\nimport type {ShaderLayout, BufferLayout, AttributeDeclaration, VertexFormat} from '@luma.gl/core';\nimport {log, decodeVertexFormat} from '@luma.gl/core';\n// import {getAttributeInfosFromLayouts} from '@luma.gl/core';\n\n/** Throw error on any WebGL-only vertex formats */\nfunction getWebGPUVertexFormat(format: VertexFormat): GPUVertexFormat {\n  if (format.endsWith('-webgl')) {\n    throw new Error(`WebGPU does not support vertex format ${format}`);\n  }\n  return format as GPUVertexFormat;\n}\n\n/**\n * Build a WebGPU vertex buffer layout intended for use in a GPURenderPassDescriptor.\n * Converts luma.gl attribute definitions to a WebGPU GPUVertexBufferLayout[] array\n * @param layout\n * @param bufferLayout The buffer map is optional\n * @returns WebGPU layout intended for a GPURenderPassDescriptor.\n */\nexport function getVertexBufferLayout(\n  shaderLayout: ShaderLayout,\n  bufferLayout: BufferLayout[]\n): GPUVertexBufferLayout[] {\n  const vertexBufferLayouts: GPUVertexBufferLayout[] = [];\n  const usedAttributes = new Set<string>();\n\n  // First handle any buffers mentioned in `bufferLayout`\n  for (const mapping of bufferLayout) {\n    // Build vertex attributes for one buffer\n    const vertexAttributes: GPUVertexAttribute[] = [];\n\n    // TODO verify that all stepModes for one buffer are the same\n    let stepMode: 'vertex' | 'instance' = 'vertex';\n    let byteStride = 0;\n    // interleaved mapping {..., attributes: [{...}, ...]}\n    if (mapping.attributes) {\n      // const arrayStride = mapping.byteStride; TODO\n      for (const attributeMapping of mapping.attributes) {\n        const attributeName = attributeMapping.attribute;\n        const attributeLayout = findAttributeLayout(shaderLayout, attributeName, usedAttributes);\n\n        stepMode = attributeLayout.stepMode || 'vertex';\n        vertexAttributes.push({\n          format: getWebGPUVertexFormat(attributeMapping.format || mapping.format),\n          offset: attributeMapping.byteOffset,\n          shaderLocation: attributeLayout.location\n        });\n\n        byteStride += decodeVertexFormat(mapping.format).byteLength;\n      }\n      // non-interleaved mapping (just set offset and stride)\n    } else {\n      const attributeLayout = findAttributeLayout(shaderLayout, mapping.name, usedAttributes);\n      if (!attributeLayout) {\n        continue; // eslint-disable-line no-continue\n      }\n      byteStride = decodeVertexFormat(mapping.format).byteLength;\n\n      stepMode = attributeLayout.stepMode || 'vertex';\n      vertexAttributes.push({\n        format: getWebGPUVertexFormat(mapping.format),\n        // We only support 0 offset for non-interleaved buffer layouts\n        offset: 0,\n        shaderLocation: attributeLayout.location\n      });\n    }\n\n    // Store all the attribute bindings for one buffer\n    vertexBufferLayouts.push({\n      arrayStride: mapping.byteStride || byteStride,\n      stepMode: stepMode || 'vertex',\n      attributes: vertexAttributes\n    });\n  }\n\n  // Add any non-mapped attributes - TODO - avoid hardcoded types\n  for (const attribute of shaderLayout.attributes) {\n    if (!usedAttributes.has(attribute.name)) {\n      vertexBufferLayouts.push({\n        arrayStride: decodeVertexFormat('float32x3').byteLength,\n        stepMode: attribute.stepMode || 'vertex',\n        attributes: [\n          {\n            format: getWebGPUVertexFormat('float32x3'),\n            offset: 0,\n            shaderLocation: attribute.location\n          }\n        ]\n      });\n    }\n  }\n\n  return vertexBufferLayouts;\n}\n\nexport function getBufferSlots(\n  shaderLayout: ShaderLayout,\n  bufferLayout: BufferLayout[]\n): Record<string, number> {\n  const usedAttributes = new Set<string>();\n  let bufferSlot = 0;\n  const bufferSlots: Record<string, number> = {};\n\n  // First handle any buffers mentioned in `bufferLayout`\n  for (const mapping of bufferLayout) {\n    // interleaved mapping {..., attributes: [{...}, ...]}\n    if ('attributes' in mapping) {\n      for (const interleaved of mapping.attributes) {\n        usedAttributes.add(interleaved.attribute);\n      }\n      // non-interleaved mapping (just set offset and stride)\n    } else {\n      usedAttributes.add(mapping.name);\n    }\n    bufferSlots[mapping.name] = bufferSlot++;\n  }\n\n  // Add any non-mapped attributes\n  for (const attribute of shaderLayout.attributes) {\n    if (!usedAttributes.has(attribute.name)) {\n      bufferSlots[attribute.name] = bufferSlot++;\n    }\n  }\n\n  return bufferSlots;\n}\n\n/**\n * Looks up an attribute in the ShaderLayout.\n * @throws if name is not in ShaderLayout\n * @throws if name has already been referenced\n */\nfunction findAttributeLayout(\n  shaderLayout: ShaderLayout,\n  name: string,\n  attributeNames: Set<string>\n): AttributeDeclaration {\n  const attribute = shaderLayout.attributes.find(attribute => attribute.name === name);\n  if (!attribute) {\n    log.warn(`Unknown attribute ${name}`)();\n    return null;\n  }\n  if (attributeNames.has(name)) {\n    throw new Error(`Duplicate attribute ${name}`);\n  }\n  attributeNames.add(name);\n  return attribute;\n}\n"],"mappings":"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"}