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

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

@@ -0,0 +1 @@
+{"version":3,"file":"webgpu-device.js","names":["_api","require","_webgpuBuffer","_interopRequireDefault","_webgpuTexture","_webgpuExternalTexture","_webgpuSampler","_webgpuShader","_webgpuRenderPipeline","_webgpuComputePipeline","_webgpuRenderPass","_webgpuComputePass","_webgpuCanvasContext","ownKeys","object","enumerableOnly","keys","Object","getOwnPropertySymbols","symbols","filter","sym","getOwnPropertyDescriptor","enumerable","push","apply","_objectSpread","target","i","arguments","length","source","forEach","key","_defineProperty2","default","getOwnPropertyDescriptors","defineProperties","defineProperty","_createSuper","Derived","hasNativeReflectConstruct","_isNativeReflectConstruct","_createSuperInternal","Super","_getPrototypeOf2","result","NewTarget","constructor","Reflect","construct","_possibleConstructorReturn2","sham","Proxy","Boolean","prototype","valueOf","call","e","WebGPUDevice","_Device","_inherits2","_super","device","adapter","props","_this","_classCallCheck2","id","uid","_assertThisInitialized2","handle","_info","type","vendor","__brand","renderer","version","gpu","shadingLanguages","shadingLanguageVersions","glsl","wgsl","vendorMasked","rendererMasked","lost","Promise","_ref","_asyncToGenerator2","_regenerator","mark","_callee","resolve","lostInfo","wrap","_callee$","_context","prev","next","sent","_isLost","reason","message","stop","_x","canvas","canvasContext","WebGPUCanvasContext","features","_getFeatures","_createClass2","value","destroy","get","limits","isTextureFormatSupported","format","includes","isTextureFormatFilterable","isTextureFormatRenderable","_createBuffer","WebGPUBuffer","_createTexture","WebGPUTexture","createExternalTexture","WebGPUExternalTexture","createShader","WebGPUShader","createSampler","WebGPUSampler","createRenderPipeline","WebGPURenderPipeline","createFramebuffer","Error","createComputePipeline","WebGPUComputePipeline","beginRenderPass","commandEncoder","createCommandEncoder","WebGPURenderPass","beginComputePass","WebGPUComputePass","createCanvasContext","getDefaultRenderPass","_this$canvasContext","renderPass","framebuffer","getCurrentFramebuffer","submit","_this$renderPass","_this$commandEncoder","end","commandBuffer","finish","queue","Set","has","delete","add","isSupported","navigator","_create","_callee2","gpuDevice","_callee2$","_context2","log","groupCollapsed","requestAdapter","powerPreference","probe","requestDevice","requiredFeatures","CanvasContext","pageLoaded","info","table","groupEnd","abrupt","create","_x2","Device","exports"],"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/es5/adapter/webgpu-types.js

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

package/dist/es5/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/es5/bundle.js

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

package/dist/es5/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,IAAMA,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/es5/glsl/glsllang.js

@@ -0,0 +1,47 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.loadGlslangModule = loadGlslangModule;
+var _regenerator = _interopRequireDefault(require("@babel/runtime/regenerator"));
+var _typeof2 = _interopRequireDefault(require("@babel/runtime/helpers/typeof"));
+var _asyncToGenerator2 = _interopRequireDefault(require("@babel/runtime/helpers/asyncToGenerator"));
+function _getRequireWildcardCache(nodeInterop) { if (typeof WeakMap !== "function") return null; var cacheBabelInterop = new WeakMap(); var cacheNodeInterop = new WeakMap(); return (_getRequireWildcardCache = function _getRequireWildcardCache(nodeInterop) { return nodeInterop ? cacheNodeInterop : cacheBabelInterop; })(nodeInterop); }
+function _interopRequireWildcard(obj, nodeInterop) { if (!nodeInterop && obj && obj.__esModule) { return obj; } if (obj === null || (0, _typeof2.default)(obj) !== "object" && typeof obj !== "function") { return { default: obj }; } var cache = _getRequireWildcardCache(nodeInterop); if (cache && cache.has(obj)) { return cache.get(obj); } var newObj = {}; var hasPropertyDescriptor = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var key in obj) { if (key !== "default" && Object.prototype.hasOwnProperty.call(obj, key)) { var desc = hasPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : null; if (desc && (desc.get || desc.set)) { Object.defineProperty(newObj, key, desc); } else { newObj[key] = obj[key]; } } } newObj.default = obj; if (cache) { cache.set(obj, newObj); } return newObj; }
+var glslang;
+function loadGlslangModule() {
+  return _loadGlslangModule.apply(this, arguments);
+}
+function _loadGlslangModule() {
+  _loadGlslangModule = (0, _asyncToGenerator2.default)(_regenerator.default.mark(function _callee() {
+    var glslangModule;
+    return _regenerator.default.wrap(function _callee$(_context) {
+      while (1) switch (_context.prev = _context.next) {
+        case 0:
+          if (glslang) {
+            _context.next = 7;
+            break;
+          }
+          _context.next = 3;
+          return Promise.resolve().then(function () {
+            return _interopRequireWildcard(require('https://unpkg.com/@webgpu/glslang@0.0.15/dist/web-devel/glslang.js'));
+          });
+        case 3:
+          glslangModule = _context.sent;
+          _context.next = 6;
+          return glslangModule.default();
+        case 6:
+          glslang = _context.sent;
+        case 7:
+          return _context.abrupt("return", glslang);
+        case 8:
+        case "end":
+          return _context.stop();
+      }
+    }, _callee);
+  }));
+  return _loadGlslangModule.apply(this, arguments);
+}
+//# sourceMappingURL=glsllang.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"glsllang.js","names":["glslang","loadGlslangModule","_loadGlslangModule","apply","arguments","_asyncToGenerator2","default","_regenerator","mark","_callee","glslangModule","wrap","_callee$","_context","prev","next","Promise","resolve","then","_interopRequireWildcard","require","sent","abrupt","stop"],"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;AAAC,SAGCC,iBAAiBA,CAAA;EAAA,OAAAC,kBAAA,CAAAC,KAAA,OAAAC,SAAA;AAAA;AAAA,SAAAF,mBAAA;EAAAA,kBAAA,OAAAG,kBAAA,CAAAC,OAAA,EAAAC,YAAA,CAAAD,OAAA,CAAAE,IAAA,CAAhC,SAAAC,QAAA;IAAA,IAAAC,aAAA;IAAA,OAAAH,YAAA,CAAAD,OAAA,CAAAK,IAAA,UAAAC,SAAAC,QAAA;MAAA,kBAAAA,QAAA,CAAAC,IAAA,GAAAD,QAAA,CAAAE,IAAA;QAAA;UAAA,IACAf,OAAO;YAAAa,QAAA,CAAAE,IAAA;YAAA;UAAA;UAAAF,QAAA,CAAAE,IAAA;UAAA,OAAAC,OAAA,CAAAC,OAAA,GAAAC,IAAA;YAAA,OAAAC,uBAAA,CAAAC,OAAA,CAEmD,oEAAoE;UAAA;QAAA;UAA3HV,aAAa,GAAAG,QAAA,CAAAQ,IAAA;UAAAR,QAAA,CAAAE,IAAA;UAAA,OACHL,aAAa,CAACJ,OAAO,EAAE;QAAA;UAAvCN,OAAO,GAAAa,QAAA,CAAAQ,IAAA;QAAA;UAAA,OAAAR,QAAA,CAAAS,MAAA,WAEFtB,OAAO;QAAA;QAAA;UAAA,OAAAa,QAAA,CAAAU,IAAA;MAAA;IAAA,GAAAd,OAAA;EAAA,CACf;EAAA,OAAAP,kBAAA,CAAAC,KAAA,OAAAC,SAAA;AAAA"}

