@luma.gl/webgpu 9.0.0-alpha.14 → 9.0.0-alpha.16

package/dist/esm/adapter/webgpu-device.js

@@ -0,0 +1,196 @@
+import _defineProperty from "@babel/runtime/helpers/esm/defineProperty";
+import { Device, CanvasContext, log, uid } from '@luma.gl/api';
+import WebGPUBuffer from './resources/webgpu-buffer';
+import WebGPUTexture from './resources/webgpu-texture';
+import WebGPUExternalTexture from './resources/webgpu-external-texture';
+import WebGPUSampler from './resources/webgpu-sampler';
+import WebGPUShader from './resources/webgpu-shader';
+import WebGPURenderPipeline from './resources/webgpu-render-pipeline';
+import WebGPUComputePipeline from './resources/webgpu-compute-pipeline';
+import WebGPURenderPass from './resources/webgpu-render-pass';
+import WebGPUComputePass from './resources/webgpu-compute-pass';
+import WebGPUCanvasContext from './webgpu-canvas-context';
+export default class WebGPUDevice extends Device {
+  static isSupported() {
+    return Boolean(typeof navigator !== 'undefined' && navigator.gpu);
+  }
+  static async create(props) {
+    if (!navigator.gpu) {
+      throw new Error('WebGPU not available. Open in Chrome Canary and turn on chrome://flags/#enable-unsafe-webgpu');
+    }
+    log.groupCollapsed(1, 'WebGPUDevice created')();
+    const adapter = await navigator.gpu.requestAdapter({
+      powerPreference: 'high-performance'
+    });
+    if (!adapter) {
+      throw new Error('Failed to request WebGPU adapter');
+    }
+    log.probe(1, 'Adapter available')();
+    const gpuDevice = await adapter.requestDevice({
+      requiredFeatures: adapter.features
+    });
+    log.probe(1, 'GPUDevice available')();
+    if (typeof props.canvas === 'string') {
+      await CanvasContext.pageLoaded;
+      log.probe(1, 'DOM is loaded')();
+    }
+    const device = new WebGPUDevice(gpuDevice, adapter, props);
+    log.probe(1, 'Device created', device.info)();
+    log.table(1, device.info)();
+    log.groupEnd(1)();
+    return device;
+  }
+  constructor(device, adapter, props) {
+    super({
+      ...props,
+      id: props.id || uid('webgpu-device')
+    });
+    _defineProperty(this, "handle", void 0);
+    _defineProperty(this, "adapter", void 0);
+    _defineProperty(this, "lost", void 0);
+    _defineProperty(this, "canvasContext", null);
+    _defineProperty(this, "commandEncoder", null);
+    _defineProperty(this, "renderPass", null);
+    _defineProperty(this, "_info", void 0);
+    _defineProperty(this, "_isLost", false);
+    _defineProperty(this, "features", void 0);
+    this.handle = device;
+    this.adapter = adapter;
+    this._info = {
+      type: 'webgpu',
+      vendor: this.adapter.__brand,
+      renderer: '',
+      version: '',
+      gpu: 'unknown',
+      shadingLanguages: ['glsl', 'wgsl'],
+      shadingLanguageVersions: {
+        glsl: '450',
+        wgsl: '100'
+      },
+      vendorMasked: '',
+      rendererMasked: ''
+    };
+    this.lost = new Promise(async resolve => {
+      const lostInfo = await this.handle.lost;
+      this._isLost = true;
+      resolve({
+        reason: 'destroyed',
+        message: lostInfo.message
+      });
+    });
+    if (props.canvas) {
+      this.canvasContext = new WebGPUCanvasContext(this, this.adapter, {
+        canvas: props.canvas
+      });
+    }
+    this.features = this._getFeatures();
+  }
+  destroy() {
+    this.handle.destroy();
+  }
+  get info() {
+    return this._info;
+  }
+  get limits() {
+    return this.handle.limits;
+  }
+  isTextureFormatSupported(format) {
+    return !format.includes('webgl');
+  }
+  isTextureFormatFilterable(format) {
+    return this.isTextureFormatSupported(format);
+  }
+  isTextureFormatRenderable(format) {
+    return this.isTextureFormatSupported(format);
+  }
+  get isLost() {
+    return this._isLost;
+  }
+  _createBuffer(props) {
+    return new WebGPUBuffer(this, props);
+  }
+  _createTexture(props) {
+    return new WebGPUTexture(this, props);
+  }
+  createExternalTexture(props) {
+    return new WebGPUExternalTexture(this, props);
+  }
+  createShader(props) {
+    return new WebGPUShader(this, props);
+  }
+  createSampler(props) {
+    return new WebGPUSampler(this, props);
+  }
+  createRenderPipeline(props) {
+    return new WebGPURenderPipeline(this, props);
+  }
+  createFramebuffer(props) {
+    throw new Error('Not implemented');
+  }
+  createComputePipeline(props) {
+    return new WebGPUComputePipeline(this, props);
+  }
+  beginRenderPass(props) {
+    this.commandEncoder = this.commandEncoder || this.handle.createCommandEncoder();
+    return new WebGPURenderPass(this, props);
+  }
+  beginComputePass(props) {
+    this.commandEncoder = this.commandEncoder || this.handle.createCommandEncoder();
+    return new WebGPUComputePass(this, props);
+  }
+  createCanvasContext(props) {
+    return new WebGPUCanvasContext(this, this.adapter, props);
+  }
+  getDefaultRenderPass() {
+    var _this$canvasContext;
+    this.renderPass = this.renderPass || this.beginRenderPass({
+      framebuffer: (_this$canvasContext = this.canvasContext) === null || _this$canvasContext === void 0 ? void 0 : _this$canvasContext.getCurrentFramebuffer()
+    });
+    return this.renderPass;
+  }
+  submit() {
+    var _this$renderPass, _this$commandEncoder;
+    (_this$renderPass = this.renderPass) === null || _this$renderPass === void 0 ? void 0 : _this$renderPass.end();
+    const commandBuffer = (_this$commandEncoder = this.commandEncoder) === null || _this$commandEncoder === void 0 ? void 0 : _this$commandEncoder.finish();
+    if (commandBuffer) {
+      this.handle.queue.submit([commandBuffer]);
+    }
+    this.commandEncoder = null;
+    this.renderPass = null;
+  }
+  _getFeatures() {
+    const features = new Set(this.handle.features);
+    if (features.has('depth-clamping')) {
+      features.delete('depth-clamping');
+      features.add('depth-clip-control');
+    }
+    if (features.has('texture-compression-bc')) {
+      features.add('texture-compression-bc5-webgl');
+    }
+    features.add('webgpu');
+    features.add('timer-query-webgl');
+    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');
+    features.add('texture-formats-srgb-webgl1');
+    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');
+    features.add('texture-renderable-rgba32float-webgl');
+    features.add('texture-renderable-float32-webgl');
+    features.add('texture-renderable-float16-webgl');
+    features.add('glsl-frag-data');
+    features.add('glsl-frag-depth');
+    features.add('glsl-derivatives');
+    features.add('glsl-texture-lod');
+    return features;
+  }
+}
+_defineProperty(WebGPUDevice, "type", 'webgpu');
+//# sourceMappingURL=webgpu-device.js.map

