@kitware/vtk.js 21.6.0 → 21.6.1

package/Rendering/WebGPU/StorageBuffer.js

@@ -178,7 +178,7 @@ function vtkWebGPUStorageBuffer(publicAPI, model) {
       lines.push("  ".concat(entry.name, ": ").concat(entry.type, ";"));
     }
 
-    lines.push("\n};\n[[block]] struct ".concat(model.name, "Struct\n{\n  values: array<").concat(model.name, "StructEntry>;\n};\n[[binding(").concat(binding, "), group(").concat(group, ")]] var<storage, read> ").concat(model.name, ": ").concat(model.name, "Struct;\n"));
+    lines.push("\n};\nstruct ".concat(model.name, "Struct\n{\n  values: array<").concat(model.name, "StructEntry>;\n};\n[[binding(").concat(binding, "), group(").concat(group, ")]] var<storage, read> ").concat(model.name, ": ").concat(model.name, "Struct;\n"));
     return lines.join('\n');
   };
 

package/Rendering/WebGPU/UniformBuffer.js

@@ -45,18 +45,34 @@ function vtkWebGPUUniformBuffer(publicAPI, model) {
     }
 
     var currOffset = 0;
-    var newEntries = []; // pack anything whose size is a multiple of 16 bytes first
-    // this includes a couple types that don't require 16 byte alignment
-    // such as mat2x2<f32> but that is OK
+    var newEntries = []; // compute the max alignment, this is required as WebGPU defines a UBO to have
+    // a size that is a multiple of the maxAlignment
+
+    var maxAlignment = 4;
 
     for (var i = 0; i < model.bufferEntries.length; i++) {
       var entry = model.bufferEntries[i];
 
-      if (entry.packed === false && entry.sizeInBytes % 16 === 0) {
-        entry.packed = true;
-        entry.offset = currOffset;
-        newEntries.push(entry);
-        currOffset += entry.sizeInBytes;
+      if (entry.sizeInBytes % 16 === 0) {
+        maxAlignment = Math.max(16, maxAlignment);
+      }
+
+      if (entry.sizeInBytes % 8 === 0) {
+        maxAlignment = Math.max(8, maxAlignment);
+      }
+    } // pack anything whose size is a multiple of 16 bytes first
+    // this includes a couple types that don't require 16 byte alignment
+    // such as mat2x2<f32> but that is OK
+
+
+    for (var _i = 0; _i < model.bufferEntries.length; _i++) {
+      var _entry = model.bufferEntries[_i];
+
+      if (_entry.packed === false && _entry.sizeInBytes % 16 === 0) {
+        _entry.packed = true;
+        _entry.offset = currOffset;
+        newEntries.push(_entry);
+        currOffset += _entry.sizeInBytes;
       }
     } // now it gets tough, we have the following common types (f32, i32, u32)
     // - vec2<f32> 8 byte size, 8 byte alignment
@@ -65,18 +81,18 @@ function vtkWebGPUUniformBuffer(publicAPI, model) {
     // try adding 12 byte, 4 byte pairs
 
 
-    for (var _i = 0; _i < model.bufferEntries.length; _i++) {
-      var _entry = model.bufferEntries[_i];
+    for (var _i2 = 0; _i2 < model.bufferEntries.length; _i2++) {
+      var _entry2 = model.bufferEntries[_i2];
 
-      if (_entry.packed === false && _entry.sizeInBytes === 12) {
+      if (_entry2.packed === false && _entry2.sizeInBytes === 12) {
         for (var i2 = 0; i2 < model.bufferEntries.length; i2++) {
           var entry2 = model.bufferEntries[i2];
 
           if (entry2.packed === false && entry2.sizeInBytes === 4) {
-            _entry.packed = true;
-            _entry.offset = currOffset;
-            newEntries.push(_entry);
-            currOffset += _entry.sizeInBytes;
+            _entry2.packed = true;
+            _entry2.offset = currOffset;
+            newEntries.push(_entry2);
+            currOffset += _entry2.sizeInBytes;
             entry2.packed = true;
             entry2.offset = currOffset;
             newEntries.push(entry2);
@@ -88,22 +104,22 @@ function vtkWebGPUUniformBuffer(publicAPI, model) {
     } // try adding 8 byte, 8 byte pairs
 
 
-    for (var _i2 = 0; _i2 < model.bufferEntries.length; _i2++) {
-      var _entry2 = model.bufferEntries[_i2];
+    for (var _i3 = 0; _i3 < model.bufferEntries.length; _i3++) {
+      var _entry3 = model.bufferEntries[_i3];
 
-      if (!_entry2.packed && _entry2.sizeInBytes % 8 === 0) {
-        for (var _i3 = _i2 + 1; _i3 < model.bufferEntries.length; _i3++) {
-          var _entry3 = model.bufferEntries[_i3];
+      if (!_entry3.packed && _entry3.sizeInBytes % 8 === 0) {
+        for (var _i4 = _i3 + 1; _i4 < model.bufferEntries.length; _i4++) {
+          var _entry4 = model.bufferEntries[_i4];
 
-          if (!_entry3.packed && _entry3.sizeInBytes % 8 === 0) {
-            _entry2.packed = true;
-            _entry2.offset = currOffset;
-            newEntries.push(_entry2);
-            currOffset += _entry2.sizeInBytes;
+          if (!_entry4.packed && _entry4.sizeInBytes % 8 === 0) {
             _entry3.packed = true;
             _entry3.offset = currOffset;
             newEntries.push(_entry3);
             currOffset += _entry3.sizeInBytes;
+            _entry4.packed = true;
+            _entry4.offset = currOffset;
+            newEntries.push(_entry4);
+            currOffset += _entry4.sizeInBytes;
             break;
           }
         }
@@ -111,28 +127,28 @@ function vtkWebGPUUniformBuffer(publicAPI, model) {
     } // try adding 8 byte, 4 byte 4 byte triplets
 
 
-    for (var _i4 = 0; _i4 < model.bufferEntries.length; _i4++) {
-      var _entry4 = model.bufferEntries[_i4];
+    for (var _i5 = 0; _i5 < model.bufferEntries.length; _i5++) {
+      var _entry5 = model.bufferEntries[_i5];
 
-      if (!_entry4.packed && _entry4.sizeInBytes % 8 === 0) {
+      if (!_entry5.packed && _entry5.sizeInBytes % 8 === 0) {
         var found = false;
 
-        for (var _i5 = 0; !found && _i5 < model.bufferEntries.length; _i5++) {
-          var _entry5 = model.bufferEntries[_i5];
+        for (var _i6 = 0; !found && _i6 < model.bufferEntries.length; _i6++) {
+          var _entry6 = model.bufferEntries[_i6];
 
-          if (!_entry5.packed && _entry5.sizeInBytes === 4) {
-            for (var i3 = _i5 + 1; i3 < model.bufferEntries.length; i3++) {
+          if (!_entry6.packed && _entry6.sizeInBytes === 4) {
+            for (var i3 = _i6 + 1; i3 < model.bufferEntries.length; i3++) {
               var entry3 = model.bufferEntries[i3];
 
               if (!entry3.packed && entry3.sizeInBytes === 4) {
-                _entry4.packed = true;
-                _entry4.offset = currOffset;
-                newEntries.push(_entry4);
-                currOffset += _entry4.sizeInBytes;
                 _entry5.packed = true;
                 _entry5.offset = currOffset;
                 newEntries.push(_entry5);
                 currOffset += _entry5.sizeInBytes;
+                _entry6.packed = true;
+                _entry6.offset = currOffset;
+                newEntries.push(_entry6);
+                currOffset += _entry6.sizeInBytes;
                 entry3.packed = true;
                 entry3.offset = currOffset;
                 newEntries.push(entry3);
@@ -149,27 +165,27 @@ function vtkWebGPUUniformBuffer(publicAPI, model) {
     // in a failed UBO
 
 
-    for (var _i6 = 0; _i6 < model.bufferEntries.length; _i6++) {
-      var _entry6 = model.bufferEntries[_i6];
-
-      if (!_entry6.packed && _entry6.sizeInBytes > 4) {
-        _entry6.packed = true;
-        _entry6.offset = currOffset;
-        newEntries.push(_entry6);
-        currOffset += _entry6.sizeInBytes;
-      }
-    } // finally add remaining 4 byte items
-
-
     for (var _i7 = 0; _i7 < model.bufferEntries.length; _i7++) {
       var _entry7 = model.bufferEntries[_i7];
 
-      if (!_entry7.packed) {
+      if (!_entry7.packed && _entry7.sizeInBytes > 4) {
         _entry7.packed = true;
         _entry7.offset = currOffset;
         newEntries.push(_entry7);
         currOffset += _entry7.sizeInBytes;
       }
+    } // finally add remaining 4 byte items
+
+
+    for (var _i8 = 0; _i8 < model.bufferEntries.length; _i8++) {
+      var _entry8 = model.bufferEntries[_i8];
+
+      if (!_entry8.packed) {
+        _entry8.packed = true;
+        _entry8.offset = currOffset;
+        newEntries.push(_entry8);
+        currOffset += _entry8.sizeInBytes;
+      }
     } // update entries and entryNames
 
 
@@ -177,11 +193,12 @@ function vtkWebGPUUniformBuffer(publicAPI, model) {
 
     model._bufferEntryNames.clear();
 
-    for (var _i8 = 0; _i8 < model.bufferEntries.length; _i8++) {
-      model._bufferEntryNames.set(model.bufferEntries[_i8].name, _i8);
+    for (var _i9 = 0; _i9 < model.bufferEntries.length; _i9++) {
+      model._bufferEntryNames.set(model.bufferEntries[_i9].name, _i9);
     }
 
     model.sizeInBytes = currOffset;
+    model.sizeInBytes = maxAlignment * Math.ceil(model.sizeInBytes / maxAlignment);
     model.sortDirty = false;
   };
 
@@ -284,7 +301,7 @@ function vtkWebGPUUniformBuffer(publicAPI, model) {
   publicAPI.getShaderCode = function (binding, group) {
     // sort the entries
     publicAPI.sortBufferEntries();
-    var lines = ["[[block]] struct ".concat(model.name, "Struct\n{")];
+    var lines = ["struct ".concat(model.name, "Struct\n{")];
 
     for (var i = 0; i < model.bufferEntries.length; i++) {
       var entry = model.bufferEntries[i];

package/Rendering/WebGPU/VolumePass.js

@@ -218,7 +218,7 @@ function vtkWebGPUVolumePass(publicAPI, model) {
       fDesc.addOutput('vec4<f32>', 'outColor1');
       fDesc.addOutput('vec4<f32>', 'outColor2');
       var code = fDesc.getCode();
-      code = vtkWebGPUShaderCache.substitute(code, '//VTK::RenderEncoder::Impl', ['output.outColor1 = vec4<f32>(stopval, 0.0, 0.0, 0.0);', 'output.outColor2 = vec4<f32>(input.fragPos.z, 0.0, 0.0, 0.0);']).result;
+      code = vtkWebGPUShaderCache.substitute(code, '//VTK::RenderEncoder::Impl', ['output.outColor1 = vec4<f32>(input.fragPos.z, 0.0, 0.0, 0.0);', 'output.outColor2 = vec4<f32>(stopval, 0.0, 0.0, 0.0);']).result;
       fDesc.setCode(code);
     });
     model.depthRangeEncoder.setDescription({

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@kitware/vtk.js",
-  "version": "21.6.0",
+  "version": "21.6.1",
   "description": "Visualization Toolkit for the Web",
   "keywords": [
     "3d",