package/dist/es5/index.js

@@ -0,0 +1,44 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+Object.defineProperty(exports, "WebGPUBuffer", {
+  enumerable: true,
+  get: function get() {
+    return _webgpuBuffer.default;
+  }
+});
+Object.defineProperty(exports, "WebGPUDevice", {
+  enumerable: true,
+  get: function get() {
+    return _webgpuDevice.default;
+  }
+});
+Object.defineProperty(exports, "WebGPUSampler", {
+  enumerable: true,
+  get: function get() {
+    return _webgpuSampler.default;
+  }
+});
+Object.defineProperty(exports, "WebGPUShader", {
+  enumerable: true,
+  get: function get() {
+    return _webgpuShader.default;
+  }
+});
+Object.defineProperty(exports, "WebGPUTexture", {
+  enumerable: true,
+  get: function get() {
+    return _webgpuTexture.default;
+  }
+});
+require("@luma.gl/api");
+require("./init");
+var _webgpuDevice = _interopRequireDefault(require("./adapter/webgpu-device"));
+var _webgpuBuffer = _interopRequireDefault(require("./adapter/resources/webgpu-buffer"));
+var _webgpuTexture = _interopRequireDefault(require("./adapter/resources/webgpu-texture"));
+var _webgpuSampler = _interopRequireDefault(require("./adapter/resources/webgpu-sampler"));
+var _webgpuShader = _interopRequireDefault(require("./adapter/resources/webgpu-shader"));
+//# sourceMappingURL=index.js.map