package/dist/esm/adapter/webgpu-device.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"webgpu-device.js","names":["Device","CanvasContext","log","uid","WebGPUBuffer","WebGPUTexture","WebGPUExternalTexture","WebGPUSampler","WebGPUShader","WebGPURenderPipeline","WebGPUComputePipeline","WebGPURenderPass","WebGPUComputePass","WebGPUCanvasContext","WebGPUDevice","isSupported","Boolean","navigator","gpu","create","props","Error","groupCollapsed","adapter","requestAdapter","powerPreference","probe","gpuDevice","requestDevice","requiredFeatures","features","canvas","pageLoaded","device","info","table","groupEnd","constructor","id","_defineProperty","handle","_info","type","vendor","__brand","renderer","version","shadingLanguages","shadingLanguageVersions","glsl","wgsl","vendorMasked","rendererMasked","lost","Promise","resolve","lostInfo","_isLost","reason","message","canvasContext","_getFeatures","destroy","limits","isTextureFormatSupported","format","includes","isTextureFormatFilterable","isTextureFormatRenderable","isLost","_createBuffer","_createTexture","createExternalTexture","createShader","createSampler","createRenderPipeline","createFramebuffer","createComputePipeline","beginRenderPass","commandEncoder","createCommandEncoder","beginComputePass","createCanvasContext","getDefaultRenderPass","_this$canvasContext","renderPass","framebuffer","getCurrentFramebuffer","submit","_this$renderPass","_this$commandEncoder","end","commandBuffer","finish","queue","Set","has","delete","add"],"sources":["../../../src/adapter/webgpu-device.ts"],"sourcesContent":["/// <reference types=\"@webgpu/types\" />\n\nimport type {\n  DeviceProps,\n  DeviceInfo,\n  DeviceLimits,\n  DeviceFeature,\n  CanvasContextProps,\n  BufferProps,\n  SamplerProps,\n  ShaderProps,\n  TextureProps,\n  TextureFormat,\n  ExternalTextureProps,\n  FramebufferProps,\n  RenderPipelineProps,\n  ComputePipelineProps,\n  RenderPassProps,\n  ComputePassProps\n} from '@luma.gl/api';\nimport {Device, CanvasContext, log, uid} from '@luma.gl/api';\nimport WebGPUBuffer from './resources/webgpu-buffer';\nimport WebGPUTexture from './resources/webgpu-texture';\nimport WebGPUExternalTexture from './resources/webgpu-external-texture';\nimport WebGPUSampler from './resources/webgpu-sampler';\nimport WebGPUShader from './resources/webgpu-shader';\nimport WebGPURenderPipeline from './resources/webgpu-render-pipeline';\nimport WebGPUFramebuffer from './resources/webgpu-framebuffer';\nimport WebGPUComputePipeline from './resources/webgpu-compute-pipeline';\nimport WebGPURenderPass from './resources/webgpu-render-pass';\nimport WebGPUComputePass from './resources/webgpu-compute-pass';\n\nimport WebGPUCanvasContext from './webgpu-canvas-context';\n// import {loadGlslangModule} from '../glsl/glslang';\n\n/** WebGPU Device implementation */\nexport default class WebGPUDevice extends Device {\n  readonly handle: GPUDevice;\n  readonly adapter: GPUAdapter;\n  readonly lost: Promise<{reason: 'destroyed'; message: string}>;\n  canvasContext: WebGPUCanvasContext | null = null;\n\n  commandEncoder: GPUCommandEncoder | null = null;\n  renderPass: WebGPURenderPass | null = null;\n\n  private _info: DeviceInfo;\n  private _isLost: boolean = false;\n\n  static type: string = 'webgpu';\n\n  /** Check if WebGPU is available */\n  static isSupported(): boolean {\n    return Boolean(typeof navigator !== 'undefined' && navigator.gpu);\n  }\n\n  static async create(props: DeviceProps): Promise<WebGPUDevice> {\n    if (!navigator.gpu) {\n      throw new Error(\n        'WebGPU not available. Open in Chrome Canary and turn on chrome://flags/#enable-unsafe-webgpu'\n      );\n    }\n    log.groupCollapsed(1, 'WebGPUDevice created')();\n    const adapter = await navigator.gpu.requestAdapter({\n      powerPreference: 'high-performance'\n      // forceSoftware: false\n    });\n    if (!adapter) {\n      throw new Error('Failed to request WebGPU adapter');\n    }\n\n    log.probe(1, 'Adapter available')();\n\n    const gpuDevice = await adapter.requestDevice({\n      requiredFeatures: adapter.features as ReadonlySet<GPUFeatureName>\n      // TODO ensure we obtain best limits\n      // requiredLimits: adapter.limits\n    });\n    log.probe(1, 'GPUDevice available')();\n\n    if (typeof props.canvas === 'string') {\n      await CanvasContext.pageLoaded;\n      log.probe(1, 'DOM is loaded')();\n    }\n\n    const device = new WebGPUDevice(gpuDevice, adapter, props);\n    log.probe(1, 'Device created', device.info)();\n    log.table(1, device.info)();\n    log.groupEnd(1)();\n    return device;\n  }\n\n  constructor(device: GPUDevice, adapter: GPUAdapter, props: DeviceProps) {\n    super({...props, id: props.id || uid('webgpu-device')});\n    this.handle = device;\n    this.adapter = adapter;\n\n    this._info = {\n      type: 'webgpu',\n      vendor: this.adapter.__brand,\n      renderer: '',\n      version: '',\n      gpu: 'unknown', // 'nvidia' | 'amd' | 'intel' | 'apple' | 'unknown',\n      shadingLanguages: ['glsl', 'wgsl'],\n      shadingLanguageVersions: {\n        glsl: '450',\n        wgsl: '100'\n      },\n      vendorMasked: '',\n      rendererMasked: ''\n    };\n\n    // \"Context\" loss handling\n    this.lost = new Promise<{reason: 'destroyed'; message: string}>(async (resolve) => {\n      const lostInfo = await this.handle.lost;\n      this._isLost = true;\n      resolve({reason: 'destroyed', message: lostInfo.message});\n    });\n\n    // Note: WebGPU devices can be created without a canvas, for compute shader purposes\n    if (props.canvas) {\n      this.canvasContext = new WebGPUCanvasContext(this, this.adapter, {canvas: props.canvas});\n    }\n\n    this.features = this._getFeatures();\n  }\n\n  // TODO\n  // Load the glslang module now so that it is available synchronously when compiling shaders\n  // const {glsl = true} = props;\n  // this.glslang = glsl && await loadGlslangModule();\n\n  destroy(): void {\n    this.handle.destroy();\n  }\n\n  get info(): DeviceInfo {\n    return this._info;\n  }\n\n  features: Set<DeviceFeature>;\n\n  get limits(): DeviceLimits {\n    return this.handle.limits;\n  }\n\n  isTextureFormatSupported(format: TextureFormat): boolean {\n    return !format.includes('webgl');\n  }\n\n  /** @todo implement proper check? */\n  isTextureFormatFilterable(format: TextureFormat): boolean {\n    return this.isTextureFormatSupported(format);\n  }\n\n  /** @todo implement proper check? */\n  isTextureFormatRenderable(format: TextureFormat): boolean {\n    return this.isTextureFormatSupported(format);\n  }\n\n  get isLost(): boolean {\n    return this._isLost;\n  }\n\n  _createBuffer(props: BufferProps): WebGPUBuffer {\n    return new WebGPUBuffer(this, props);\n  }\n\n  _createTexture(props: TextureProps): WebGPUTexture {\n    return new WebGPUTexture(this, props);\n  }\n\n  createExternalTexture(props: ExternalTextureProps): WebGPUExternalTexture {\n    return new WebGPUExternalTexture(this, props);\n  }\n\n  createShader(props: ShaderProps): WebGPUShader {\n    return new WebGPUShader(this, props);\n  }\n\n  createSampler(props: SamplerProps): WebGPUSampler {\n    return new WebGPUSampler(this, props);\n  }\n\n  createRenderPipeline(props: RenderPipelineProps): WebGPURenderPipeline {\n    return new WebGPURenderPipeline(this, props);\n  }\n\n  createFramebuffer(props: FramebufferProps): WebGPUFramebuffer {\n    throw new Error('Not implemented');\n  }\n\n  createComputePipeline(props: ComputePipelineProps): WebGPUComputePipeline {\n    return new WebGPUComputePipeline(this, props);\n  }\n\n  // WebGPU specifics\n\n  /**\n   * Allows a render pass to begin against a canvas context\n   * @todo need to support a \"Framebuffer\" equivalent (aka preconfigured RenderPassDescriptors?).\n   */\n  beginRenderPass(props: RenderPassProps): WebGPURenderPass {\n    this.commandEncoder = this.commandEncoder || this.handle.createCommandEncoder();\n    return new WebGPURenderPass(this, props);\n  }\n\n  beginComputePass(props: ComputePassProps): WebGPUComputePass {\n    this.commandEncoder = this.commandEncoder || this.handle.createCommandEncoder();\n    return new WebGPUComputePass(this, props);\n  }\n\n  createCanvasContext(props: CanvasContextProps): WebGPUCanvasContext {\n    return new WebGPUCanvasContext(this, this.adapter, props);\n  }\n\n  /**\n   * Gets default renderpass encoder.\n   * Creates a new encoder against default canvasContext if not already created\n   * @note Called internally by Model.\n   */\n  getDefaultRenderPass(): WebGPURenderPass {\n    this.renderPass =\n      this.renderPass ||\n      this.beginRenderPass({\n        framebuffer: this.canvasContext?.getCurrentFramebuffer()\n      });\n    return this.renderPass;\n  }\n\n  submit(): void {\n    this.renderPass?.end();\n    const commandBuffer = this.commandEncoder?.finish();\n    if (commandBuffer) {\n      this.handle.queue.submit([commandBuffer]);\n    }\n    this.commandEncoder = null;\n    this.renderPass = null;\n  }\n\n  _getFeatures() {\n    // WebGPU Features\n    const features = new Set<DeviceFeature>(this.handle.features as Set<DeviceFeature>);\n\n    // Fixups for pre-standard names: https://github.com/webgpu-native/webgpu-headers/issues/133\n    // @ts-expect-error Chrome Canary v99\n    if (features.has('depth-clamping')) {\n      // @ts-expect-error Chrome Canary v99\n      features.delete('depth-clamping');\n      features.add('depth-clip-control');\n    }\n\n    // Add subsets\n    if (features.has('texture-compression-bc')) {\n      features.add('texture-compression-bc5-webgl');\n    }\n\n    features.add('webgpu');\n\n    features.add('timer-query-webgl');\n\n    // WEBGL1 SUPPORT\n    features.add('vertex-array-object-webgl1');\n    features.add('instanced-rendering-webgl1');\n    features.add('multiple-render-targets-webgl1');\n    features.add('index-uint32-webgl1');\n    features.add('blend-minmax-webgl1');\n    features.add('texture-blend-float-webgl1');\n\n    // TEXTURES, RENDERBUFFERS\n    features.add('texture-formats-srgb-webgl1');\n\n    // TEXTURES\n    features.add('texture-formats-depth-webgl1');\n    features.add('texture-formats-float32-webgl1');\n    features.add('texture-formats-float16-webgl1');\n\n    features.add('texture-filter-linear-float32-webgl');\n    features.add('texture-filter-linear-float16-webgl');\n    features.add('texture-filter-anisotropic-webgl');\n\n    // FRAMEBUFFERS, TEXTURES AND RENDERBUFFERS\n    features.add('texture-renderable-rgba32float-webgl');\n    features.add('texture-renderable-float32-webgl');\n    features.add('texture-renderable-float16-webgl');\n\n    // GLSL extensions\n    features.add('glsl-frag-data');\n    features.add('glsl-frag-depth');\n    features.add('glsl-derivatives');\n    features.add('glsl-texture-lod');\n\n    return features;\n  }\n}\n"],"mappings":"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"}

