@luma.gl/webgpu 9.0.0-alpha.30 → 9.0.0-alpha.32

package/dist/index.cjs

@@ -622,24 +622,24 @@ function addColorState(descriptor) {
 
 // src/adapter/helpers/get-bind-group.ts
 var import_core6 = require("@luma.gl/core");
-function getBindGroup(device, bindGroupLayout, layout, bindings) {
-  const entries = getBindGroupEntries(bindings, layout);
+function getBindGroup(device, bindGroupLayout, shaderLayout, bindings) {
+  const entries = getBindGroupEntries(bindings, shaderLayout);
   return device.createBindGroup({
     layout: bindGroupLayout,
     entries
   });
 }
-function getShaderLayoutBinding(layout, bindingName) {
-  const bindingLayout = layout.bindings.find((binding) => binding.name === bindingName);
+function getShaderLayoutBinding(shaderLayout, bindingName) {
+  const bindingLayout = shaderLayout.bindings.find((binding) => binding.name === bindingName);
   if (!bindingLayout) {
     import_core6.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));
     }
@@ -677,31 +677,31 @@ function getWebGPUVertexFormat(format) {
   }
   return format;
 }
-function getVertexBufferLayout(layout, bufferMap) {
+function getVertexBufferLayout(shaderLayout, bufferLayout) {
   const vertexBufferLayouts = [];
   const usedAttributes = /* @__PURE__ */ new Set();
-  for (const mapping of bufferMap) {
+  for (const mapping of bufferLayout) {
     const vertexAttributes = [];
     let stepMode = "vertex";
     let byteStride = 0;
     const byteOffset = mapping.byteOffset || 0;
-    if ("attributes" in mapping) {
+    if (mapping.attributes) {
       for (const interleaved of mapping.attributes) {
-        const attributeLayout = findAttributeLayout(layout, interleaved.name, usedAttributes);
+        const attributeLayout = findAttributeLayout(shaderLayout, interleaved.name, usedAttributes);
         stepMode = attributeLayout.stepMode || "vertex";
         vertexAttributes.push({
-          format: getWebGPUVertexFormat(attributeLayout.format),
+          format: getWebGPUVertexFormat(interleaved.format || mapping.format),
           offset: byteOffset + byteStride,
           shaderLocation: attributeLayout.location
         });
-        byteStride += (0, import_core7.decodeVertexFormat)(attributeLayout.format).byteLength;
+        byteStride += (0, import_core7.decodeVertexFormat)(mapping.format).byteLength;
       }
     } else {
-      const attributeLayout = findAttributeLayout(layout, mapping.name, usedAttributes);
-      byteStride = (0, import_core7.decodeVertexFormat)(attributeLayout.format).byteLength;
+      const attributeLayout = findAttributeLayout(shaderLayout, mapping.name, usedAttributes);
+      byteStride = (0, import_core7.decodeVertexFormat)(mapping.format).byteLength;
       stepMode = attributeLayout.stepMode || "vertex";
       vertexAttributes.push({
-        format: getWebGPUVertexFormat(attributeLayout.format),
+        format: getWebGPUVertexFormat(mapping.format),
         offset: byteOffset,
         shaderLocation: attributeLayout.location
       });
@@ -712,26 +712,28 @@ function getVertexBufferLayout(layout, bufferMap) {
       attributes: vertexAttributes
     });
   }
-  for (const attribute of layout.attributes) {
+  for (const attribute of shaderLayout.attributes) {
     if (!usedAttributes.has(attribute.name)) {
       vertexBufferLayouts.push({
-        arrayStride: (0, import_core7.decodeVertexFormat)(attribute.format).byteLength,
+        arrayStride: (0, import_core7.decodeVertexFormat)("float32x3").byteLength,
         stepMode: attribute.stepMode || "vertex",
-        attributes: [{
-          format: getWebGPUVertexFormat(attribute.format),
-          offset: 0,
-          shaderLocation: attribute.location
-        }]
+        attributes: [
+          {
+            format: getWebGPUVertexFormat("float32x3"),
+            offset: 0,
+            shaderLocation: attribute.location
+          }
+        ]
       });
     }
   }
   return vertexBufferLayouts;
 }
-function getBufferSlots(layout, bufferMap) {
+function getBufferSlots(shaderLayout, bufferLayout) {
   const usedAttributes = /* @__PURE__ */ 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);
@@ -741,15 +743,15 @@ function getBufferSlots(layout, bufferMap) {
     }
     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((attribute2) => attribute2.name === name);
+function findAttributeLayout(shaderLayout, name, attributeNames) {
+  const attribute = shaderLayout.attributes.find((attribute2) => attribute2.name === name);
   if (!attribute) {
     throw new Error(`Unknown attribute ${name}`);
   }
@@ -772,7 +774,7 @@ var WebGPURenderPipeline = class extends import_core8.RenderPipeline {
     this.handle.label = this.props.id;
     this.vs = (0, import_core8.cast)(props.vs);
     this.fs = (0, import_core8.cast)(props.fs);
-    this._bufferSlots = getBufferSlots(this.props.layout, this.props.bufferMap);
+    this._bufferSlots = getBufferSlots(this.props.shaderLayout, this.props.bufferLayout);
     this._buffers = new Array(Object.keys(this._bufferSlots).length).fill(null);
     this._bindGroupLayout = this.handle.getBindGroupLayout(0);
   }
@@ -801,18 +803,16 @@ var WebGPURenderPipeline = class extends import_core8.RenderPipeline {
       }
     }
   }
-  /** Constant attributes are not available in WebGPU */
   setConstantAttributes(attributes) {
-    console.error("not implemented");
+    throw new Error("not implemented");
   }
-  /** Set the bindings */
   setBindings(bindings) {
     if (!(0, import_core8.isObjectEmpty)(this.props.bindings)) {
       Object.assign(this.props.bindings, bindings);
       this._bindGroup = getBindGroup(
         this.device.handle,
         this._bindGroupLayout,
-        this.props.layout,
+        this.props.shaderLayout,
         this.props.bindings
       );
     }
@@ -835,7 +835,7 @@ var WebGPURenderPipeline = class extends import_core8.RenderPipeline {
     const vertex = {
       module: (0, import_core8.cast)(this.props.vs).handle,
       entryPoint: this.props.vsEntryPoint || "main",
-      buffers: getVertexBufferLayout(this.props.layout, this.props.bufferMap)
+      buffers: getVertexBufferLayout(this.props.shaderLayout, this.props.bufferLayout)
     };
     let fragment;
     if (this.props.fs) {
@@ -900,7 +900,7 @@ var WebGPURenderPipeline = class extends import_core8.RenderPipeline {
     for (let i = 0; i < buffers.length; ++i) {
       const buffer = (0, import_core8.cast)(buffers[i]);
       if (!buffer) {
-        const attribute = this.props.layout.attributes.find(
+        const attribute = this.props.shaderLayout.attributes.find(
           (attribute2) => attribute2.location === i
         );
         throw new Error(