@luma.gl/webgpu 9.0.0-alpha.9 → 9.0.0-beta.10

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

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

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":";AAIA,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

@@ -1,8 +1,10 @@
+// luma.gl
+// SPDX-License-Identifier: MIT
+// Copyright (c) vis.gl contributors
+/** Ensure a texture format is WebGPU compatible */
 export function getWebGPUTextureFormat(format) {
-  if (format.includes('webgl')) {
-    throw new Error('webgl-only format');
-  }
-
-  return format;
+    if (format.includes('webgl')) {
+        throw new Error('webgl-only format');
+    }
+    return format;
 }
-//# sourceMappingURL=convert-texture-format.js.map

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 { ComputeShaderLayout, 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: ComputeShaderLayout, bindings: Record<string, Binding>): GPUBindGroup;
+export declare function getShaderLayoutBinding(shaderLayout: ComputeShaderLayout, 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":";AAIA,OAAO,KAAK,EAAC,mBAAmB,EAAE,kBAAkB,EAAE,OAAO,EAAC,MAAM,eAAe,CAAC;AAMpF;;;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,mBAAmB,EACjC,QAAQ,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAChC,YAAY,CAMd;AAED,wBAAgB,sBAAsB,CACpC,YAAY,EAAE,mBAAmB,EACjC,WAAW,EAAE,MAAM,GAClB,kBAAkB,CASpB"}

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

@@ -1,60 +1,69 @@
-import { Buffer, Sampler, Texture, log, cast } from '@luma.gl/api';
+// luma.gl
+// SPDX-License-Identifier: MIT
+// Copyright (c) vis.gl contributors
+import { Buffer, Sampler, Texture, log, cast } 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.
+ */
 export function makeBindGroupLayout(device, layout, bindings) {
-  throw new Error('not implemented');
+    throw new Error('not implemented');
+    // return device.createBindGroupLayout({
+    //   layout,
+    //   entries: getBindGroupEntries(bindings)
+    // })
 }
-export function getBindGroup(device, bindGroupLayout, layout, bindings) {
-  const entries = getBindGroupEntries(bindings, layout);
-  return device.createBindGroup({
-    layout: bindGroupLayout,
-    entries
-  });
+/**
+ * Create a WebGPU "bind group" from an array of luma.gl bindings
+ */
+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);
-
-  if (!bindingLayout) {
-    log.warn("Binding ".concat(bindingName, " not set: Not found in shader layout."))();
-  }
-
-  return bindingLayout;
+export function getShaderLayoutBinding(shaderLayout, bindingName) {
+    const bindingLayout = shaderLayout.bindings.find(binding => binding.name === bindingName || `${binding.name}uniforms` === bindingName.toLocaleLowerCase());
+    if (!bindingLayout) {
+        log.warn(`Binding ${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));
+/**
+ * @param bindings
+ * @returns
+ */
+function getBindGroupEntries(bindings, shaderLayout) {
+    const entries = [];
+    for (const [bindingName, value] of Object.entries(bindings)) {
+        const bindingLayout = getShaderLayoutBinding(shaderLayout, bindingName);
+        if (bindingLayout) {
+            entries.push(getBindGroupEntry(value, bindingLayout.location));
+        }
     }
-  }
-
-  return entries;
+    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');
+    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({ label: 'bind-group-auto-created' })
+        };
+    }
+    throw new Error('invalid binding');
 }
-//# sourceMappingURL=get-bind-group.js.map

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":";AAIA,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,CA4EzB;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,98 +1,131 @@
-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) {
-      const arrayStride = mapping.byteStride;
-
-      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
+// luma.gl
+// SPDX-License-Identifier: MIT
+// Copyright (c) vis.gl contributors
+import { log, decodeVertexFormat } from '@luma.gl/core';
+// import {getAttributeInfosFromLayouts} from '@luma.gl/core';
+/** Throw error on any WebGL-only vertex formats */
+function getWebGPUVertexFormat(format) {
+    if (format.endsWith('-webgl')) {
+        throw new Error(`WebGPU does not support vertex format ${format}`);
+    }
+    return format;
+}
+/**
+ * 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 bufferLayout The buffer map is optional
+ * @returns WebGPU layout intended for a GPURenderPassDescriptor.
+ */
+export function getVertexBufferLayout(shaderLayout, bufferLayout) {
+    const vertexBufferLayouts = [];
+    const usedAttributes = new Set();
+    // First handle any buffers mentioned in `bufferLayout`
+    for (const mapping of bufferLayout) {
+        // Build vertex attributes for one buffer
+        const vertexAttributes = [];
+        // TODO verify that all stepModes for one buffer are the same
+        let stepMode = 'vertex';
+        let byteStride = 0;
+        // interleaved mapping {..., attributes: [{...}, ...]}
+        if (mapping.attributes) {
+            // const arrayStride = mapping.byteStride; TODO
+            for (const attributeMapping of mapping.attributes) {
+                const attributeName = attributeMapping.attribute;
+                const attributeLayout = findAttributeLayout(shaderLayout, attributeName, usedAttributes);
+                stepMode =
+                    attributeLayout.stepMode ||
+                        (attributeLayout.name.startsWith('instance') ? 'instance' : 'vertex');
+                vertexAttributes.push({
+                    format: getWebGPUVertexFormat(attributeMapping.format || mapping.format),
+                    offset: attributeMapping.byteOffset,
+                    shaderLocation: attributeLayout.location
+                });
+                byteStride += decodeVertexFormat(mapping.format).byteLength;
+            }
+            // non-interleaved mapping (just set offset and stride)
+        }
+        else {
+            const attributeLayout = findAttributeLayout(shaderLayout, mapping.name, usedAttributes);
+            if (!attributeLayout) {
+                continue; // eslint-disable-line no-continue
+            }
+            byteStride = decodeVertexFormat(mapping.format).byteLength;
+            stepMode =
+                attributeLayout.stepMode ||
+                    (attributeLayout.name.startsWith('instance') ? 'instance' : 'vertex');
+            vertexAttributes.push({
+                format: getWebGPUVertexFormat(mapping.format),
+                // We only support 0 offset for non-interleaved buffer layouts
+                offset: 0,
+                shaderLocation: attributeLayout.location
+            });
+        }
+        // Store all the attribute bindings for one buffer
+        vertexBufferLayouts.push({
+            arrayStride: mapping.byteStride || byteStride,
+            stepMode,
+            attributes: vertexAttributes
         });
-        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
-        }]
-      });
+    // Add any non-mapped attributes - TODO - avoid hardcoded types
+    for (const attribute of shaderLayout.attributes) {
+        if (!usedAttributes.has(attribute.name)) {
+            vertexBufferLayouts.push({
+                arrayStride: decodeVertexFormat('float32x3').byteLength,
+                stepMode: attribute.stepMode || (attribute.name.startsWith('instance') ? 'instance' : 'vertex'),
+                attributes: [
+                    {
+                        format: getWebGPUVertexFormat('float32x3'),
+                        offset: 0,
+                        shaderLocation: attribute.location
+                    }
+                ]
+            });
+        }
     }
-  }
-
-  return vertexBufferLayouts;
+    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);
+export function getBufferSlots(shaderLayout, bufferLayout) {
+    const usedAttributes = new Set();
+    let bufferSlot = 0;
+    const bufferSlots = {};
+    // First handle any buffers mentioned in `bufferLayout`
+    for (const mapping of bufferLayout) {
+        // interleaved mapping {..., attributes: [{...}, ...]}
+        if ('attributes' in mapping) {
+            for (const interleaved of mapping.attributes) {
+                usedAttributes.add(interleaved.attribute);
+            }
+            // non-interleaved mapping (just set offset and stride)
+        }
+        else {
+            usedAttributes.add(mapping.name);
+        }
+        bufferSlots[mapping.name] = bufferSlot++;
     }
-
-    bufferSlots[mapping.name] = bufferSlot++;
-  }
-
-  for (const attribute of layout.attributes) {
-    if (!usedAttributes.has(attribute.name)) {
-      bufferSlots[attribute.name] = bufferSlot++;
+    // Add any non-mapped attributes
+    for (const attribute of shaderLayout.attributes) {
+        if (!usedAttributes.has(attribute.name)) {
+            bufferSlots[attribute.name] = bufferSlot++;
+        }
     }
-  }
-
-  return bufferSlots;
+    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;
+/**
+ * Looks up an attribute in the ShaderLayout.
+ * @throws if name is not in ShaderLayout
+ * @throws if name has already been referenced
+ */
+function findAttributeLayout(shaderLayout, name, attributeNames) {
+    const attribute = shaderLayout.attributes.find(attribute => attribute.name === name);
+    if (!attribute) {
+        log.warn(`Unknown attribute ${name}`)();
+        return null;
+    }
+    if (attributeNames.has(name)) {
+        throw new Error(`Duplicate attribute ${name}`);
+    }
+    attributeNames.add(name);
+    return attribute;
 }
-//# sourceMappingURL=get-vertex-buffer-layout.js.map

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":";AAIA,OAAO,EAAC,UAAU,EAAC,MAAM,eAAe,CAAC;AAezC;;;GAGG;AAEH,eAAO,MAAM,eAAe,EAAE,MAAM,CAAC,MAAM,UAAU,EAAE,QAAQ,CAkN9D,CAAC;AAgCF,wBAAgB,yCAAyC,CACvD,kBAAkB,EAAE,2BAA2B,EAC/C,UAAU,GAAE,UAAe,GAC1B,IAAI,CAIN"}