package/dist/esm/adapter/webgpu-types.js

@@ -0,0 +1,2 @@
+
+//# sourceMappingURL=webgpu-types.js.map

package/dist/esm/adapter/webgpu-types.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"webgpu-types.js","names":[],"sources":["../../../src/adapter/webgpu-types.ts"],"sourcesContent":[""],"mappings":""}

package/dist/esm/bundle.js

@@ -0,0 +1,4 @@
+const moduleExports = require('./index');
+globalThis.luma = globalThis.luma || {};
+module.exports = Object.assign(globalThis.luma, moduleExports);
+//# sourceMappingURL=bundle.js.map

package/dist/esm/bundle.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"bundle.js","names":["moduleExports","require","globalThis","luma","module","exports","Object","assign"],"sources":["../../src/bundle.ts"],"sourcesContent":["// @ts-nocheck\nconst moduleExports = require('./index');\nglobalThis.luma = globalThis.luma || {};\nmodule.exports = Object.assign(globalThis.luma, moduleExports);\n"],"mappings":"AACA,MAAMA,aAAa,GAAGC,OAAO,CAAC,SAAS,CAAC;AACxCC,UAAU,CAACC,IAAI,GAAGD,UAAU,CAACC,IAAI,IAAI,CAAC,CAAC;AACvCC,MAAM,CAACC,OAAO,GAAGC,MAAM,CAACC,MAAM,CAACL,UAAU,CAACC,IAAI,EAAEH,aAAa,CAAC"}

