@luma.gl/webgpu 9.0.0-alpha.33 → 9.0.0-alpha.35

package/dist/dist.dev.js

@@ -11,8 +11,8 @@ var __exports__ = (() => {
   var __hasOwnProp = Object.prototype.hasOwnProperty;
   var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
   var __export = (target, all) => {
-    for (var name in all)
-      __defProp(target, name, { get: all[name], enumerable: true });
+    for (var name2 in all)
+      __defProp(target, name2, { get: all[name2], enumerable: true });
   };
   var __copyProps = (to, from, except, desc) => {
     if (from && typeof from === "object" || typeof from === "function") {
@@ -198,7 +198,7 @@ var __exports__ = (() => {
     for (const key of propNames) {
       const value = object[key];
       if (typeof value === "function") {
-        if (!predefined.find((name) => key === name)) {
+        if (!predefined.find((name2) => key === name2)) {
           object[key] = value.bind(obj);
         }
       }
@@ -587,7 +587,7 @@ var __exports__ = (() => {
 
   // ../../node_modules/@probe.gl/stats/dist/lib/stat.js
   var Stat = class {
-    constructor(name, type) {
+    constructor(name2, type) {
       this.name = void 0;
       this.type = void 0;
       this.sampleSize = 1;
@@ -602,7 +602,7 @@ var __exports__ = (() => {
       this._samples = 0;
       this._startTime = 0;
       this._timerPending = false;
-      this.name = name;
+      this.name = name2;
       this.type = type;
       this.reset();
     }
@@ -707,10 +707,10 @@ var __exports__ = (() => {
       this._initializeStats(options.stats);
       Object.seal(this);
     }
-    get(name) {
+    get(name2) {
       let type = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : "count";
       return this._getOrCreate({
-        name,
+        name: name2,
         type
       });
     }
@@ -746,17 +746,17 @@ var __exports__ = (() => {
     }
     _getOrCreate(stat) {
       const {
-        name,
+        name: name2,
         type
       } = stat;
-      let result = this.stats[name];
+      let result = this.stats[name2];
       if (!result) {
         if (stat instanceof Stat) {
           result = stat;
         } else {
-          result = new Stat(name, type);
+          result = new Stat(name2, type);
         }
-        this.stats[name] = result;
+        this.stats[name2] = result;
       }
       return result;
     }
@@ -765,16 +765,16 @@ var __exports__ = (() => {
   // ../core/src/lib/utils/stats-manager.ts
   var StatsManager = class {
     stats = /* @__PURE__ */ new Map();
-    getStats(name) {
-      return this.get(name);
+    getStats(name2) {
+      return this.get(name2);
     }
-    get(name) {
-      if (!this.stats.has(name)) {
-        this.stats.set(name, new Stats({
-          id: name
+    get(name2) {
+      if (!this.stats.has(name2)) {
+        this.stats.set(name2, new Stats({
+          id: name2
         }));
       }
-      return this.stats.get(name);
+      return this.stats.get(name2);
     }
   };
   var lumaStats = new StatsManager();
@@ -904,30 +904,30 @@ var __exports__ = (() => {
     /** Called by .destroy() to track object destruction. Subclass must call if overriding destroy() */
     removeStats() {
       const stats = this._device.statsManager.getStats("Resource Counts");
-      const name = this[Symbol.toStringTag];
-      stats.get(`${name}s Active`).decrementCount();
+      const name2 = this[Symbol.toStringTag];
+      stats.get(`${name2}s Active`).decrementCount();
     }
     /** Called by subclass to track memory allocations */
-    trackAllocatedMemory(bytes, name = this[Symbol.toStringTag]) {
+    trackAllocatedMemory(bytes, name2 = this[Symbol.toStringTag]) {
       const stats = this._device.statsManager.getStats("Resource Counts");
       stats.get("GPU Memory").addCount(bytes);
-      stats.get(`${name} Memory`).addCount(bytes);
+      stats.get(`${name2} Memory`).addCount(bytes);
       this.allocatedBytes = bytes;
     }
     /** Called by subclass to track memory deallocations */
-    trackDeallocatedMemory(name = this[Symbol.toStringTag]) {
+    trackDeallocatedMemory(name2 = this[Symbol.toStringTag]) {
       const stats = this._device.statsManager.getStats("Resource Counts");
       stats.get("GPU Memory").subtractCount(this.allocatedBytes);
-      stats.get(`${name} Memory`).subtractCount(this.allocatedBytes);
+      stats.get(`${name2} Memory`).subtractCount(this.allocatedBytes);
       this.allocatedBytes = 0;
     }
     /** Called by resource constructor to track object creation */
     addStats() {
       const stats = this._device.statsManager.getStats("Resource Counts");
-      const name = this[Symbol.toStringTag];
+      const name2 = this[Symbol.toStringTag];
       stats.get("Resources Created").incrementCount();
-      stats.get(`${name}s Created`).incrementCount();
-      stats.get(`${name}s Active`).incrementCount();
+      stats.get(`${name2}s Created`).incrementCount();
+      stats.get(`${name2}s Active`).incrementCount();
     }
   };
   /** Default properties for resource */
@@ -1141,7 +1141,7 @@ var __exports__ = (() => {
     // Resource creation helpers
     _getBufferProps(props) {
       if (props instanceof ArrayBuffer || ArrayBuffer.isView(props)) {
-        return {
+        props = {
           data: props
         };
       }
@@ -1153,6 +1153,8 @@ var __exports__ = (() => {
           newProps.indexType = "uint32";
         } else if (props.data instanceof Uint16Array) {
           newProps.indexType = "uint16";
+        } else {
+          log.warn("indices buffer content must be of integer type")();
         }
       }
       return newProps;
@@ -1954,6 +1956,171 @@ var __exports__ = (() => {
     return result;
   }
 
+  // ../core/src/adapter/type-utils/decode-attribute-type.ts
+  function decodeShaderAttributeType(attributeType) {
+    const [dataType, components] = TYPE_INFO[attributeType];
+    const integer = dataType === "i32" || dataType === "u32";
+    const signed = dataType !== "u32";
+    const byteLength = TYPE_SIZES2[dataType] * components;
+    const defaultVertexFormat = getCompatibleVertexFormat(dataType, components);
+    return {
+      dataType,
+      components,
+      defaultVertexFormat,
+      byteLength,
+      integer,
+      signed
+    };
+  }
+  function getCompatibleVertexFormat(dataType, components) {
+    let vertexType;
+    switch (dataType) {
+      case "f32":
+        vertexType = "float32";
+        break;
+      case "i32":
+        vertexType = "sint32";
+        break;
+      case "u32":
+        vertexType = "uint32";
+        break;
+      case "f16":
+        return components <= 2 ? "float16x2" : "float16x4";
+    }
+    if (components === 1) {
+      return vertexType;
+    }
+    return `${vertexType}x${components}`;
+  }
+  var TYPE_INFO = {
+    f32: ["f32", 1],
+    "vec2<f32>": ["f32", 2],
+    "vec3<f32>": ["f32", 3],
+    "vec4<f32>": ["f32", 4],
+    f16: ["f16", 1],
+    "vec2<f16>": ["f16", 2],
+    "vec3<f16>": ["f16", 3],
+    "vec4<f16>": ["f16", 4],
+    i32: ["i32", 1],
+    "vec2<i32>": ["i32", 2],
+    "vec3<i32>": ["i32", 3],
+    "vec4<i32>": ["i32", 4],
+    u32: ["u32", 1],
+    "vec2<u32>": ["u32", 2],
+    "vec3<u32>": ["u32", 3],
+    "vec4<u32>": ["u32", 4]
+  };
+  var TYPE_SIZES2 = {
+    f32: 4,
+    f16: 2,
+    i32: 4,
+    u32: 4
+    // 'bool-webgl': 4,  
+  };
+
+  // ../core/src/adapter/attribute-utils/get-attribute-from-layouts.ts
+  function getAttributeInfosFromLayouts(shaderLayout, bufferLayout) {
+    const attributeInfos = {};
+    for (const attribute of shaderLayout.attributes) {
+      attributeInfos[attribute.name] = getAttributeInfoFromLayouts(shaderLayout, bufferLayout, attribute.name);
+    }
+    return attributeInfos;
+  }
+  function getAttributeInfoFromLayouts(shaderLayout, bufferLayout, name2) {
+    const shaderDeclaration = getAttributeFromShaderLayout(shaderLayout, name2);
+    const bufferMapping = getAttributeFromBufferLayout(bufferLayout, name2);
+    if (!shaderDeclaration) {
+      return null;
+    }
+    const attributeTypeInfo = decodeShaderAttributeType(shaderDeclaration.type);
+    const vertexFormat = bufferMapping?.vertexFormat || attributeTypeInfo.defaultVertexFormat;
+    const vertexFormatInfo = decodeVertexFormat(vertexFormat);
+    return {
+      attributeName: bufferMapping?.attributeName || shaderDeclaration.name,
+      bufferName: bufferMapping?.bufferName || shaderDeclaration.name,
+      location: shaderDeclaration.location,
+      shaderType: shaderDeclaration.type,
+      shaderDataType: attributeTypeInfo.dataType,
+      shaderComponents: attributeTypeInfo.components,
+      vertexFormat,
+      bufferDataType: vertexFormatInfo.type,
+      bufferComponents: vertexFormatInfo.components,
+      // normalized is a property of the buffer's vertex format
+      normalized: vertexFormatInfo.normalized,
+      // integer is a property of the shader declaration
+      integer: attributeTypeInfo.integer,
+      stepMode: bufferMapping?.stepMode || shaderDeclaration.stepMode,
+      byteOffset: bufferMapping?.byteOffset || 0,
+      byteStride: bufferMapping?.byteStride || 0
+    };
+  }
+  function getAttributeFromShaderLayout(shaderLayout, name2) {
+    const attribute = shaderLayout.attributes.find((attr) => attr.name === name2);
+    if (!attribute) {
+      log.warn(`shader layout attribute "${name2}" not present in shader`);
+    }
+    return attribute || null;
+  }
+  function getAttributeFromBufferLayout(bufferLayouts, name2) {
+    checkBufferLayouts(bufferLayouts);
+    let bufferLayoutInfo = getAttributeFromShortHand(bufferLayouts, name2);
+    if (bufferLayoutInfo) {
+      return bufferLayoutInfo;
+    }
+    bufferLayoutInfo = getAttributeFromAttributesList(bufferLayouts, name2);
+    if (bufferLayoutInfo) {
+      return bufferLayoutInfo;
+    }
+    log.warn(`layout for attribute "${name2}" not present in buffer layout`);
+    return null;
+  }
+  function checkBufferLayouts(bufferLayouts) {
+    for (const bufferLayout of bufferLayouts) {
+      if (bufferLayout.attributes && bufferLayout.format || !bufferLayout.attributes && !bufferLayout.format) {
+        log.warn(`BufferLayout ${name} must have either 'attributes' or 'format' field`);
+      }
+    }
+  }
+  function getAttributeFromShortHand(bufferLayouts, name2) {
+    for (const bufferLayout of bufferLayouts) {
+      if (bufferLayout.format && bufferLayout.name === name2) {
+        return {
+          attributeName: bufferLayout.name,
+          bufferName: name2,
+          stepMode: bufferLayout.stepMode,
+          vertexFormat: bufferLayout.format,
+          // If offset is needed, use `attributes` field.
+          byteOffset: 0,
+          byteStride: bufferLayout.byteStride || 0
+        };
+      }
+    }
+    return null;
+  }
+  function getAttributeFromAttributesList(bufferLayouts, name2) {
+    for (const bufferLayout of bufferLayouts) {
+      let byteStride = bufferLayout.byteStride;
+      if (typeof bufferLayout.byteStride !== "number") {
+        for (const attributeMapping2 of bufferLayout.attributes || []) {
+          const info = decodeVertexFormat(attributeMapping2.format);
+          byteStride += info.byteLength;
+        }
+      }
+      const attributeMapping = bufferLayout.attributes?.find((mapping) => mapping.attribute === name2);
+      if (attributeMapping) {
+        return {
+          attributeName: attributeMapping.attribute,
+          bufferName: bufferLayout.name,
+          stepMode: bufferLayout.stepMode,
+          vertexFormat: attributeMapping.format,
+          byteOffset: attributeMapping.byteOffset,
+          byteStride
+        };
+      }
+    }
+    return null;
+  }
+
   // ../core/src/lib/utils/cast.ts
   function cast(value) {
     return value;
@@ -2546,20 +2713,21 @@ var __exports__ = (() => {
     return format;
   }
   function getVertexBufferLayout(shaderLayout, bufferLayout) {
+    const attributeInfos = getAttributeInfosFromLayouts(shaderLayout, bufferLayout);
     const vertexBufferLayouts = [];
     const usedAttributes = /* @__PURE__ */ new Set();
     for (const mapping of bufferLayout) {
       const vertexAttributes = [];
       let stepMode = "vertex";
       let byteStride = 0;
-      const byteOffset = mapping.byteOffset || 0;
       if (mapping.attributes) {
-        for (const interleaved of mapping.attributes) {
-          const attributeLayout = findAttributeLayout(shaderLayout, interleaved.name, usedAttributes);
+        for (const attributeMapping of mapping.attributes) {
+          const attributeName = attributeMapping.attribute;
+          const attributeLayout = findAttributeLayout(shaderLayout, attributeName, usedAttributes);
           stepMode = attributeLayout.stepMode || "vertex";
           vertexAttributes.push({
-            format: getWebGPUVertexFormat(interleaved.format || mapping.format),
-            offset: byteOffset + byteStride,
+            format: getWebGPUVertexFormat(attributeMapping.format || mapping.format),
+            offset: attributeMapping.byteOffset,
             shaderLocation: attributeLayout.location
           });
           byteStride += decodeVertexFormat(mapping.format).byteLength;
@@ -2570,7 +2738,8 @@ var __exports__ = (() => {
         stepMode = attributeLayout.stepMode || "vertex";
         vertexAttributes.push({
           format: getWebGPUVertexFormat(mapping.format),
-          offset: byteOffset,
+          // We only support 0 offset for non-interleaved buffer layouts
+          offset: 0,
           shaderLocation: attributeLayout.location
         });
       }
@@ -2602,7 +2771,7 @@ var __exports__ = (() => {
     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);
@@ -2616,15 +2785,15 @@ var __exports__ = (() => {
     }
     return bufferSlots;
   }
-  function findAttributeLayout(shaderLayout, name, attributeNames) {
-    const attribute = shaderLayout.attributes.find((attribute2) => attribute2.name === name);
+  function findAttributeLayout(shaderLayout, name2, attributeNames) {
+    const attribute = shaderLayout.attributes.find((attribute2) => attribute2.name === name2);
     if (!attribute) {
-      throw new Error(`Unknown attribute ${name}`);
+      throw new Error(`Unknown attribute ${name2}`);
     }
-    if (attributeNames.has(name)) {
-      throw new Error(`Duplicate attribute ${name}`);
+    if (attributeNames.has(name2)) {
+      throw new Error(`Duplicate attribute ${name2}`);
     }
-    attributeNames.add(name);
+    attributeNames.add(name2);
     return attribute;
   }
 
@@ -2661,12 +2830,12 @@ var __exports__ = (() => {
       this._indexBuffer = cast(indexBuffer);
     }
     setAttributes(attributes) {
-      for (const [name, buffer] of Object.entries(attributes)) {
-        const bufferIndex = this._bufferSlots[name];
+      for (const [name2, buffer] of Object.entries(attributes)) {
+        const bufferIndex = this._bufferSlots[name2];
         if (bufferIndex >= 0) {
           this._buffers[bufferIndex] = buffer;
         } else {
-          throw new Error(`Setting attribute '${name}' not listed in shader layout for program ${this.id}`);
+          throw new Error(`Setting attribute '${name2}' not listed in shader layout for program ${this.id}`);
         }
       }
     }

package/dist/index.cjs

@@ -678,20 +678,21 @@ function getWebGPUVertexFormat(format) {
   return format;
 }
 function getVertexBufferLayout(shaderLayout, bufferLayout) {
+  const attributeInfos = (0, import_core7.getAttributeInfosFromLayouts)(shaderLayout, bufferLayout);
   const vertexBufferLayouts = [];
   const usedAttributes = /* @__PURE__ */ new Set();
   for (const mapping of bufferLayout) {
     const vertexAttributes = [];
     let stepMode = "vertex";
     let byteStride = 0;
-    const byteOffset = mapping.byteOffset || 0;
     if (mapping.attributes) {
-      for (const interleaved of mapping.attributes) {
-        const attributeLayout = findAttributeLayout(shaderLayout, interleaved.name, usedAttributes);
+      for (const attributeMapping of mapping.attributes) {
+        const attributeName = attributeMapping.attribute;
+        const attributeLayout = findAttributeLayout(shaderLayout, attributeName, usedAttributes);
         stepMode = attributeLayout.stepMode || "vertex";
         vertexAttributes.push({
-          format: getWebGPUVertexFormat(interleaved.format || mapping.format),
-          offset: byteOffset + byteStride,
+          format: getWebGPUVertexFormat(attributeMapping.format || mapping.format),
+          offset: attributeMapping.byteOffset,
           shaderLocation: attributeLayout.location
         });
         byteStride += (0, import_core7.decodeVertexFormat)(mapping.format).byteLength;
@@ -702,7 +703,8 @@ function getVertexBufferLayout(shaderLayout, bufferLayout) {
       stepMode = attributeLayout.stepMode || "vertex";
       vertexAttributes.push({
         format: getWebGPUVertexFormat(mapping.format),
-        offset: byteOffset,
+        // We only support 0 offset for non-interleaved buffer layouts
+        offset: 0,
         shaderLocation: attributeLayout.location
       });
     }
@@ -736,7 +738,7 @@ function getBufferSlots(shaderLayout, bufferLayout) {
   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);