package/dist/es5/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","names":["require","_webgpuDevice","_interopRequireDefault","_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":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAEAA,OAAA;AACAA,OAAA;AAGA,IAAAC,aAAA,GAAAC,sBAAA,CAAAF,OAAA;AAGA,IAAAG,aAAA,GAAAD,sBAAA,CAAAF,OAAA;AACA,IAAAI,cAAA,GAAAF,sBAAA,CAAAF,OAAA;AACA,IAAAK,cAAA,GAAAH,sBAAA,CAAAF,OAAA;AACA,IAAAM,aAAA,GAAAJ,sBAAA,CAAAF,OAAA"}

package/dist/es5/init.js

@@ -0,0 +1,7 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+var _api = require("@luma.gl/api");
+var _webgpuDevice = _interopRequireDefault(require("./adapter/webgpu-device"));
+_api.luma.registerDevices([_webgpuDevice.default]);
+//# sourceMappingURL=init.js.map

package/dist/es5/init.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"init.js","names":["_api","require","_webgpuDevice","_interopRequireDefault","luma","registerDevices","WebGPUDevice"],"sources":["../../src/init.ts"],"sourcesContent":["import {luma} from '@luma.gl/api';\nimport WebGPUDevice from './adapter/webgpu-device';\n\nluma.registerDevices([WebGPUDevice]);\n"],"mappings":";;;AAAA,IAAAA,IAAA,GAAAC,OAAA;AACA,IAAAC,aAAA,GAAAC,sBAAA,CAAAF,OAAA;AAEAG,SAAI,CAACC,eAAe,CAAC,CAACC,qBAAY,CAAC,CAAC"}

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

@@ -0,0 +1,2 @@
+
+//# sourceMappingURL=accessor-to-format.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"accessor-to-format.js","names":[],"sources":["../../../../src/adapter/helpers/accessor-to-format.ts"],"sourcesContent":["/*\nimport {assert} from '@luma.gl/api';\nimport GL from '@luma.gl/constants';\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/esm/adapter/helpers/convert-texture-format.js

@@ -0,0 +1,7 @@
+export function getWebGPUTextureFormat(format) {
+  if (format.includes('webgl')) {
+    throw new Error('webgl-only format');
+  }
+  return format;
+}
+//# sourceMappingURL=convert-texture-format.js.map

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

@@ -0,0 +1 @@
+{"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/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"],"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/esm/adapter/helpers/generate-mipmaps.js

@@ -0,0 +1,88 @@
+import _defineProperty from "@babel/runtime/helpers/esm/defineProperty";
+const 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}";
+const 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}";
+export class WebGPUMipmapGenerator {
+  constructor(device, glslang) {
+    _defineProperty(this, "device", void 0);
+    _defineProperty(this, "mipmapSampler", void 0);
+    _defineProperty(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) {
+    let 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: srcTexture
+    }, 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/esm/adapter/helpers/generate-mipmaps.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"generate-mipmaps.js","names":["VS_GEN_MIPMAP","FS_GEN_MIPMAP","WebGPUMipmapGenerator","constructor","device","glslang","_defineProperty","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"],"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    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"],"mappings":"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"}

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