package/dist/esm/glsl/glsllang.js

@@ -0,0 +1,9 @@
+let glslang;
+export async function loadGlslangModule() {
+  if (!glslang) {
+    const glslangModule = await import('https://unpkg.com/@webgpu/glslang@0.0.15/dist/web-devel/glslang.js');
+    glslang = await glslangModule.default();
+  }
+  return glslang;
+}
+//# sourceMappingURL=glsllang.js.map

package/dist/esm/glsl/glsllang.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"glsllang.js","names":["glslang","loadGlslangModule","glslangModule","default"],"sources":["../../../src/glsl/glsllang.ts"],"sourcesContent":["// Inspired by webgpu samples at https://github.com/austinEng/webgpu-samples/blob/master/src/glslang.ts\n// under BSD 3-clause license\n\nlet glslang: unknown;\n\n/** Dynamically load the GLSL compiler */\nexport async function loadGlslangModule() {\n  if (!glslang) {\n    // @ts-ignore\n    const glslangModule = await import(/* webpackIgnore: true */ 'https://unpkg.com/@webgpu/glslang@0.0.15/dist/web-devel/glslang.js');\n    glslang = await glslangModule.default();\n  }\n  return glslang;\n}\n"],"mappings":"AAGA,IAAIA,OAAgB;AAGpB,OAAO,eAAeC,iBAAiBA,CAAA,EAAG;EACxC,IAAI,CAACD,OAAO,EAAE;IAEZ,MAAME,aAAa,GAAG,MAAM,MAAM,CAA2B,oEAAoE,CAAC;IAClIF,OAAO,GAAG,MAAME,aAAa,CAACC,OAAO,EAAE;EACzC;EACA,OAAOH,OAAO;AAChB"}

