@luma.gl/webgpu 9.0.0-alpha.8 → 9.0.0-beta.1

package/LICENSE

@@ -1,4 +1,6 @@
-Copyright (c) 2020 Urban Computing Foundation
+luma.gl is provided under the MIT license
+
+Copyright (c) 2020 vis.gl contributors
 
 This software includes parts initially developed by Uber and open sourced under MIT license.
 Copyright (c) 2015 Uber Technologies, Inc.

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

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

package/dist/adapter/helpers/convert-texture-format.d.ts

@@ -1,5 +1,5 @@
-/// <reference types="@webgpu/types" />
-import { TextureFormat } from '@luma.gl/api';
+/// <reference types="dist" />
+import { TextureFormat } from '@luma.gl/core';
 /** Ensure a texture format is WebGPU compatible */
 export declare function getWebGPUTextureFormat(format: TextureFormat): GPUTextureFormat;
 //# sourceMappingURL=convert-texture-format.d.ts.map

package/dist/adapter/helpers/convert-texture-format.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"convert-texture-format.d.ts","sourceRoot":"","sources":["../../../src/adapter/helpers/convert-texture-format.ts"],"names":[],"mappings":";AACA,OAAO,EAAC,aAAa,EAAC,MAAM,cAAc,CAAC;AAE3C,mDAAmD;AACnD,wBAAgB,sBAAsB,CAAC,MAAM,EAAE,aAAa,GAAG,gBAAgB,CAK9E"}
+{"version":3,"file":"convert-texture-format.d.ts","sourceRoot":"","sources":["../../../src/adapter/helpers/convert-texture-format.ts"],"names":[],"mappings":";AACA,OAAO,EAAC,aAAa,EAAC,MAAM,eAAe,CAAC;AAE5C,mDAAmD;AACnD,wBAAgB,sBAAsB,CAAC,MAAM,EAAE,aAAa,GAAG,gBAAgB,CAK9E"}

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

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

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

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

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

@@ -1,4 +1,4 @@
-/// <reference types="@webgpu/types" />
+/// <reference types="dist" />
 /** WebGPU does not have built-in mipmap creation */
 export declare class WebGPUMipmapGenerator {
     device: GPUDevice;

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

@@ -1,14 +1,23 @@
-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}";
+const VS_GEN_MIPMAP = `\#version 450
+const vec2 pos[4] = vec2[4](vec2(-1.0f, 1.0f), vec2(1.0f, 1.0f), vec2(-1.0f, -1.0f), vec2(1.0f, -1.0f));
+layout(location = 0) out vec2 vTex;
+void main() {
+  gl_Position = vec4(pos[gl_VertexIndex], 0.0, 1.0);
+  vTex = gl_Position / 2.0f + vec2(0.5f);
+}`;
+const FS_GEN_MIPMAP = `#version 450
+layout(set = 0, binding = 0) uniform sampler imgSampler;
+layout(set = 0, binding = 1) uniform texture2D img;
+layout(location = 0) in vec2 vTex;
+layout(location = 0) out vec4 outColor;
+void main() {
+  outColor = texture(sampler2D(img, imgSampler), vTex);
+}`;
 export class WebGPUMipmapGenerator {
   constructor(device, glslang) {
-    _defineProperty(this, "device", void 0);
-
-    _defineProperty(this, "mipmapSampler", void 0);
-
-    _defineProperty(this, "mipmapPipeline", void 0);
-
+    this.device = void 0;
+    this.mipmapSampler = void 0;
+    this.mipmapPipeline = void 0;
     this.device = device;
     this.mipmapSampler = device.createSampler({
       minFilter: 'linear'
@@ -32,9 +41,8 @@ export class WebGPUMipmapGenerator {
       }]
     });
   }