@@ -0,0 +1,51 @@
+import { Buffer, Sampler, Texture, log, cast } from '@luma.gl/api';
+export function makeBindGroupLayout(device, layout, bindings) {
+  throw new Error('not implemented');
+}
+export function getBindGroup(device, bindGroupLayout, layout, bindings) {
+  const entries = getBindGroupEntries(bindings, layout);
+  return device.createBindGroup({
+    layout: bindGroupLayout,
+    entries
+  });
+}
+export function getShaderLayoutBinding(layout, bindingName) {
+  const bindingLayout = layout.bindings.find(binding => binding.name === bindingName);
+  if (!bindingLayout) {
+    log.warn("Binding ".concat(bindingName, " not set: Not found in shader layout."))();
+  }
+  return bindingLayout;
+}
+function getBindGroupEntries(bindings, layout) {
+  const entries = [];
+  for (const [bindingName, value] of Object.entries(bindings)) {
+    const bindingLayout = getShaderLayoutBinding(layout, bindingName);
+    if (bindingLayout) {
+      entries.push(getBindGroupEntry(value, bindingLayout.location));
+    }
+  }
+  return entries;
+}
+function getBindGroupEntry(binding, index) {
+  if (binding instanceof Buffer) {
+    return {
+      binding: index,
+      resource: {
+        buffer: cast(binding).handle
+      }
+    };
+  }
+  if (binding instanceof Sampler) {
+    return {
+      binding: index,
+      resource: cast(binding).handle
+    };
+  } else if (binding instanceof Texture) {
+    return {
+      binding: index,
+      resource: cast(binding).handle.createView()
+    };
+  }
+  throw new Error('invalid binding');
+}
+//# sourceMappingURL=get-bind-group.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"get-bind-group.js","names":["Buffer","Sampler","Texture","log","cast","makeBindGroupLayout","device","layout","bindings","Error","getBindGroup","bindGroupLayout","entries","getBindGroupEntries","createBindGroup","getShaderLayoutBinding","bindingName","bindingLayout","find","binding","name","warn","concat","value","Object","push","getBindGroupEntry","location","index","resource","buffer","handle","createView"],"sources":["../../../../src/adapter/helpers/get-bind-group.ts"],"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"],"mappings":"AAEA,SAAQA,MAAM,EAAEC,OAAO,EAAEC,OAAO,EAAEC,GAAG,EAAEC,IAAI,QAAO,cAAc;AAS/D,OAAO,SAASC,mBAAmBA,CAACC,MAAiB,EAAEC,MAA0B,EAAEC,QAAmB,EAAsB;EAC3H,MAAM,IAAIC,KAAK,CAAC,iBAAiB,CAAC;AAKpC;AAKA,OAAO,SAASC,YAAYA,CAC1BJ,MAAiB,EACjBK,eAAmC,EACnCJ,MAAoB,EACpBC,QAAiC,EACnB;EACd,MAAMI,OAAO,GAAGC,mBAAmB,CAACL,QAAQ,EAAED,MAAM,CAAC;EACrD,OAAOD,MAAM,CAACQ,eAAe,CAAC;IAC5BP,MAAM,EAAEI,eAAe;IACvBC;EACF,CAAC,CAAC;AACJ;AAEA,OAAO,SAASG,sBAAsBA,CAACR,MAAoB,EAAES,WAAmB,EAAiB;EAC/F,MAAMC,aAAa,GAAGV,MAAM,CAACC,QAAQ,CAACU,IAAI,CAACC,OAAO,IAAIA,OAAO,CAACC,IAAI,KAAKJ,WAAW,CAAC;EACnF,IAAI,CAACC,aAAa,EAAE;IAClBd,GAAG,CAACkB,IAAI,YAAAC,MAAA,CAAYN,WAAW,2CAAwC,EAAE;EAC3E;EACA,OAAOC,aAAa;AACtB;AAMA,SAASJ,mBAAmBA,CAACL,QAAiC,EAAED,MAAoB,EAAuB;EACzG,MAAMK,OAA4B,GAAG,EAAE;EAEvC,KAAK,MAAM,CAACI,WAAW,EAAEO,KAAK,CAAC,IAAIC,MAAM,CAACZ,OAAO,CAACJ,QAAQ,CAAC,EAAE;IAC3D,MAAMS,aAAa,GAAGF,sBAAsB,CAACR,MAAM,EAAES,WAAW,CAAC;IACjE,IAAIC,aAAa,EAAE;MACjBL,OAAO,CAACa,IAAI,CAACC,iBAAiB,CAACH,KAAK,EAAEN,aAAa,CAACU,QAAQ,CAAC,CAAC;IAChE;EACF;EAEA,OAAOf,OAAO;AAChB;AAEA,SAASc,iBAAiBA,CAACP,OAAgB,EAAES,KAAa,EAAqB;EAC7E,IAAIT,OAAO,YAAYnB,MAAM,EAAE;IAC7B,OAAO;MACLmB,OAAO,EAAES,KAAK;MACdC,QAAQ,EAAE;QACRC,MAAM,EAAE1B,IAAI,CAAee,OAAO,CAAC,CAACY;MACtC;IACF,CAAC;EACH;EACA,IAAIZ,OAAO,YAAYlB,OAAO,EAAE;IAC9B,OAAO;MACLkB,OAAO,EAAES,KAAK;MACdC,QAAQ,EAAEzB,IAAI,CAAgBe,OAAO,CAAC,CAACY;IACzC,CAAC;EACH,CAAC,MAAM,IAAIZ,OAAO,YAAYjB,OAAO,EAAE;IACrC,OAAO;MACLiB,OAAO,EAAES,KAAK;MACdC,QAAQ,EAAEzB,IAAI,CAAgBe,OAAO,CAAC,CAACY,MAAM,CAACC,UAAU;IAC1D,CAAC;EACH;EACA,MAAM,IAAIvB,KAAK,CAAC,iBAAiB,CAAC;AACpC"}

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