package/dist/esm/index.js

@@ -0,0 +1,8 @@
+import '@luma.gl/api';
+import './init';
+export { default as WebGPUDevice } from './adapter/webgpu-device';
+export { default as WebGPUBuffer } from './adapter/resources/webgpu-buffer';
+export { default as WebGPUTexture } from './adapter/resources/webgpu-texture';
+export { default as WebGPUSampler } from './adapter/resources/webgpu-sampler';
+export { default as WebGPUShader } from './adapter/resources/webgpu-shader';
+//# sourceMappingURL=index.js.map

package/dist/esm/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","names":["default","WebGPUDevice","WebGPUBuffer","WebGPUTexture","WebGPUSampler","WebGPUShader"],"sources":["../../src/index.ts"],"sourcesContent":["\n// Initialize any global state\nimport '@luma.gl/api';\nimport './init'\n\n// WEBGPU ADAPTER\nexport {default as WebGPUDevice} from './adapter/webgpu-device';\n\n// WEBGPU CLASSES (typically not accessed directly)\nexport {default as WebGPUBuffer} from './adapter/resources/webgpu-buffer';\nexport {default as WebGPUTexture} from './adapter/resources/webgpu-texture';\nexport {default as WebGPUSampler} from './adapter/resources/webgpu-sampler';\nexport {default as WebGPUShader} from './adapter/resources/webgpu-shader';\n"],"mappings":"AAEA,OAAO,cAAc;AACrB,OAAO,QAAQ;AAGf,SAAQA,OAAO,IAAIC,YAAY,QAAO,yBAAyB;AAG/D,SAAQD,OAAO,IAAIE,YAAY,QAAO,mCAAmC;AACzE,SAAQF,OAAO,IAAIG,aAAa,QAAO,oCAAoC;AAC3E,SAAQH,OAAO,IAAII,aAAa,QAAO,oCAAoC;AAC3E,SAAQJ,OAAO,IAAIK,YAAY,QAAO,mCAAmC"}

package/dist/esm/init.js

@@ -0,0 +1,4 @@
+import { luma } from '@luma.gl/api';
+import WebGPUDevice from './adapter/webgpu-device';
+luma.registerDevices([WebGPUDevice]);
+//# sourceMappingURL=init.js.map

package/dist/esm/init.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"init.js","names":["luma","WebGPUDevice","registerDevices"],"sources":["../../src/init.ts"],"sourcesContent":["import {luma} from '@luma.gl/api';\nimport WebGPUDevice from './adapter/webgpu-device';\n\nluma.registerDevices([WebGPUDevice]);\n"],"mappings":"AAAA,SAAQA,IAAI,QAAO,cAAc;AACjC,OAAOC,YAAY,MAAM,yBAAyB;AAElDD,IAAI,CAACE,eAAe,CAAC,CAACD,YAAY,CAAC,CAAC"}

package/dist/glsl/glsllang.js

@@ -1,10 +1,12 @@
+// Inspired by webgpu samples at https://github.com/austinEng/webgpu-samples/blob/master/src/glslang.ts
+// under BSD 3-clause license
 let glslang;
+/** Dynamically load the GLSL compiler */
 export async function loadGlslangModule() {
-  if (!glslang) {
-    const glslangModule = await import('https://unpkg.com/@webgpu/glslang@0.0.15/dist/web-devel/glslang.js');
-    glslang = await glslangModule.default();
-  }
-
-  return glslang;
+    if (!glslang) {
+        // @ts-ignore
+        const glslangModule = await import(/* webpackIgnore: true */ 'https://unpkg.com/@webgpu/glslang@0.0.15/dist/web-devel/glslang.js');
+        glslang = await glslangModule.default();
+    }
+    return glslang;
 }
-//# sourceMappingURL=glsllang.js.map

package/dist/index.js

@@ -1,8 +1,10 @@
+// Initialize any global state
 import '@luma.gl/api';
 import './init';
-export { default as WebGPUDevice } from './adapter/webgpu-device';
-export { default as WebGPUBuffer } from './adapter/resources/webgpu-buffer';
-export { default as WebGPUTexture } from './adapter/resources/webgpu-texture';
-export { default as WebGPUSampler } from './adapter/resources/webgpu-sampler';
-export { default as WebGPUShader } from './adapter/resources/webgpu-shader';
-//# sourceMappingURL=index.js.map
+// WEBGPU ADAPTER
+export { default as WebGPUDevice } from './adapter/webgpu-device.js';
+// WEBGPU CLASSES (typically not accessed directly)
+export { default as WebGPUBuffer } from './adapter/resources/webgpu-buffer.js';
+export { default as WebGPUTexture } from './adapter/resources/webgpu-texture.js';
+export { default as WebGPUSampler } from './adapter/resources/webgpu-sampler.js';
+export { default as WebGPUShader } from './adapter/resources/webgpu-shader.js';