-
   generateMipmappedTexture(imageBitmap) {
-    let textureSize = {
+    const textureSize = {
       width: imageBitmap.width,
       height: imageBitmap.height,
       depth: 1
@@ -49,10 +57,9 @@ export class WebGPUMipmapGenerator {
     this.device.queue.copyImageBitmapToTexture({
       imageBitmap
     }, {
-      texture: srcTexture
+      texture
     }, textureSize);
     const commandEncoder = this.device.createCommandEncoder({});
-
     for (let i = 1; i < mipLevelCount; ++i) {
       const passEncoder = commandEncoder.beginRenderPass({
         colorAttachments: [{
@@ -86,10 +93,8 @@ export class WebGPUMipmapGenerator {
       passEncoder.draw(4);
       passEncoder.endPass();
     }
-
     this.device.queue.submit([commandEncoder.finish()]);
     return texture;
   }
-
 }
 //# sourceMappingURL=generate-mipmaps.js.map

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

@@ -1 +1 @@
-{"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"}
+{"version":3,"file":"generate-mipmaps.js","names":["VS_GEN_MIPMAP","FS_GEN_MIPMAP","WebGPUMipmapGenerator","constructor","device","glslang","mipmapSampler","mipmapPipeline","createSampler","minFilter","createRenderPipeline","vertexStage","module","createShaderModule","code","compileGLSL","entryPoint","fragmentStage","primitiveTopology","colorStates","format","generateMipmappedTexture","imageBitmap","textureSize","width","height","depth","mipLevelCount","Math","floor","log2","max","texture","createTexture","size","usage","GPUTextureUsage","COPY_DST","SAMPLED","OUTPUT_ATTACHMENT","queue","copyImageBitmapToTexture","commandEncoder","createCommandEncoder","i","passEncoder","beginRenderPass","colorAttachments","attachment","createView","baseMipLevel","loadValue","r","g","b","a","bindGroup","createBindGroup","layout","getBindGroupLayout","bindings","binding","resource","setPipeline","setBindGroup","draw","endPass","submit","finish"],"sources":["../../../src/adapter/helpers/generate-mipmaps.ts"],"sourcesContent":["// luma.gl, MIT license\n// Forked from Kangz/mipmapper.js under MIT license Copyright 2020 Brandon Jones\n// https://gist.github.com/Kangz/782d5f1ae502daf53910a13f55db2f83\n\n// @ts-nocheck this is written against outdated WebGPU API, needs an update pass\n\nconst VS_GEN_MIPMAP = `\\#version 450\nconst vec2 pos[4] = vec2[4](vec2(-1.0f, 1.0f), vec2(1.0f, 1.0f), vec2(-1.0f, -1.0f), vec2(1.0f, -1.0f));\nlayout(location = 0) out vec2 vTex;\nvoid main() {\n  gl_Position = vec4(pos[gl_VertexIndex], 0.0, 1.0);\n  vTex = gl_Position / 2.0f + vec2(0.5f);\n}`;\n\nconst FS_GEN_MIPMAP = `#version 450\nlayout(set = 0, binding = 0) uniform sampler imgSampler;\nlayout(set = 0, binding = 1) uniform texture2D img;\nlayout(location = 0) in vec2 vTex;\nlayout(location = 0) out vec4 outColor;\nvoid main() {\n  outColor = texture(sampler2D(img, imgSampler), vTex);\n}`;\n\n/** WebGPU does not have built-in mipmap creation */\nexport class WebGPUMipmapGenerator {\n  device: GPUDevice;\n  mipmapSampler: GPUSampler;\n  mipmapPipeline: GPURenderPipeline;\n\n  constructor(device: GPUDevice, glslang) {\n    this.device = device;\n\n    this.mipmapSampler = device.createSampler({ minFilter: 'linear' });\n\n    this.mipmapPipeline = device.createRenderPipeline({\n      vertexStage: {\n        module: device.createShaderModule({\n          code: glslang.compileGLSL(VS_GEN_MIPMAP, 'vertex')\n        }),\n        entryPoint: 'main'\n      },\n      fragmentStage: {\n        module: device.createShaderModule({\n          code: glslang.compileGLSL(FS_GEN_MIPMAP, 'fragment')\n        }),\n        entryPoint: 'main'\n      },\n      primitiveTopology: 'triangle-strip',\n      colorStates: [{\n        format: 'rgba8unorm',\n      }]\n    });\n  }\n\n  generateMipmappedTexture(imageBitmap: ImageBitmap) {\n    const textureSize = {\n      width: imageBitmap.width,\n      height: imageBitmap.height,\n      depth: 1,\n    }\n    const mipLevelCount = Math.floor(Math.log2(Math.max(imageBitmap.width, imageBitmap.height))) + 1;\n\n    // Populate the top level of the srcTexture with the imageBitmap.\n    const texture = this.device.createTexture({\n      size: textureSize,\n      format: 'rgba8unorm',\n      usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.SAMPLED | GPUTextureUsage.OUTPUT_ATTACHMENT,\n      mipLevelCount\n    });\n    this.device.queue.copyImageBitmapToTexture({ imageBitmap }, { texture }, textureSize);\n\n    const commandEncoder = this.device.createCommandEncoder({});\n    for (let i = 1; i < mipLevelCount; ++i) {\n      const passEncoder = commandEncoder.beginRenderPass({\n        colorAttachments: [{\n          attachment: texture.createView({\n            baseMipLevel: i,\n            mipLevelCount: 1\n          }),\n          loadValue: { r: 1.0, g: 0.0, b: 0.0, a: 0.0 },\n        }],\n      });\n\n      const bindGroup = this.device.createBindGroup({\n        layout: this.mipmapPipeline.getBindGroupLayout(0),\n        bindings: [{\n          binding: 0,\n          resource: this.mipmapSampler,\n        }, {\n          binding: 1,\n          resource: texture.createView({\n            baseMipLevel: i - 1,\n            mipLevelCount: 1\n          }),\n        }],\n      });\n\n      passEncoder.setPipeline(this.mipmapPipeline);\n      passEncoder.setBindGroup(0, bindGroup);\n      passEncoder.draw(4);\n      passEncoder.endPass();\n    }\n\n    this.device.queue.submit([commandEncoder.finish()]);\n    return texture;\n  }\n}\n"],"mappings":"AAMA,MAAMA,aAAa,GAAI;AACvB;AACA;AACA;AACA;AACA;AACA,EAAE;AAEF,MAAMC,aAAa,GAAI;AACvB;AACA;AACA;AACA;AACA;AACA;AACA,EAAE;AAGF,OAAO,MAAMC,qBAAqB,CAAC;EAKjCC,WAAWA,CAACC,MAAiB,EAAEC,OAAO,EAAE;IAAA,KAJxCD,MAAM;IAAA,KACNE,aAAa;IAAA,KACbC,cAAc;IAGZ,IAAI,CAACH,MAAM,GAAGA,MAAM;IAEpB,IAAI,CAACE,aAAa,GAAGF,MAAM,CAACI,aAAa,CAAC;MAAEC,SAAS,EAAE;IAAS,CAAC,CAAC;IAElE,IAAI,CAACF,cAAc,GAAGH,MAAM,CAACM,oBAAoB,CAAC;MAChDC,WAAW,EAAE;QACXC,MAAM,EAAER,MAAM,CAACS,kBAAkB,CAAC;UAChCC,IAAI,EAAET,OAAO,CAACU,WAAW,CAACf,aAAa,EAAE,QAAQ;QACnD,CAAC,CAAC;QACFgB,UAAU,EAAE;MACd,CAAC;MACDC,aAAa,EAAE;QACbL,MAAM,EAAER,MAAM,CAACS,kBAAkB,CAAC;UAChCC,IAAI,EAAET,OAAO,CAACU,WAAW,CAACd,aAAa,EAAE,UAAU;QACrD,CAAC,CAAC;QACFe,UAAU,EAAE;MACd,CAAC;MACDE,iBAAiB,EAAE,gBAAgB;MACnCC,WAAW,EAAE,CAAC;QACZC,MAAM,EAAE;MACV,CAAC;IACH,CAAC,CAAC;EACJ;EAEAC,wBAAwBA,CAACC,WAAwB,EAAE;IACjD,MAAMC,WAAW,GAAG;MAClBC,KAAK,EAAEF,WAAW,CAACE,KAAK;MACxBC,MAAM,EAAEH,WAAW,CAACG,MAAM;MAC1BC,KAAK,EAAE;IACT,CAAC;IACD,MAAMC,aAAa,GAAGC,IAAI,CAACC,KAAK,CAACD,IAAI,CAACE,IAAI,CAACF,IAAI,CAACG,GAAG,CAACT,WAAW,CAACE,KAAK,EAAEF,WAAW,CAACG,MAAM,CAAC,CAAC,CAAC,GAAG,CAAC;IAGhG,MAAMO,OAAO,GAAG,IAAI,CAAC5B,MAAM,CAAC6B,aAAa,CAAC;MACxCC,IAAI,EAAEX,WAAW;MACjBH,MAAM,EAAE,YAAY;MACpBe,KAAK,EAAEC,eAAe,CAACC,QAAQ,GAAGD,eAAe,CAACE,OAAO,GAAGF,eAAe,CAACG,iBAAiB;MAC7FZ;IACF,CAAC,CAAC;IACF,IAAI,CAACvB,MAAM,CAACoC,KAAK,CAACC,wBAAwB,CAAC;MAAEnB;IAAY,CAAC,EAAE;MAAEU;IAAQ,CAAC,EAAET,WAAW,CAAC;IAErF,MAAMmB,cAAc,GAAG,IAAI,CAACtC,MAAM,CAACuC,oBAAoB,CAAC,CAAC,CAAC,CAAC;IAC3D,KAAK,IAAIC,CAAC,GAAG,CAAC,EAAEA,CAAC,GAAGjB,aAAa,EAAE,EAAEiB,CAAC,EAAE;MACtC,MAAMC,WAAW,GAAGH,cAAc,CAACI,eAAe,CAAC;QACjDC,gBAAgB,EAAE,CAAC;UACjBC,UAAU,EAAEhB,OAAO,CAACiB,UAAU,CAAC;YAC7BC,YAAY,EAAEN,CAAC;YACfjB,aAAa,EAAE;UACjB,CAAC,CAAC;UACFwB,SAAS,EAAE;YAAEC,CAAC,EAAE,GAAG;YAAEC,CAAC,EAAE,GAAG;YAAEC,CAAC,EAAE,GAAG;YAAEC,CAAC,EAAE;UAAI;QAC9C,CAAC;MACH,CAAC,CAAC;MAEF,MAAMC,SAAS,GAAG,IAAI,CAACpD,MAAM,CAACqD,eAAe,CAAC;QAC5CC,MAAM,EAAE,IAAI,CAACnD,cAAc,CAACoD,kBAAkB,CAAC,CAAC,CAAC;QACjDC,QAAQ,EAAE,CAAC;UACTC,OAAO,EAAE,CAAC;UACVC,QAAQ,EAAE,IAAI,CAACxD;QACjB,CAAC,EAAE;UACDuD,OAAO,EAAE,CAAC;UACVC,QAAQ,EAAE9B,OAAO,CAACiB,UAAU,CAAC;YAC3BC,YAAY,EAAEN,CAAC,GAAG,CAAC;YACnBjB,aAAa,EAAE;UACjB,CAAC;QACH,CAAC;MACH,CAAC,CAAC;MAEFkB,WAAW,CAACkB,WAAW,CAAC,IAAI,CAACxD,cAAc,CAAC;MAC5CsC,WAAW,CAACmB,YAAY,CAAC,CAAC,EAAER,SAAS,CAAC;MACtCX,WAAW,CAACoB,IAAI,CAAC,CAAC,CAAC;MACnBpB,WAAW,CAACqB,OAAO,CAAC,CAAC;IACvB;IAEA,IAAI,CAAC9D,MAAM,CAACoC,KAAK,CAAC2B,MAAM,CAAC,CAACzB,cAAc,CAAC0B,MAAM,CAAC,CAAC,CAAC,CAAC;IACnD,OAAOpC,OAAO;EAChB;AACF"}

package/dist/adapter/helpers/get-bind-group.d.ts

@@ -1,5 +1,5 @@
-/// <reference types="@webgpu/types" />
-import type { ShaderLayout, BindingLayout, Binding } from '@luma.gl/api';
+/// <reference types="dist" />
+import type { ShaderLayout, BindingDeclaration, Binding } from '@luma.gl/core';
 /**
  * Create a WebGPU "bind group layout" from an array of luma.gl bindings
  * @note bind groups can be automatically generated by WebGPU.
@@ -8,6 +8,6 @@ export declare function makeBindGroupLayout(device: GPUDevice, layout: GPUBindGr
 /**
  * Create a WebGPU "bind group" from an array of luma.gl bindings
  */
-export declare function getBindGroup(device: GPUDevice, bindGroupLayout: GPUBindGroupLayout, layout: ShaderLayout, bindings: Record<string, Binding>): GPUBindGroup;
-export declare function getShaderLayoutBinding(layout: ShaderLayout, bindingName: string): BindingLayout;
+export declare function getBindGroup(device: GPUDevice, bindGroupLayout: GPUBindGroupLayout, shaderLayout: ShaderLayout, bindings: Record<string, Binding>): GPUBindGroup;
+export declare function getShaderLayoutBinding(shaderLayout: ShaderLayout, bindingName: string): BindingDeclaration;
 //# sourceMappingURL=get-bind-group.d.ts.map

package/dist/adapter/helpers/get-bind-group.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"get-bind-group.d.ts","sourceRoot":"","sources":["../../../src/adapter/helpers/get-bind-group.ts"],"names":[],"mappings":";AACA,OAAO,KAAK,EAAC,YAAY,EAAE,aAAa,EAAE,OAAO,EAAC,MAAM,cAAc,CAAC;AAMvE;;;GAGG;AACF,wBAAgB,mBAAmB,CAAC,MAAM,EAAE,SAAS,EAAE,MAAM,EAAE,kBAAkB,EAAE,QAAQ,EAAE,OAAO,EAAE,GAAG,kBAAkB,CAM3H;AAED;;GAEG;AACH,wBAAgB,YAAY,CAC1B,MAAM,EAAE,SAAS,EACjB,eAAe,EAAE,kBAAkB,EACnC,MAAM,EAAE,YAAY,EACpB,QAAQ,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAChC,YAAY,CAMd;AAED,wBAAgB,sBAAsB,CAAC,MAAM,EAAE,YAAY,EAAE,WAAW,EAAE,MAAM,GAAG,aAAa,CAM/F"}
+{"version":3,"file":"get-bind-group.d.ts","sourceRoot":"","sources":["../../../src/adapter/helpers/get-bind-group.ts"],"names":[],"mappings":";AACA,OAAO,KAAK,EAAC,YAAY,EAAE,kBAAkB,EAAE,OAAO,EAAC,MAAM,eAAe,CAAC;AAM7E;;;GAGG;AACH,wBAAgB,mBAAmB,CACjC,MAAM,EAAE,SAAS,EACjB,MAAM,EAAE,kBAAkB,EAC1B,QAAQ,EAAE,OAAO,EAAE,GAClB,kBAAkB,CAMpB;AAED;;GAEG;AACH,wBAAgB,YAAY,CAC1B,MAAM,EAAE,SAAS,EACjB,eAAe,EAAE,kBAAkB,EACnC,YAAY,EAAE,YAAY,EAC1B,QAAQ,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAChC,YAAY,CAMd;AAED,wBAAgB,sBAAsB,CACpC,YAAY,EAAE,YAAY,EAC1B,WAAW,EAAE,MAAM,GAClB,kBAAkB,CAMpB"}

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

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

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

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

package/dist/adapter/helpers/get-vertex-buffer-layout.d.ts

@@ -1,12 +1,12 @@
-/// <reference types="@webgpu/types" />
-import type { ShaderLayout, BufferMapping } from '@luma.gl/api';
+/// <reference types="dist" />
+import type { ShaderLayout, BufferLayout } from '@luma.gl/core';
 /**
  * Build a WebGPU vertex buffer layout intended for use in a GPURenderPassDescriptor.
  * Converts luma.gl attribute definitions to a WebGPU GPUVertexBufferLayout[] array
  * @param layout
- * @param bufferMap The buffer map is optional
+ * @param bufferLayout The buffer map is optional
  * @returns WebGPU layout intended for a GPURenderPassDescriptor.
  */
-export declare function getVertexBufferLayout(layout: ShaderLayout, bufferMap: BufferMapping[]): GPUVertexBufferLayout[];
-export declare function getBufferSlots(layout: ShaderLayout, bufferMap: BufferMapping[]): Record<string, number>;
+export declare function getVertexBufferLayout(shaderLayout: ShaderLayout, bufferLayout: BufferLayout[]): GPUVertexBufferLayout[];
+export declare function getBufferSlots(shaderLayout: ShaderLayout, bufferLayout: BufferLayout[]): Record<string, number>;
 //# sourceMappingURL=get-vertex-buffer-layout.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"get-vertex-buffer-layout.d.ts","sourceRoot":"","sources":["../../../src/adapter/helpers/get-vertex-buffer-layout.ts"],"names":[],"mappings":";AAAA,OAAO,KAAK,EAAC,YAAY,EAAE,aAAa,EAAkB,MAAM,cAAc,CAAC;AAG/E;;;;;;GAMG;AACH,wBAAgB,qBAAqB,CAAC,MAAM,EAAE,YAAY,EAAE,SAAS,EAAE,aAAa,EAAE,GAAG,qBAAqB,EAAE,CAkE/G;AAED,wBAAgB,cAAc,CAAC,MAAM,EAAE,YAAY,EAAE,SAAS,EAAE,aAAa,EAAE,GAAG,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CA2BvG"}
+{"version":3,"file":"get-vertex-buffer-layout.d.ts","sourceRoot":"","sources":["../../../src/adapter/helpers/get-vertex-buffer-layout.ts"],"names":[],"mappings":";AACA,OAAO,KAAK,EAAC,YAAY,EAAE,YAAY,EAAqC,MAAM,eAAe,CAAC;AAYlG;;;;;;GAMG;AACH,wBAAgB,qBAAqB,CACnC,YAAY,EAAE,YAAY,EAC1B,YAAY,EAAE,YAAY,EAAE,GAC3B,qBAAqB,EAAE,CAuEzB;AAED,wBAAgB,cAAc,CAC5B,YAAY,EAAE,YAAY,EAC1B,YAAY,EAAE,YAAY,EAAE,GAC3B,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CA2BxB"}

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

@@ -1,97 +1,93 @@
-import { decodeVertexFormat } from '@luma.gl/api';
-export function getVertexBufferLayout(layout, bufferMap) {
+import { log, decodeVertexFormat } from '@luma.gl/core';
+function getWebGPUVertexFormat(format) {
+  if (format.endsWith('-webgl')) {
+    throw new Error(`WebGPU does not support vertex format ${format}`);
+  }
+  return format;
+}
+export function getVertexBufferLayout(shaderLayout, bufferLayout) {
   const vertexBufferLayouts = [];
   const usedAttributes = new Set();
-
-  for (const mapping of bufferMap) {
+  for (const mapping of bufferLayout) {
     const vertexAttributes = [];
     let stepMode = 'vertex';
     let byteStride = 0;
-    let byteOffset = mapping.byteOffset || 0;
-
-    if ('attributes' in mapping) {
-      const arrayStride = mapping.byteStride;
-
-      for (const interleaved of mapping.attributes) {
-        const attributeLayout = findAttributeLayout(layout, interleaved.name, usedAttributes);
+    if (mapping.attributes) {
+      for (const attributeMapping of mapping.attributes) {
+        const attributeName = attributeMapping.attribute;
+        const attributeLayout = findAttributeLayout(shaderLayout, attributeName, usedAttributes);
         stepMode = attributeLayout.stepMode || 'vertex';
         vertexAttributes.push({
-          format: attributeLayout.format,
-          offset: byteOffset + byteStride,
+          format: getWebGPUVertexFormat(attributeMapping.format || mapping.format),
+          offset: attributeMapping.byteOffset,
           shaderLocation: attributeLayout.location
         });
-        byteStride += decodeVertexFormat(attributeLayout.format).byteLength;
+        byteStride += decodeVertexFormat(mapping.format).byteLength;
       }
     } else {
-      const attributeLayout = findAttributeLayout(layout, mapping.name, usedAttributes);
-      byteStride = decodeVertexFormat(attributeLayout.format).byteLength, stepMode = attributeLayout.stepMode || 'vertex';
+      const attributeLayout = findAttributeLayout(shaderLayout, mapping.name, usedAttributes);
+      if (!attributeLayout) {
+        continue;
+      }
+      byteStride = decodeVertexFormat(mapping.format).byteLength;
+      stepMode = attributeLayout.stepMode || 'vertex';
       vertexAttributes.push({
-        format: attributeLayout.format,
-        offset: byteOffset,
+        format: getWebGPUVertexFormat(mapping.format),
+        offset: 0,
         shaderLocation: attributeLayout.location
       });
     }
-
     vertexBufferLayouts.push({
       arrayStride: mapping.byteStride || byteStride,
       stepMode: stepMode || 'vertex',
       attributes: vertexAttributes
     });
   }
-
-  for (const attribute of layout.attributes) {
+  for (const attribute of shaderLayout.attributes) {
     if (!usedAttributes.has(attribute.name)) {
       vertexBufferLayouts.push({
-        arrayStride: decodeVertexFormat(attribute.format).byteLength,
+        arrayStride: decodeVertexFormat('float32x3').byteLength,
         stepMode: attribute.stepMode || 'vertex',
         attributes: [{
-          format: attribute.format,
+          format: getWebGPUVertexFormat('float32x3'),
           offset: 0,
           shaderLocation: attribute.location
         }]
       });
     }
   }
-
   return vertexBufferLayouts;
 }
-export function getBufferSlots(layout, bufferMap) {
+export function getBufferSlots(shaderLayout, bufferLayout) {
   const usedAttributes = new Set();
   let bufferSlot = 0;
   const bufferSlots = {};
-
-  for (const mapping of bufferMap) {
+  for (const mapping of bufferLayout) {
     if ('attributes' in mapping) {
       for (const interleaved of mapping.attributes) {
-        usedAttributes.add(interleaved.name);
+        usedAttributes.add(interleaved.attribute);
       }
     } else {
       usedAttributes.add(mapping.name);
     }
-
     bufferSlots[mapping.name] = bufferSlot++;
   }
-
-  for (const attribute of layout.attributes) {
+  for (const attribute of shaderLayout.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);
-
+function findAttributeLayout(shaderLayout, name, attributeNames) {
+  const attribute = shaderLayout.attributes.find(attribute => attribute.name === name);
   if (!attribute) {
-    throw new Error("Unknown attribute ".concat(name));
+    log.warn(`Unknown attribute ${name}`)();
+    return null;
   }
-
   if (attributeNames.has(name)) {
-    throw new Error("Duplicate attribute ".concat(name));
+    throw new Error(`Duplicate attribute ${name}`);
   }
-
   attributeNames.add(name);
   return attribute;
 }

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

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

package/dist/adapter/helpers/webgpu-parameters.d.ts

@@ -1,5 +1,5 @@
-/// <reference types="@webgpu/types" />
-import { Parameters } from '@luma.gl/api';
+/// <reference types="dist" />
+import { Parameters } from '@luma.gl/core';
 /**
  * Supports for luma.gl's flat parameter space
  * Populates the corresponding sub-objects in a GPURenderPipelineDescriptor

package/dist/adapter/helpers/webgpu-parameters.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"webgpu-parameters.d.ts","sourceRoot":"","sources":["../../../src/adapter/helpers/webgpu-parameters.ts"],"names":[],"mappings":";AAAA,OAAO,EAAC,UAAU,EAAC,MAAM,cAAc,CAAC;AAYxC;;;GAGG;AAEH,eAAO,MAAM,eAAe,EAAE,MAAM,CAAC,MAAM,UAAU,EAAE,QAAQ,CAqJ9D,CAAC;AA8BF,wBAAgB,yCAAyC,CACvD,kBAAkB,EAAE,2BAA2B,EAC/C,UAAU,GAAE,UAAe,GAC1B,IAAI,CAIN"}
+{"version":3,"file":"webgpu-parameters.d.ts","sourceRoot":"","sources":["../../../src/adapter/helpers/webgpu-parameters.ts"],"names":[],"mappings":";AAAA,OAAO,EAAC,UAAU,EAAC,MAAM,eAAe,CAAC;AAezC;;;GAGG;AAEH,eAAO,MAAM,eAAe,EAAE,MAAM,CAAC,MAAM,UAAU,EAAE,QAAQ,CAsJ9D,CAAC;AAgCF,wBAAgB,yCAAyC,CACvD,kBAAkB,EAAE,2BAA2B,EAC/C,UAAU,GAAE,UAAe,GAC1B,IAAI,CAIN"}

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

@@ -2,11 +2,12 @@ function addDepthStencil(descriptor) {
   descriptor.depthStencil = descriptor.depthStencil || {
     format: 'depth24plus',
     stencilFront: {},
-    stencilBack: {}
+    stencilBack: {},
+    depthWriteEnabled: false,
+    depthCompare: 'less-equal'
   };
   return descriptor.depthStencil;
 }
-
 export const PARAMETER_TABLE = {
   cullMode: (parameter, value, descriptor) => {
     descriptor.primitive = descriptor.primitive || {};
@@ -85,8 +86,7 @@ export const PARAMETER_TABLE = {
     targets[0].writeMask = value;
   },
   blendColorOperation: (parameter, value, descriptor) => {
-    const targets = addColorState(descriptor);
-    const target = targets[0];
+    addColorState(descriptor);
   }
 };
 const DEFAULT_PIPELINE_DESCRIPTOR = {
@@ -102,42 +102,36 @@ const DEFAULT_PIPELINE_DESCRIPTOR = {
     module: undefined,
     entryPoint: 'main',
     targets: []
-  }
+  },
+  layout: 'auto'
 };
-export function applyParametersToRenderPipelineDescriptor(pipelineDescriptor, parameters = {}) {
-  Object.assign(pipelineDescriptor, { ...DEFAULT_PIPELINE_DESCRIPTOR,
+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));
+      throw new Error(`Illegal parameter ${key}`);
     }
-
     setterFunction(key, value, pipelineDescriptor);
   }
 }
-
 function addColorState(descriptor) {
-  var _descriptor$fragment, _descriptor$fragment2, _descriptor$fragment3, _descriptor$fragment4, _descriptor$fragment5;
-
+  var _descriptor$fragment, _descriptor$fragment2, _descriptor$fragment3, _descriptor$fragment4;
   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) {
+  if (((_descriptor$fragment3 = descriptor.fragment) === null || _descriptor$fragment3 === void 0 || (_descriptor$fragment3 = _descriptor$fragment3.targets) === null || _descriptor$fragment3 === void 0 ? void 0 : _descriptor$fragment3.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;
+  return (_descriptor$fragment4 = descriptor.fragment) === null || _descriptor$fragment4 === void 0 ? void 0 : _descriptor$fragment4.targets;
 }
 //# sourceMappingURL=webgpu-parameters.js.map