@@ -0,0 +1,83 @@
+import { decodeVertexFormat } from '@luma.gl/api';
+export function getVertexBufferLayout(layout, bufferMap) {
+  const vertexBufferLayouts = [];
+  const usedAttributes = new Set();
+  for (const mapping of bufferMap) {
+    const vertexAttributes = [];
+    let stepMode = 'vertex';
+    let byteStride = 0;
+    let byteOffset = mapping.byteOffset || 0;
+    if ('attributes' in mapping) {
+      for (const interleaved of mapping.attributes) {
+        const attributeLayout = findAttributeLayout(layout, interleaved.name, usedAttributes);
+        stepMode = attributeLayout.stepMode || 'vertex';
+        vertexAttributes.push({
+          format: attributeLayout.format,
+          offset: byteOffset + byteStride,
+          shaderLocation: attributeLayout.location
+        });
+        byteStride += decodeVertexFormat(attributeLayout.format).byteLength;
+      }
+    } else {
+      const attributeLayout = findAttributeLayout(layout, mapping.name, usedAttributes);
+      byteStride = decodeVertexFormat(attributeLayout.format).byteLength, stepMode = attributeLayout.stepMode || 'vertex';
+      vertexAttributes.push({
+        format: attributeLayout.format,
+        offset: byteOffset,
+        shaderLocation: attributeLayout.location
+      });
+    }
+    vertexBufferLayouts.push({
+      arrayStride: mapping.byteStride || byteStride,
+      stepMode: stepMode || 'vertex',
+      attributes: vertexAttributes
+    });
+  }
+  for (const attribute of layout.attributes) {
+    if (!usedAttributes.has(attribute.name)) {
+      vertexBufferLayouts.push({
+        arrayStride: decodeVertexFormat(attribute.format).byteLength,
+        stepMode: attribute.stepMode || 'vertex',
+        attributes: [{
+          format: attribute.format,
+          offset: 0,
+          shaderLocation: attribute.location
+        }]
+      });
+    }
+  }
+  return vertexBufferLayouts;
+}
+export function getBufferSlots(layout, bufferMap) {
+  const usedAttributes = new Set();
+  let bufferSlot = 0;
+  const bufferSlots = {};
+  for (const mapping of bufferMap) {
+    if ('attributes' in mapping) {
+      for (const interleaved of mapping.attributes) {
+        usedAttributes.add(interleaved.name);
+      }
+    } else {
+      usedAttributes.add(mapping.name);
+    }
+    bufferSlots[mapping.name] = bufferSlot++;
+  }
+  for (const attribute of layout.attributes) {
+    if (!usedAttributes.has(attribute.name)) {
+      bufferSlots[attribute.name] = bufferSlot++;
+    }
+  }
+  return bufferSlots;
+}
+function findAttributeLayout(layout, name, attributeNames) {
+  const attribute = layout.attributes.find(attribute => attribute.name === name);
+  if (!attribute) {
+    throw new Error("Unknown attribute ".concat(name));
+  }
+  if (attributeNames.has(name)) {
+    throw new Error("Duplicate attribute ".concat(name));
+  }
+  attributeNames.add(name);
+  return attribute;
+}
+//# sourceMappingURL=get-vertex-buffer-layout.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"get-vertex-buffer-layout.js","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","concat"],"sources":["../../../../src/adapter/helpers/get-vertex-buffer-layout.ts"],"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"],"mappings":"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"}