package/dist/init.js

@@ -1,4 +1,3 @@
 import { luma } from '@luma.gl/api';
-import WebGPUDevice from './adapter/webgpu-device';
+import WebGPUDevice from './adapter/webgpu-device.js';
 luma.registerDevices([WebGPUDevice]);
-//# sourceMappingURL=init.js.map

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@luma.gl/webgpu",
-  "version": "9.0.0-alpha.14",
+  "version": "9.0.0-alpha.16",
   "description": "WebGPU adapter for the luma.gl API",
   "license": "MIT",
   "repository": {
@@ -13,9 +13,9 @@
     "animation",
     "3d"
   ],
-  "types": "src/index.ts",
-  "main": "dist/index.js",
-  "module": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "main": "dist/es5/index.js",
+  "module": "dist/esm/index.js",
   "files": [
     "src",
     "dist",
@@ -28,9 +28,9 @@
   },
   "dependencies": {
     "@babel/runtime": "^7.0.0",
-    "@luma.gl/api": "9.0.0-alpha.14",
-    "@webgpu/types": "^0.1.9",
-    "probe.gl": "^3.2.1"
+    "@luma.gl/api": "9.0.0-alpha.16",
+    "@probe.gl/env": "^4.0.0",
+    "@webgpu/types": "^0.1.31"
   },
-  "gitHead": "777474ce360ac49de05d7de5ee36e7e276a96e08"
+  "gitHead": "697bc4ef1deff8438e2f3be51bf0bd245882106a"
 }

package/src/adapter/helpers/webgpu-parameters.ts

@@ -5,7 +5,10 @@ function addDepthStencil(descriptor: GPURenderPipelineDescriptor): GPUDepthStenc
     // required, set something
     format: 'depth24plus',
     stencilFront: {},
-    stencilBack: {}
+    stencilBack: {},
+    // TODO can this cause trouble? Should we set to WebGPU defaults? Are there defaults?
+    depthWriteEnabled: undefined!,
+    depthCompare: undefined!
   };
   return descriptor.depthStencil;
 }
@@ -192,7 +195,9 @@ const DEFAULT_PIPELINE_DESCRIPTOR: GPURenderPipelineDescriptor = {
     targets: [
       // { format: props.color0Format || 'bgra8unorm' }
     ]
-  }
+  },
+
+  layout: 'auto'
 };
 
 export function applyParametersToRenderPipelineDescriptor(

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

@@ -11,7 +11,8 @@ export default class WebGPUCommandEncoder extends CommandEncoder {
     super(props);
     this.device = device;
     this.handle = props.handle || this.device.handle.createCommandEncoder({
-      measureExecutionTime: this.props.measureExecutionTime
+      // TODO was this removed in standard?
+      // measureExecutionTime: this.props.measureExecutionTime
     });
     this.handle.label = this.props.id;
   }

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

@@ -22,8 +22,8 @@ export default class WebGPUComputePass extends ComputePass {
   /** @note no WebGPU destroy method, just gc */
   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

@@ -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-framebuffer.ts

@@ -43,9 +43,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 +53,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'
       }));

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