package/dist/esm/adapter/helpers/webgpu-parameters.js

@@ -0,0 +1,137 @@
+function addDepthStencil(descriptor) {
+  descriptor.depthStencil = descriptor.depthStencil || {
+    format: 'depth24plus',
+    stencilFront: {},
+    stencilBack: {},
+    depthWriteEnabled: undefined,
+    depthCompare: undefined
+  };
+  return descriptor.depthStencil;
+}
+export const PARAMETER_TABLE = {
+  cullMode: (parameter, value, descriptor) => {
+    descriptor.primitive = descriptor.primitive || {};
+    descriptor.primitive.cullMode = value;
+  },
+  frontFace: (parameter, value, descriptor) => {
+    descriptor.primitive = descriptor.primitive || {};
+    descriptor.primitive.frontFace = value;
+  },
+  depthWriteEnabled: (parameter, value, descriptor) => {
+    const depthStencil = addDepthStencil(descriptor);
+    depthStencil.depthWriteEnabled = value;
+  },
+  depthCompare: (parameter, value, descriptor) => {
+    const depthStencil = addDepthStencil(descriptor);
+    depthStencil.depthCompare = value;
+  },
+  depthFormat: (parameter, value, descriptor) => {
+    const depthStencil = addDepthStencil(descriptor);
+    depthStencil.format = value;
+  },
+  depthBias: (parameter, value, descriptor) => {
+    const depthStencil = addDepthStencil(descriptor);
+    depthStencil.depthBias = value;
+  },
+  depthBiasSlopeScale: (parameter, value, descriptor) => {
+    const depthStencil = addDepthStencil(descriptor);
+    depthStencil.depthBiasSlopeScale = value;
+  },
+  depthBiasClamp: (parameter, value, descriptor) => {
+    const depthStencil = addDepthStencil(descriptor);
+    depthStencil.depthBiasClamp = value;
+  },
+  stencilReadMask: (parameter, value, descriptor) => {
+    const depthStencil = addDepthStencil(descriptor);
+    depthStencil.stencilReadMask = value;
+  },
+  stencilWriteMask: (parameter, value, descriptor) => {
+    const depthStencil = addDepthStencil(descriptor);
+    depthStencil.stencilWriteMask = value;
+  },
+  stencilCompare: (parameter, value, descriptor) => {
+    const depthStencil = addDepthStencil(descriptor);
+    depthStencil.stencilFront.compare = value;
+    depthStencil.stencilBack.compare = value;
+  },
+  stencilPassOperation: (parameter, value, descriptor) => {
+    const depthStencil = addDepthStencil(descriptor);
+    depthStencil.stencilFront.passOp = value;
+    depthStencil.stencilBack.passOp = value;
+  },
+  stencilFailOperation: (parameter, value, descriptor) => {
+    const depthStencil = addDepthStencil(descriptor);
+    depthStencil.stencilFront.failOp = value;
+    depthStencil.stencilBack.failOp = value;
+  },
+  stencilDepthFailOperation: (parameter, value, descriptor) => {
+    const depthStencil = addDepthStencil(descriptor);
+    depthStencil.stencilFront.depthFailOp = value;
+    depthStencil.stencilBack.depthFailOp = value;
+  },
+  sampleCount: (parameter, value, descriptor) => {
+    descriptor.multisample = descriptor.multisample || {};
+    descriptor.multisample.count = value;
+  },
+  sampleMask: (parameter, value, descriptor) => {
+    descriptor.multisample = descriptor.multisample || {};
+    descriptor.multisample.mask = value;
+  },
+  sampleAlphaToCoverageEnabled: (parameter, value, descriptor) => {
+    descriptor.multisample = descriptor.multisample || {};
+    descriptor.multisample.alphaToCoverageEnabled = value;
+  },
+  colorMask: (parameter, value, descriptor) => {
+    const targets = addColorState(descriptor);
+    targets[0].writeMask = value;
+  },
+  blendColorOperation: (parameter, value, descriptor) => {
+    addColorState(descriptor);
+  }
+};
+const DEFAULT_PIPELINE_DESCRIPTOR = {
+  primitive: {
+    cullMode: 'back',
+    topology: 'triangle-list'
+  },
+  vertex: {
+    module: undefined,
+    entryPoint: 'main'
+  },
+  fragment: {
+    module: undefined,
+    entryPoint: 'main',
+    targets: []
+  },
+  layout: 'auto'
+};
+export function applyParametersToRenderPipelineDescriptor(pipelineDescriptor) {
+  let parameters = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
+  Object.assign(pipelineDescriptor, {
+    ...DEFAULT_PIPELINE_DESCRIPTOR,
+    ...pipelineDescriptor
+  });
+  setParameters(pipelineDescriptor, parameters);
+}
+function setParameters(pipelineDescriptor, parameters) {
+  for (const [key, value] of Object.entries(parameters)) {
+    const setterFunction = PARAMETER_TABLE[key];
+    if (!setterFunction) {
+      throw new Error("Illegal parameter ".concat(key));
+    }
+    setterFunction(key, value, pipelineDescriptor);
+  }
+}
+function addColorState(descriptor) {
+  var _descriptor$fragment, _descriptor$fragment2, _descriptor$fragment3, _descriptor$fragment4, _descriptor$fragment5;
+  descriptor.fragment.targets = ((_descriptor$fragment = descriptor.fragment) === null || _descriptor$fragment === void 0 ? void 0 : _descriptor$fragment.targets) || [];
+  if (!Array.isArray((_descriptor$fragment2 = descriptor.fragment) === null || _descriptor$fragment2 === void 0 ? void 0 : _descriptor$fragment2.targets)) {
+    throw new Error('colorstate');
+  }
+  if (((_descriptor$fragment3 = descriptor.fragment) === null || _descriptor$fragment3 === void 0 ? void 0 : (_descriptor$fragment4 = _descriptor$fragment3.targets) === null || _descriptor$fragment4 === void 0 ? void 0 : _descriptor$fragment4.length) === 0) {
+    var _descriptor$fragment$;
+    (_descriptor$fragment$ = descriptor.fragment.targets) === null || _descriptor$fragment$ === void 0 ? void 0 : _descriptor$fragment$.push({});
+  }
+  return (_descriptor$fragment5 = descriptor.fragment) === null || _descriptor$fragment5 === void 0 ? void 0 : _descriptor$fragment5.targets;
+}
+//# sourceMappingURL=webgpu-parameters.js.map