@@ -24,8 +24,8 @@ export default class WebGPURenderPass extends RenderPass {
 
   override destroy(): void {}
 
-  endPass(): void {
-    this.handle.endPass();
+  end(): void {
+    this.handle.end();
   }
 
   setPipeline(pipeline: RenderPipeline): void {

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

@@ -151,7 +151,8 @@ export default class WebGPURenderPipeline extends RenderPipeline {
       fragment,
       primitive: {
         topology: this.props.topology
-      }
+      },
+      layout: 'auto'
     };
 
     // Set parameters on the descriptor

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

@@ -66,7 +66,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/webgpu-canvas-context.ts

@@ -25,6 +25,7 @@ export default class WebGPUCanvasContext extends CanvasContext {
   
     this._setAutoCreatedCanvasId(`${this.device.id}-canvas`);
     this.gpuCanvasContext = this.canvas.getContext('webgpu') as GPUCanvasContext;
+    // @ts-expect-error TODO this has been replaced
     this.format = this.gpuCanvasContext.getPreferredFormat(adapter);
   }
 
@@ -75,9 +76,9 @@ export default class WebGPUCanvasContext extends CanvasContext {
       this.gpuCanvasContext.configure({
         device: this.device.handle,
         format: getWebGPUTextureFormat(this.format),
-        size: [this.width, this.height],
+        // size: [this.width, this.height],
         colorSpace: this.props.colorSpace,
-        compositingAlphaMode: this.props.compositingAlphaMode
+        alphaMode: this.props.alphaMode
       });
 
       log.log(1, `Resized to ${this.width}x${this.height}px`)();

package/src/adapter/webgpu-device.ts

@@ -96,7 +96,7 @@ export default class WebGPUDevice extends Device {
 
     this._info = {
       type: 'webgpu',
-      vendor: this.adapter.name,
+      vendor: this.adapter.__brand,
       renderer: '',
       version: '',
       gpu: 'unknown', // 'nvidia' | 'amd' | 'intel' | 'apple' | 'unknown',
@@ -228,7 +228,7 @@ export default class WebGPUDevice extends Device {
   }
 
   submit(): void {
-    this.renderPass?.endPass();
+    this.renderPass?.end();
     const commandBuffer = this.commandEncoder?.finish();
     if (commandBuffer) {
       this.handle.queue.submit([commandBuffer]);

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

@@ -1 +0,0 @@
-{"version":3,"sources":[],"names":[],"mappings":"","sourcesContent":[],"file":"accessor-to-format.js"}

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

@@ -1 +0,0 @@
-{"version":3,"sources":["../../../src/adapter/helpers/convert-texture-format.ts"],"names":["getWebGPUTextureFormat","format","includes","Error"],"mappings":"AAIA,OAAO,SAASA,sBAAT,CAAgCC,MAAhC,EAAyE;AAC9E,MAAIA,MAAM,CAACC,QAAP,CAAgB,OAAhB,CAAJ,EAA8B;AAC5B,UAAM,IAAIC,KAAJ,CAAU,mBAAV,CAAN;AACD;;AACD,SAAOF,MAAP;AACD","sourcesContent":["// luma.gl, MIT license\nimport {TextureFormat} from '@luma.gl/api';\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"],"file":"convert-texture-format.js"}

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

@@ -1 +0,0 @@
-{"version":3,"sources":["../../../src/adapter/helpers/generate-mipmaps.ts"],"names":["VS_GEN_MIPMAP","FS_GEN_MIPMAP","WebGPUMipmapGenerator","constructor","device","glslang","mipmapSampler","createSampler","minFilter","mipmapPipeline","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","srcTexture","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"],"mappings":"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","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    let 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: srcTexture }, 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"],"file":"generate-mipmaps.js"}

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

@@ -1 +0,0 @@
-{"version":3,"sources":["../../../src/adapter/helpers/get-bind-group.ts"],"names":["Buffer","Sampler","Texture","log","cast","makeBindGroupLayout","device","layout","bindings","Error","getBindGroup","bindGroupLayout","entries","getBindGroupEntries","createBindGroup","getShaderLayoutBinding","bindingName","bindingLayout","find","binding","name","warn","value","Object","push","getBindGroupEntry","location","index","resource","buffer","handle","createView"],"mappings":"AAEA,SAAQA,MAAR,EAAgBC,OAAhB,EAAyBC,OAAzB,EAAkCC,GAAlC,EAAuCC,IAAvC,QAAkD,cAAlD;AASC,OAAO,SAASC,mBAAT,CAA6BC,MAA7B,EAAgDC,MAAhD,EAA4EC,QAA5E,EAAqH;AAC3H,QAAM,IAAIC,KAAJ,CAAU,iBAAV,CAAN;AAKD;AAKD,OAAO,SAASC,YAAT,CACLJ,MADK,EAELK,eAFK,EAGLJ,MAHK,EAILC,QAJK,EAKS;AACd,QAAMI,OAAO,GAAGC,mBAAmB,CAACL,QAAD,EAAWD,MAAX,CAAnC;AACA,SAAOD,MAAM,CAACQ,eAAP,CAAuB;AAC5BP,IAAAA,MAAM,EAAEI,eADoB;AAE5BC,IAAAA;AAF4B,GAAvB,CAAP;AAID;AAED,OAAO,SAASG,sBAAT,CAAgCR,MAAhC,EAAsDS,WAAtD,EAA0F;AAC/F,QAAMC,aAAa,GAAGV,MAAM,CAACC,QAAP,CAAgBU,IAAhB,CAAqBC,OAAO,IAAIA,OAAO,CAACC,IAAR,KAAiBJ,WAAjD,CAAtB;;AACA,MAAI,CAACC,aAAL,EAAoB;AAClBd,IAAAA,GAAG,CAACkB,IAAJ,mBAAoBL,WAApB;AACD;;AACD,SAAOC,aAAP;AACD;;AAMD,SAASJ,mBAAT,CAA6BL,QAA7B,EAAgED,MAAhE,EAA2G;AACzG,QAAMK,OAA4B,GAAG,EAArC;;AAEA,OAAK,MAAM,CAACI,WAAD,EAAcM,KAAd,CAAX,IAAmCC,MAAM,CAACX,OAAP,CAAeJ,QAAf,CAAnC,EAA6D;AAC3D,UAAMS,aAAa,GAAGF,sBAAsB,CAACR,MAAD,EAASS,WAAT,CAA5C;;AACA,QAAIC,aAAJ,EAAmB;AACjBL,MAAAA,OAAO,CAACY,IAAR,CAAaC,iBAAiB,CAACH,KAAD,EAAQL,aAAa,CAACS,QAAtB,CAA9B;AACD;AACF;;AAED,SAAOd,OAAP;AACD;;AAED,SAASa,iBAAT,CAA2BN,OAA3B,EAA6CQ,KAA7C,EAA+E;AAC7E,MAAIR,OAAO,YAAYnB,MAAvB,EAA+B;AAC7B,WAAO;AACLmB,MAAAA,OAAO,EAAEQ,KADJ;AAELC,MAAAA,QAAQ,EAAE;AACRC,QAAAA,MAAM,EAAEzB,IAAI,CAAee,OAAf,CAAJ,CAA4BW;AAD5B;AAFL,KAAP;AAMD;;AACD,MAAIX,OAAO,YAAYlB,OAAvB,EAAgC;AAC9B,WAAO;AACLkB,MAAAA,OAAO,EAAEQ,KADJ;AAELC,MAAAA,QAAQ,EAAExB,IAAI,CAAgBe,OAAhB,CAAJ,CAA6BW;AAFlC,KAAP;AAID,GALD,MAKO,IAAIX,OAAO,YAAYjB,OAAvB,EAAgC;AACrC,WAAO;AACLiB,MAAAA,OAAO,EAAEQ,KADJ;AAELC,MAAAA,QAAQ,EAAExB,IAAI,CAAgBe,OAAhB,CAAJ,CAA6BW,MAA7B,CAAoCC,UAApC;AAFL,KAAP;AAID;;AACD,QAAM,IAAItB,KAAJ,CAAU,iBAAV,CAAN;AACD","sourcesContent":["// luma.gl, MIT license\nimport type {ShaderLayout, BindingLayout, Binding} from '@luma.gl/api';\nimport {Buffer, Sampler, Texture, log, cast} from '@luma.gl/api';\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 */\n export function makeBindGroupLayout(device: GPUDevice, layout: GPUBindGroupLayout, bindings: Binding[]): 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  layout: ShaderLayout,\n  bindings: Record<string, Binding>\n): GPUBindGroup {\n  const entries = getBindGroupEntries(bindings, layout);\n  return device.createBindGroup({\n    layout: bindGroupLayout,\n    entries\n  });\n}\n\nexport function getShaderLayoutBinding(layout: ShaderLayout, bindingName: string): BindingLayout {\n  const bindingLayout = layout.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(bindings: Record<string, Binding>, layout: ShaderLayout): GPUBindGroupEntry[] {\n  const entries: GPUBindGroupEntry[] = [];\n\n  for (const [bindingName, value] of Object.entries(bindings)) {\n    const bindingLayout = getShaderLayoutBinding(layout, 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()\n    };\n  }\n  throw new Error('invalid binding');\n}\n"],"file":"get-bind-group.js"}

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

@@ -1 +0,0 @@
-{"version":3,"sources":["../../../src/adapter/helpers/get-vertex-buffer-layout.ts"],"names":["decodeVertexFormat","getVertexBufferLayout","layout","bufferMap","vertexBufferLayouts","usedAttributes","Set","mapping","vertexAttributes","stepMode","byteStride","byteOffset","interleaved","attributes","attributeLayout","findAttributeLayout","name","push","format","offset","shaderLocation","location","byteLength","arrayStride","attribute","has","getBufferSlots","bufferSlot","bufferSlots","add","attributeNames","find","Error"],"mappings":"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","sourcesContent":["import type {ShaderLayout, BufferMapping, AttributeLayout} from '@luma.gl/api';\nimport {decodeVertexFormat} from '@luma.gl/api';\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 bufferMap The buffer map is optional\n * @returns WebGPU layout intended for a GPURenderPassDescriptor.\n */\nexport function getVertexBufferLayout(layout: ShaderLayout, bufferMap: BufferMapping[]): GPUVertexBufferLayout[] {\n  const vertexBufferLayouts: GPUVertexBufferLayout[] = [];\n  const usedAttributes = new Set<string>();\n\n  // First handle any buffers mentioned in `bufferMapping`\n  for (const mapping of bufferMap) {\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    let byteOffset = mapping.byteOffset || 0;\n\n    // interleaved mapping {..., attributes: [{...}, ...]}\n    if ('attributes' in mapping) {\n      // const arrayStride = mapping.byteStride; TODO \n      for (const interleaved of mapping.attributes) {\n        const attributeLayout = findAttributeLayout(layout, interleaved.name, usedAttributes);\n\n        stepMode = attributeLayout.stepMode || 'vertex';\n        vertexAttributes.push({\n          format: attributeLayout.format,\n          offset: byteOffset + byteStride,\n          shaderLocation: attributeLayout.location\n        });\n\n        byteStride += decodeVertexFormat(attributeLayout.format).byteLength;\n      }\n      // non-interleaved mapping (just set offset and stride)\n    } else {\n      const attributeLayout = findAttributeLayout(layout, mapping.name, usedAttributes);\n      byteStride = decodeVertexFormat(attributeLayout.format).byteLength,\n\n      stepMode = attributeLayout.stepMode || 'vertex';\n      vertexAttributes.push({\n        format: attributeLayout.format,\n        offset: byteOffset,\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\n  for (const attribute of layout.attributes) {\n    if (!usedAttributes.has(attribute.name)) {\n      vertexBufferLayouts.push({\n        arrayStride: decodeVertexFormat(attribute.format).byteLength,\n        stepMode: attribute.stepMode || 'vertex',\n        attributes: [{\n          format: attribute.format,\n          offset: 0,\n          shaderLocation: attribute.location\n        }]\n      });\n    }\n  }\n\n  return vertexBufferLayouts;\n}\n\nexport function getBufferSlots(layout: ShaderLayout, bufferMap: BufferMapping[]): 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 `bufferMapping`\n  for (const mapping of bufferMap) {\n    // interleaved mapping {..., attributes: [{...}, ...]}\n    if ('attributes' in mapping) {\n      for (const interleaved of mapping.attributes) {\n        usedAttributes.add(interleaved.name);\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 layout.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(layout: ShaderLayout, name: string, attributeNames: Set<string>): AttributeLayout {\n  const attribute = layout.attributes.find(attribute => attribute.name === name);\n  if (!attribute) {\n    throw new Error(`Unknown attribute ${name}`);\n  }\n  if (attributeNames.has(name)) {\n    throw new Error(`Duplicate attribute ${name}`);\n  }\n  attributeNames.add(name);\n  return attribute;\n}\n"],"file":"get-vertex-buffer-layout.js"}