@kitware/vtk.js 22.2.0 → 22.3.0

package/Rendering/WebGPU/RenderWindow.js

@@ -66,6 +66,7 @@ function vtkWebGPURenderWindow(publicAPI, model) {
 
   publicAPI.recreateSwapChain = function () {
     if (model.context) {
+      model.context.unconfigure();
       var presentationFormat = model.context.getPreferredFormat(model.adapter);
       /* eslint-disable no-undef */
 
@@ -77,6 +78,7 @@ function vtkWebGPURenderWindow(publicAPI, model) {
         usage: GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.COPY_DST,
         size: model.size
       });
+      model._configured = true;
     }
   };
 
@@ -96,7 +98,7 @@ function vtkWebGPURenderWindow(publicAPI, model) {
       publicAPI.removeUnusedNodes();
       publicAPI.initialize();
     } else if (model.initialized) {
-      if (!model.context.validConfiguration) {
+      if (!model._configured) {
         publicAPI.recreateSwapChain();
       }
 
@@ -596,6 +598,13 @@ function vtkWebGPURenderWindow(publicAPI, model) {
       }
     }, _callee2);
   }));
+
+  publicAPI.createSelector = function () {
+    var ret = vtkWebGPUHardwareSelector.newInstance();
+    ret.setWebGPURenderWindow(publicAPI);
+    return ret;
+  };
+
   publicAPI.delete = macro.chain(publicAPI.delete, publicAPI.setViewStream);
 } // ----------------------------------------------------------------------------
 // Object factory

package/Rendering/WebGPU/Renderer.js

@@ -7,7 +7,7 @@ import vtkWebGPUUniformBuffer from './UniformBuffer.js';
 import { registerOverride } from './ViewNodeFactory.js';
 
 var vtkDebugMacro = vtkDebugMacro$1;
-var clearFragTemplate = "\n//VTK::Renderer::Dec\n\n//VTK::Mapper::Dec\n\n//VTK::TCoord::Dec\n\n//VTK::RenderEncoder::Dec\n\n//VTK::IOStructs::Dec\n\n[[stage(fragment)]]\nfn main(\n//VTK::IOStructs::Input\n)\n//VTK::IOStructs::Output\n{\n  var output: fragmentOutput;\n\n  var computedColor: vec4<f32> = mapperUBO.BackgroundColor;\n\n  //VTK::RenderEncoder::Impl\n  return output;\n}\n"; // ----------------------------------------------------------------------------
+var clearFragTemplate = "\n//VTK::Renderer::Dec\n\n//VTK::Mapper::Dec\n\n//VTK::TCoord::Dec\n\n//VTK::RenderEncoder::Dec\n\n//VTK::IOStructs::Dec\n\n@stage(fragment)\nfn main(\n//VTK::IOStructs::Input\n)\n//VTK::IOStructs::Output\n{\n  var output: fragmentOutput;\n\n  var computedColor: vec4<f32> = mapperUBO.BackgroundColor;\n\n  //VTK::RenderEncoder::Impl\n  return output;\n}\n"; // ----------------------------------------------------------------------------
 // vtkWebGPURenderer methods
 // ----------------------------------------------------------------------------
 
@@ -181,8 +181,9 @@ function vtkWebGPURenderer(publicAPI, model) {
       model.clearFSQ.setDevice(device);
       model.clearFSQ.setPipelineHash('clearfsq');
       model.clearFSQ.setFragmentShaderTemplate(clearFragTemplate);
-      var ubo = vtkWebGPUUniformBuffer.newInstance();
-      ubo.setName('mapperUBO');
+      var ubo = vtkWebGPUUniformBuffer.newInstance({
+        label: 'mapperUBO'
+      });
       ubo.addEntry('BackgroundColor', 'vec4<f32>');
       model.clearFSQ.setUBO(ubo);
     }
@@ -334,8 +335,9 @@ function extend(publicAPI, model) {
   Object.assign(model, DEFAULT_VALUES, initialValues); // Inheritance
 
   vtkViewNode.extend(publicAPI, model, initialValues);
-  model.UBO = vtkWebGPUUniformBuffer.newInstance();
-  model.UBO.setName('rendererUBO');
+  model.UBO = vtkWebGPUUniformBuffer.newInstance({
+    label: 'rendererUBO'
+  });
   model.UBO.addEntry('WCVCMatrix', 'mat4x4<f32>');
   model.UBO.addEntry('SCPCMatrix', 'mat4x4<f32>');
   model.UBO.addEntry('PCSCMatrix', 'mat4x4<f32>');
@@ -344,8 +346,9 @@ function extend(publicAPI, model) {
   model.UBO.addEntry('WCVCNormals', 'mat4x4<f32>');
   model.UBO.addEntry('viewportSize', 'vec2<f32>');
   model.UBO.addEntry('cameraParallel', 'u32');
-  model.bindGroup = vtkWebGPUBindGroup.newInstance();
-  model.bindGroup.setName('rendererBG');
+  model.bindGroup = vtkWebGPUBindGroup.newInstance({
+    label: 'rendererBG'
+  });
   model.bindGroup.setBindables([model.UBO]);
   model.tmpMat4 = mat4.identity(new Float64Array(16));
   model.stabilizedTime = {};

package/Rendering/WebGPU/Sampler.js

@@ -14,12 +14,13 @@ function vtkWebGPUSampler(publicAPI, model) {
     model.device = device;
     model.options.magFilter = options.magFilter ? options.magFilter : 'nearest';
     model.options.minFilter = options.minFilter ? options.minFilter : 'nearest';
+    model.options.label = model.label;
     model.handle = model.device.getHandle().createSampler(model.options);
     model.bindGroupTime.modified();
   };
 
   publicAPI.getShaderCode = function (binding, group) {
-    var result = "[[binding(".concat(binding, "), group(").concat(group, ")]] var ").concat(model.name, ": sampler;");
+    var result = "@binding(".concat(binding, ") @group(").concat(group, ") var ").concat(model.label, ": sampler;");
     return result;
   };
 
@@ -37,7 +38,7 @@ function vtkWebGPUSampler(publicAPI, model) {
 var DEFAULT_VALUES = {
   device: null,
   handle: null,
-  name: null,
+  label: null,
   options: null
 }; // ----------------------------------------------------------------------------
 
@@ -60,7 +61,7 @@ function extend(publicAPI, model) {
     mtime: 0
   });
   macro.get(publicAPI, model, ['bindGroupTime', 'handle', 'options']);
-  macro.setGet(publicAPI, model, ['bindGroupLayoutEntry', 'device', 'name']);
+  macro.setGet(publicAPI, model, ['bindGroupLayoutEntry', 'device', 'label']);
   vtkWebGPUSampler(publicAPI, model);
 } // ----------------------------------------------------------------------------
 

package/Rendering/WebGPU/ShaderDescription.js

@@ -51,9 +51,9 @@ function vtkWebGPUShaderDescription(publicAPI, model) {
 
         for (var i = 0; i < inputNames.length; i++) {
           if (inputInterpolations[i] !== undefined) {
-            inputStruct.push("  [[location(".concat(i, "), interpolate(").concat(inputInterpolations[i], ")]] ").concat(inputNames[i], " : ").concat(inputTypes[i], ";"));
+            inputStruct.push("  @location(".concat(i, ") @interpolate(").concat(inputInterpolations[i], ") ").concat(inputNames[i], " : ").concat(inputTypes[i], ";"));
           } else {
-            inputStruct.push("  [[location(".concat(i, ")]] ").concat(inputNames[i], " : ").concat(inputTypes[i], ";"));
+            inputStruct.push("  @location(".concat(i, ") ").concat(inputNames[i], " : ").concat(inputTypes[i], ";"));
           }
         }
       }
@@ -79,9 +79,9 @@ function vtkWebGPUShaderDescription(publicAPI, model) {
 
       for (var _i2 = 0; _i2 < model.outputNames.length; _i2++) {
         if (model.outputInterpolations[_i2] !== undefined) {
-          outputStruct.push("  [[location(".concat(_i2, "), interpolate(").concat(model.outputInterpolations[_i2], ")]] ").concat(model.outputNames[_i2], " : ").concat(model.outputTypes[_i2], ";"));
+          outputStruct.push("  @location(".concat(_i2, ") @interpolate(").concat(model.outputInterpolations[_i2], ") ").concat(model.outputNames[_i2], " : ").concat(model.outputTypes[_i2], ";"));
         } else {
-          outputStruct.push("  [[location(".concat(_i2, ")]] ").concat(model.outputNames[_i2], " : ").concat(model.outputTypes[_i2], ";"));
+          outputStruct.push("  @location(".concat(_i2, ") ").concat(model.outputNames[_i2], " : ").concat(model.outputTypes[_i2], ";"));
         }
       }
 

package/Rendering/WebGPU/SphereMapper.js

@@ -8,7 +8,7 @@ import { registerOverride } from './ViewNodeFactory.js';
 var BufferUsage = vtkWebGPUBufferManager.BufferUsage,
     PrimitiveTypes = vtkWebGPUBufferManager.PrimitiveTypes;
 var vtkErrorMacro = vtkErrorMacro$1;
-var vtkWebGPUSphereMapperVS = "\n//VTK::Renderer::Dec\n\n//VTK::Mapper::Dec\n\n//VTK::Color::Dec\n\n//VTK::IOStructs::Dec\n\n[[stage(vertex)]]\nfn main(\n//VTK::IOStructs::Input\n)\n//VTK::IOStructs::Output\n{\n  var output : vertexOutput;\n\n  var vertexVC: vec4<f32> = rendererUBO.SCVCMatrix * mapperUBO.BCSCMatrix * vec4<f32>(vertexBC.x, vertexBC.y, vertexBC.z, 1.0);\n\n  //VTK::Color::Impl\n\n  // compute the projected vertex position\n  output.centerVC = vertexVC.xyz;\n  output.radiusVC = length(offsetMC)*0.5;\n\n  // make the triangle face the camera\n  if (rendererUBO.cameraParallel == 0u)\n    {\n    var dir: vec3<f32> = normalize(-vertexVC.xyz);\n    var base2: vec3<f32> = normalize(cross(dir,vec3<f32>(1.0,0.0,0.0)));\n    var base1: vec3<f32> = cross(base2,dir);\n    dir = vertexVC.xyz + offsetMC.x*base1 + offsetMC.y*base2;\n    vertexVC = vec4<f32>(dir, 1.0);\n    }\n  else\n    {\n    // add in the offset\n    var tmp2: vec2<f32> = vertexVC.xy + offsetMC;\n    vertexVC = vec4<f32>(tmp2, vertexVC.zw);\n    }\n\n  output.vertexVC = vertexVC.xyz;\n\n  //VTK::Position::Impl\n\n  return output;\n}\n"; // ----------------------------------------------------------------------------
+var vtkWebGPUSphereMapperVS = "\n//VTK::Renderer::Dec\n\n//VTK::Mapper::Dec\n\n//VTK::Color::Dec\n\n//VTK::IOStructs::Dec\n\n@stage(vertex)\nfn main(\n//VTK::IOStructs::Input\n)\n//VTK::IOStructs::Output\n{\n  var output : vertexOutput;\n\n  var vertexVC: vec4<f32> = rendererUBO.SCVCMatrix * mapperUBO.BCSCMatrix * vec4<f32>(vertexBC.x, vertexBC.y, vertexBC.z, 1.0);\n\n  //VTK::Color::Impl\n\n  // compute the projected vertex position\n  output.centerVC = vertexVC.xyz;\n  output.radiusVC = length(offsetMC)*0.5;\n\n  // make the triangle face the camera\n  if (rendererUBO.cameraParallel == 0u)\n    {\n    var dir: vec3<f32> = normalize(-vertexVC.xyz);\n    var base2: vec3<f32> = normalize(cross(dir,vec3<f32>(1.0,0.0,0.0)));\n    var base1: vec3<f32> = cross(base2,dir);\n    dir = vertexVC.xyz + offsetMC.x*base1 + offsetMC.y*base2;\n    vertexVC = vec4<f32>(dir, 1.0);\n    }\n  else\n    {\n    // add in the offset\n    var tmp2: vec2<f32> = vertexVC.xy + offsetMC;\n    vertexVC = vec4<f32>(tmp2, vertexVC.zw);\n    }\n\n  output.vertexVC = vertexVC.xyz;\n\n  //VTK::Position::Impl\n\n  return output;\n}\n"; // ----------------------------------------------------------------------------
 // vtkWebGPUSphereMapper methods
 // ----------------------------------------------------------------------------
 
@@ -22,7 +22,7 @@ function vtkWebGPUSphereMapper(publicAPI, model) {
     vDesc.addOutput('vec3<f32>', 'centerVC');
     vDesc.addOutput('f32', 'radiusVC');
     var fDesc = pipeline.getShaderDescription('fragment');
-    fDesc.addBuiltinOutput('f32', '[[builtin(frag_depth)]] fragDepth');
+    fDesc.addBuiltinOutput('f32', '@builtin(frag_depth) fragDepth');
     var sphereFrag = "\n    // compute the eye position and unit direction\n    var vertexVC: vec4<f32>;\n    var EyePos: vec3<f32>;\n    var EyeDir: vec3<f32>;\n    var invertedDepth: f32 = 1.0;\n    if (rendererUBO.cameraParallel != 0u) {\n      EyePos = vec3<f32>(input.vertexVC.x, input.vertexVC.y, input.vertexVC.z + 3.0*input.radiusVC);\n      EyeDir = vec3<f32>(0.0, 0.0, -1.0);\n    }\n    else {\n      EyeDir = input.vertexVC.xyz;\n      EyePos = vec3<f32>(0.0,0.0,0.0);\n      var lengthED: f32 = length(EyeDir);\n      EyeDir = normalize(EyeDir);\n      // we adjust the EyePos to be closer if it is too far away\n      // to prevent floating point precision noise\n      if (lengthED > input.radiusVC*3.0) {\n        EyePos = input.vertexVC.xyz - EyeDir*3.0*input.radiusVC;\n      }\n    }\n\n    // translate to Sphere center\n    EyePos = EyePos - input.centerVC;\n    // scale to radius 1.0\n    EyePos = EyePos * (1.0 / input.radiusVC);\n    // find the intersection\n    var b: f32 = 2.0*dot(EyePos,EyeDir);\n    var c: f32 = dot(EyePos,EyePos) - 1.0;\n    var d: f32 = b*b - 4.0*c;\n    var normal: vec3<f32> = vec3<f32>(0.0,0.0,1.0);\n    if (d < 0.0) { discard; }\n    else {\n      var t: f32 = (-b - invertedDepth*sqrt(d))*0.5;\n\n      // compute the normal, for unit sphere this is just\n      // the intersection point\n      normal = invertedDepth*normalize(EyePos + t*EyeDir);\n      // compute the intersection point in VC\n      vertexVC = vec4<f32>(normal * input.radiusVC + input.centerVC, 1.0);\n    }\n    // compute the pixel's depth\n    var pos: vec4<f32> = rendererUBO.VCPCMatrix * vertexVC;\n    output.fragDepth = pos.z / pos.w;\n    ";
     var code = fDesc.getCode();
     code = vtkWebGPUShaderCache.substitute(code, '//VTK::Normal::Impl', [sphereFrag]).result;
@@ -31,7 +31,7 @@ function vtkWebGPUSphereMapper(publicAPI, model) {
 
   publicAPI.replaceShaderPosition = function (hash, pipeline, vertexInput) {
     var vDesc = pipeline.getShaderDescription('vertex');
-    vDesc.addBuiltinOutput('vec4<f32>', '[[builtin(position)]] Position');
+    vDesc.addBuiltinOutput('vec4<f32>', '@builtin(position) Position');
     var code = vDesc.getCode();
     code = vtkWebGPUShaderCache.substitute(code, '//VTK::Position::Impl', ['  output.Position = rendererUBO.VCPCMatrix*vertexVC;']).result;
     vDesc.setCode(code);

package/Rendering/WebGPU/StickMapper.js

@@ -27,7 +27,7 @@ var vtkErrorMacro = vtkErrorMacro$1; // Vertices
 // 4: 011
 // 5: 111
 
-var vtkWebGPUStickMapperVS = "\n//VTK::Renderer::Dec\n\n//VTK::Mapper::Dec\n\n//VTK::Color::Dec\n\n//VTK::IOStructs::Dec\n\n[[stage(vertex)]]\nfn main(\n//VTK::IOStructs::Input\n)\n//VTK::IOStructs::Output\n{\n  var offsetsArray: array<vec3<f32>, 12> = array<vec3<f32>, 12>(\n    vec3<f32>(-1.0, -1.0, -1.0),\n    vec3<f32>(1.0, -1.0, -1.0),\n    vec3<f32>(1.0, -1.0, 1.0),\n\n    vec3<f32>(-1.0, -1.0, -1.0),\n    vec3<f32>(1.0, -1.0, 1.0),\n    vec3<f32>(-1.0, -1.0, 1.0),\n\n    vec3<f32>(-1.0, -1.0, 1.0),\n    vec3<f32>(1.0, -1.0, 1.0),\n    vec3<f32>(1.0, 1.0, 1.0),\n\n    vec3<f32>(-1.0, -1.0, 1.0),\n    vec3<f32>(1.0, 1.0, 1.0),\n    vec3<f32>(-1.0, 1.0, 1.0)\n  );\n\n  var output : vertexOutput;\n\n  var vertexVC: vec4<f32> = rendererUBO.SCVCMatrix * mapperUBO.BCSCMatrix * vec4<f32>(vertexBC.x, vertexBC.y, vertexBC.z, 1.0);\n\n  //VTK::Color::Impl\n\n  // compute the projected vertex position\n  output.centerVC = vertexVC.xyz;\n  output.radiusVC = radiusMC;\n  output.lengthVC = length(orientMC);\n  output.orientVC = (rendererUBO.WCVCNormals * vec4<f32>(normalize(orientMC), 0.0)).xyz;\n\n  // make sure it is pointing out of the screen\n  if (output.orientVC.z < 0.0)\n    {\n    output.orientVC = -output.orientVC;\n    }\n\n  // make the basis\n  var xbase: vec3<f32>;\n  var ybase: vec3<f32>;\n  var dir: vec3<f32> = vec3<f32>(0.0,0.0,1.0);\n  if (rendererUBO.cameraParallel == 0u)\n    {\n    dir = normalize(-vertexVC.xyz);\n    }\n  if (abs(dot(dir,output.orientVC)) == 1.0)\n    {\n    xbase = normalize(cross(vec3<f32>(0.0,1.0,0.0),output.orientVC));\n    ybase = cross(xbase,output.orientVC);\n    }\n  else\n    {\n    xbase = normalize(cross(output.orientVC,dir));\n    ybase = cross(output.orientVC,xbase);\n    }\n\n\n  var vertIdx: u32 = input.vertexIndex % 12u;\n  var offsets: vec3<f32> = offsetsArray[vertIdx];\n\n  vertexVC = vec4<f32>(vertexVC.xyz +\n    output.radiusVC * offsets.x * xbase +\n    output.radiusVC * offsets.y * ybase +\n    0.5 * output.lengthVC * offsets.z * output.orientVC, 1.0);\n\n  output.vertexVC = vertexVC;\n\n  //VTK::Position::Impl\n\n  return output;\n}\n"; // ----------------------------------------------------------------------------
+var vtkWebGPUStickMapperVS = "\n//VTK::Renderer::Dec\n\n//VTK::Mapper::Dec\n\n//VTK::Color::Dec\n\n//VTK::IOStructs::Dec\n\n@stage(vertex)\nfn main(\n//VTK::IOStructs::Input\n)\n//VTK::IOStructs::Output\n{\n  var offsetsArray: array<vec3<f32>, 12> = array<vec3<f32>, 12>(\n    vec3<f32>(-1.0, -1.0, -1.0),\n    vec3<f32>(1.0, -1.0, -1.0),\n    vec3<f32>(1.0, -1.0, 1.0),\n\n    vec3<f32>(-1.0, -1.0, -1.0),\n    vec3<f32>(1.0, -1.0, 1.0),\n    vec3<f32>(-1.0, -1.0, 1.0),\n\n    vec3<f32>(-1.0, -1.0, 1.0),\n    vec3<f32>(1.0, -1.0, 1.0),\n    vec3<f32>(1.0, 1.0, 1.0),\n\n    vec3<f32>(-1.0, -1.0, 1.0),\n    vec3<f32>(1.0, 1.0, 1.0),\n    vec3<f32>(-1.0, 1.0, 1.0)\n  );\n\n  var output : vertexOutput;\n\n  var vertexVC: vec4<f32> = rendererUBO.SCVCMatrix * mapperUBO.BCSCMatrix * vec4<f32>(vertexBC.x, vertexBC.y, vertexBC.z, 1.0);\n\n  //VTK::Color::Impl\n\n  // compute the projected vertex position\n  output.centerVC = vertexVC.xyz;\n  output.radiusVC = radiusMC;\n  output.lengthVC = length(orientMC);\n  output.orientVC = (rendererUBO.WCVCNormals * vec4<f32>(normalize(orientMC), 0.0)).xyz;\n\n  // make sure it is pointing out of the screen\n  if (output.orientVC.z < 0.0)\n    {\n    output.orientVC = -output.orientVC;\n    }\n\n  // make the basis\n  var xbase: vec3<f32>;\n  var ybase: vec3<f32>;\n  var dir: vec3<f32> = vec3<f32>(0.0,0.0,1.0);\n  if (rendererUBO.cameraParallel == 0u)\n    {\n    dir = normalize(-vertexVC.xyz);\n    }\n  if (abs(dot(dir,output.orientVC)) == 1.0)\n    {\n    xbase = normalize(cross(vec3<f32>(0.0,1.0,0.0),output.orientVC));\n    ybase = cross(xbase,output.orientVC);\n    }\n  else\n    {\n    xbase = normalize(cross(output.orientVC,dir));\n    ybase = cross(output.orientVC,xbase);\n    }\n\n\n  var vertIdx: u32 = input.vertexIndex % 12u;\n  var offsets: vec3<f32> = offsetsArray[vertIdx];\n\n  vertexVC = vec4<f32>(vertexVC.xyz +\n    output.radiusVC * offsets.x * xbase +\n    output.radiusVC * offsets.y * ybase +\n    0.5 * output.lengthVC * offsets.z * output.orientVC, 1.0);\n\n  output.vertexVC = vertexVC;\n\n  //VTK::Position::Impl\n\n  return output;\n}\n"; // ----------------------------------------------------------------------------
 // vtkWebGPUStickMapper methods
 // ----------------------------------------------------------------------------
 
@@ -42,9 +42,9 @@ function vtkWebGPUStickMapper(publicAPI, model) {
     vDesc.addOutput('vec3<f32>', 'orientVC');
     vDesc.addOutput('f32', 'radiusVC');
     vDesc.addOutput('f32', 'lengthVC');
-    vDesc.addBuiltinInput('u32', '[[builtin(vertex_index)]] vertexIndex');
+    vDesc.addBuiltinInput('u32', '@builtin(vertex_index) vertexIndex');
     var fDesc = pipeline.getShaderDescription('fragment');
-    fDesc.addBuiltinOutput('f32', '[[builtin(frag_depth)]] fragDepth');
+    fDesc.addBuiltinOutput('f32', '@builtin(frag_depth) fragDepth');
     var stickFrag = "\n    // compute the eye position and unit direction\n    var vertexVC: vec4<f32>;\n    var EyePos: vec3<f32>;\n    var EyeDir: vec3<f32>;\n\n    if (rendererUBO.cameraParallel != 0u)\n    {\n      EyePos = vec3<f32>(input.vertexVC.x, input.vertexVC.y, input.vertexVC.z + 3.0*input.radiusVC);\n      EyeDir = vec3<f32>(0.0, 0.0, -1.0);\n    }\n    else\n    {\n      EyeDir = input.vertexVC.xyz;\n      EyePos = vec3<f32>(0.0,0.0,0.0);\n      var lengthED: f32 = length(EyeDir);\n      EyeDir = normalize(EyeDir);\n      // we adjust the EyePos to be closer if it is too far away\n      // to prevent floating point precision noise\n      if (lengthED > input.radiusVC*3.0)\n      {\n        EyePos = input.vertexVC.xyz - EyeDir*3.0*input.radiusVC;\n      }\n    }\n    // translate to Sphere center\n    EyePos = EyePos - input.centerVC;\n\n    // rotate to new basis\n    // base1, base2, orientVC\n    var base1: vec3<f32>;\n    if (abs(input.orientVC.z) < 0.99)\n    {\n      base1 = normalize(cross(input.orientVC,vec3<f32>(0.0,0.0,1.0)));\n    }\n    else\n    {\n      base1 = normalize(cross(input.orientVC,vec3<f32>(0.0,1.0,0.0)));\n    }\n    var base2: vec3<f32> = cross(input.orientVC,base1);\n    EyePos = vec3<f32>(dot(EyePos,base1),dot(EyePos,base2),dot(EyePos,input.orientVC));\n    EyeDir = vec3<f32>(dot(EyeDir,base1),dot(EyeDir,base2),dot(EyeDir,input.orientVC));\n\n    // scale to radius 1.0\n    EyePos = EyePos * (1.0 / input.radiusVC);\n\n    // find the intersection\n    var a: f32 = EyeDir.x*EyeDir.x + EyeDir.y*EyeDir.y;\n    var b: f32 = 2.0*(EyePos.x*EyeDir.x + EyePos.y*EyeDir.y);\n    var c: f32 = EyePos.x*EyePos.x + EyePos.y*EyePos.y - 1.0;\n    var d: f32 = b*b - 4.0*a*c;\n    var normal: vec3<f32> = vec3<f32>(0.0,0.0,1.0);\n    if (d < 0.0) { discard; }\n    else\n    {\n      var t: f32 = (-b - sqrt(d))*(0.5 / a);\n      var tz: f32 = EyePos.z + t*EyeDir.z;\n      var iPoint: vec3<f32> = EyePos + t*EyeDir;\n      if (abs(iPoint.z)*input.radiusVC > input.lengthVC*0.5)\n      {\n        // test for end cap\n        var t2: f32 = (-b + sqrt(d))*(0.5 / a);\n        var tz2: f32 = EyePos.z + t2*EyeDir.z;\n        if (tz2*input.radiusVC > input.lengthVC*0.5 || tz*input.radiusVC < -0.5*input.lengthVC) { discard; }\n        else\n        {\n          normal = input.orientVC;\n          var t3: f32 = (input.lengthVC*0.5/input.radiusVC - EyePos.z)/EyeDir.z;\n          iPoint = EyePos + t3*EyeDir;\n          vertexVC = vec4<f32>(input.radiusVC*(iPoint.x*base1 + iPoint.y*base2 + iPoint.z*input.orientVC) + input.centerVC, 1.0);\n        }\n      }\n      else\n      {\n        // The normal is the iPoint.xy rotated back into VC\n        normal = iPoint.x*base1 + iPoint.y*base2;\n        // rescale rerotate and translate\n        vertexVC = vec4<f32>(input.radiusVC*(normal + iPoint.z*input.orientVC) + input.centerVC, 1.0);\n      }\n      // compute the pixel's depth\n      var pos: vec4<f32> = rendererUBO.VCPCMatrix * vertexVC;\n      output.fragDepth = pos.z / pos.w;\n    }\n    ";
     var code = fDesc.getCode();
     code = vtkWebGPUShaderCache.substitute(code, '//VTK::Normal::Impl', [stickFrag]).result;
@@ -53,7 +53,7 @@ function vtkWebGPUStickMapper(publicAPI, model) {
 
   publicAPI.replaceShaderPosition = function (hash, pipeline, vertexInput) {
     var vDesc = pipeline.getShaderDescription('vertex');
-    vDesc.addBuiltinOutput('vec4<f32>', '[[builtin(position)]] Position');
+    vDesc.addBuiltinOutput('vec4<f32>', '@builtin(position) Position');
     var code = vDesc.getCode();
     code = vtkWebGPUShaderCache.substitute(code, '//VTK::Position::Impl', ['  output.Position = rendererUBO.VCPCMatrix*vertexVC;']).result;
     vDesc.setCode(code);

package/Rendering/WebGPU/StorageBuffer.js

@@ -41,7 +41,8 @@ function vtkWebGPUStorageBuffer(publicAPI, model) {
       var req = {
         nativeArray: model.Float32Array,
         time: 0,
-        usage: BufferUsage.Storage
+        usage: BufferUsage.Storage,
+        label: model.label
       };
       model._buffer = device.getBufferManager().getBuffer(req);
       model.bindGroupTime.modified();
@@ -171,14 +172,14 @@ function vtkWebGPUStorageBuffer(publicAPI, model) {
   };
 
   publicAPI.getShaderCode = function (binding, group) {
-    var lines = ["struct ".concat(model.name, "StructEntry\n{")];
+    var lines = ["struct ".concat(model.label, "StructEntry\n{")];
 
     for (var i = 0; i < model.bufferEntries.length; i++) {
       var entry = model.bufferEntries[i];
       lines.push("  ".concat(entry.name, ": ").concat(entry.type, ";"));
     }
 
-    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"));
+    lines.push("\n};\nstruct ".concat(model.label, "Struct\n{\n  values: array<").concat(model.label, "StructEntry>;\n};\n@binding(").concat(binding, ") @group(").concat(group, ") var<storage, read> ").concat(model.label, ": ").concat(model.label, "Struct;\n"));
     return lines.join('\n');
   };
 
@@ -209,7 +210,7 @@ var DEFAULT_VALUES = {
   bufferEntries: null,
   bufferEntryNames: null,
   sizeInBytes: 0,
-  name: null,
+  label: null,
   numberOfInstances: 1
 }; // ----------------------------------------------------------------------------
 
@@ -236,7 +237,7 @@ function extend(publicAPI, model) {
     }
   };
   macro.get(publicAPI, model, ['bindGroupTime']);
-  macro.setGet(publicAPI, model, ['device', 'bindGroupLayoutEntry', 'name', 'numberOfInstances', 'sizeInBytes']); // Object methods
+  macro.setGet(publicAPI, model, ['device', 'bindGroupLayoutEntry', 'label', 'numberOfInstances', 'sizeInBytes']); // Object methods
 
   vtkWebGPUStorageBuffer(publicAPI, model);
 } // ----------------------------------------------------------------------------

package/Rendering/WebGPU/Texture.js

@@ -36,6 +36,7 @@ function vtkWebGPUTexture(publicAPI, model) {
       format: model.format,
       // 'rgba8unorm',
       usage: model.usage,
+      label: model.label,
       dimension: dimension
     });
   };
@@ -172,7 +173,8 @@ function vtkWebGPUTexture(publicAPI, model) {
       model.handle = model.device.getHandle().createTexture({
         size: [model.width, model.height, model.depth],
         format: model.format,
-        usage: model.usage
+        usage: model.usage,
+        label: model.label
       });
     }
   };
@@ -187,20 +189,23 @@ function vtkWebGPUTexture(publicAPI, model) {
       model.handle = model.device.getHandle().createTexture({
         size: [model.width, model.height, model.depth],
         format: model.format,
-        usage: model.usage
+        usage: model.usage,
+        label: model.label
       });
     }
   };
 
-  publicAPI.createView = function () {
-    var options = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
+  publicAPI.createView = function (label) {
+    var options = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
 
     // if options is missing values try to add them in
     if (!options.dimension) {
       options.dimension = model.depth === 1 ? '2d' : '3d';
     }
 
-    var view = vtkWebGPUTextureView.newInstance();
+    var view = vtkWebGPUTextureView.newInstance({
+      label: label
+    });
     view.create(publicAPI, options);
     return view;
   };
@@ -213,7 +218,8 @@ var DEFAULT_VALUES = {
   device: null,
   handle: null,
   buffer: null,
-  ready: false
+  ready: false,
+  label: null
 }; // ----------------------------------------------------------------------------
 
 function extend(publicAPI, model) {
@@ -222,7 +228,7 @@ function extend(publicAPI, model) {
 
   macro.obj(publicAPI, model);
   macro.get(publicAPI, model, ['handle', 'ready', 'width', 'height', 'depth', 'format', 'usage']);
-  macro.setGet(publicAPI, model, ['device']);
+  macro.setGet(publicAPI, model, ['device', 'label']);
   vtkWebGPUTexture(publicAPI, model);
 } // ----------------------------------------------------------------------------
 

package/Rendering/WebGPU/TextureView.js

@@ -15,6 +15,7 @@ function vtkWebGPUTextureView(publicAPI, model) {
     model.texture = texture;
     model.options = options;
     model.options.dimension = model.options.dimension || '2d';
+    model.options.label = model.label;
     model.textureHandle = texture.getHandle();
     model.handle = model.textureHandle.createView(model.options);
     model.bindGroupLayoutEntry.texture.viewDimension = model.options.dimension;
@@ -38,33 +39,21 @@ function vtkWebGPUTextureView(publicAPI, model) {
       ttype = 'u32';
     }
 
-    var result = "[[binding(".concat(binding, "), group(").concat(group, ")]] var ").concat(model.name, ": texture_").concat(model.options.dimension, "<").concat(ttype, ">;");
+    var result = "@binding(".concat(binding, ") @group(").concat(group, ") var ").concat(model.label, ": texture_").concat(model.options.dimension, "<").concat(ttype, ">;");
 
     if (model.bindGroupLayoutEntry.texture.sampleType === 'depth') {
-      result = "[[binding(".concat(binding, "), group(").concat(group, ")]] var ").concat(model.name, ": texture_depth_").concat(model.options.dimension, ";");
+      result = "@binding(".concat(binding, ") @group(").concat(group, ") var ").concat(model.label, ": texture_depth_").concat(model.options.dimension, ";");
     }
 
     return result;
   };
 
   publicAPI.addSampler = function (device, options) {
-    var newSamp = vtkWebGPUSampler.newInstance();
+    var newSamp = vtkWebGPUSampler.newInstance({
+      label: "".concat(model.label, "Sampler")
+    });
     newSamp.create(device, options);
     publicAPI.setSampler(newSamp);
-    model.sampler.setName("".concat(model.name, "Sampler"));
-  };
-
-  publicAPI.setName = function (val) {
-    if (model.sampler) {
-      model.sampler.setName("".concat(val, "Sampler"));
-    }
-
-    if (model.name === val) {
-      return;
-    }
-
-    model.name = val;
-    publicAPI.modified();
   };
 
   publicAPI.getBindGroupTime = function () {
@@ -96,8 +85,8 @@ function vtkWebGPUTextureView(publicAPI, model) {
 var DEFAULT_VALUES = {
   texture: null,
   handle: null,
-  name: null,
-  sampler: null
+  sampler: null,
+  label: null
 }; // ----------------------------------------------------------------------------
 
 function extend(publicAPI, model) {
@@ -120,8 +109,8 @@ function extend(publicAPI, model) {
   macro.obj(model.bindGroupTime, {
     mtime: 0
   });
-  macro.get(publicAPI, model, ['bindGroupTime', 'name', 'texture']);
-  macro.setGet(publicAPI, model, ['bindGroupLayoutEntry', 'sampler']);
+  macro.get(publicAPI, model, ['bindGroupTime', 'texture']);
+  macro.setGet(publicAPI, model, ['bindGroupLayoutEntry', 'label', 'sampler']);
   vtkWebGPUTextureView(publicAPI, model);
 } // ----------------------------------------------------------------------------
 

package/Rendering/WebGPU/UniformBuffer.js

@@ -207,7 +207,8 @@ function vtkWebGPUUniformBuffer(publicAPI, model) {
       var req = {
         nativeArray: model.Float32Array,
         time: 0,
-        usage: BufferUsage.UniformArray
+        usage: BufferUsage.UniformArray,
+        label: model.label
       };
       model.UBO = device.getBufferManager().getBuffer(req);
       model.bindGroupTime.modified();
@@ -301,14 +302,14 @@ function vtkWebGPUUniformBuffer(publicAPI, model) {
   publicAPI.getShaderCode = function (binding, group) {
     // sort the entries
     publicAPI.sortBufferEntries();
-    var lines = ["struct ".concat(model.name, "Struct\n{")];
+    var lines = ["struct ".concat(model.label, "Struct\n{")];
 
     for (var i = 0; i < model.bufferEntries.length; i++) {
       var entry = model.bufferEntries[i];
       lines.push("  ".concat(entry.name, ": ").concat(entry.type, ";"));
     }
 
-    lines.push("};\n[[binding(".concat(binding, "), group(").concat(group, ")]] var<uniform> ").concat(model.name, ": ").concat(model.name, "Struct;"));
+    lines.push("};\n@binding(".concat(binding, ") @group(").concat(group, ") var<uniform> ").concat(model.label, ": ").concat(model.label, "Struct;"));
     return lines.join('\n');
   };
 } // ----------------------------------------------------------------------------
@@ -320,7 +321,7 @@ var DEFAULT_VALUES = {
   bufferEntries: null,
   bufferEntryNames: null,
   sizeInBytes: 0,
-  name: null,
+  label: null,
   bindGroupLayoutEntry: null,
   bindGroupEntry: null
 }; // ----------------------------------------------------------------------------
@@ -350,7 +351,7 @@ function extend(publicAPI, model) {
   model.sendDirty = true;
   model.sortDirty = true;
   macro.get(publicAPI, model, ['binding', 'bindGroupTime']);
-  macro.setGet(publicAPI, model, ['bindGroupLayoutEntry', 'device', 'name', 'sizeInBytes']); // Object methods
+  macro.setGet(publicAPI, model, ['bindGroupLayoutEntry', 'device', 'label', 'sizeInBytes']); // Object methods
 
   vtkWebGPUUniformBuffer(publicAPI, model);
 } // ----------------------------------------------------------------------------

package/Rendering/WebGPU/VertexInput.js

@@ -112,7 +112,7 @@ function vtkWebGPUVertexInput(publicAPI, model) {
           result += ',\n';
         }
 
-        result = "".concat(result, "  [[location(").concat(nameCount, ")]] ").concat(model.inputs[i].names[nm], " : ").concat(type);
+        result = "".concat(result, "  @location(").concat(nameCount, ") ").concat(model.inputs[i].names[nm], " : ").concat(type);
         nameCount++;
       }
     }

package/Rendering/WebGPU/VolumePass.js

@@ -33,8 +33,8 @@ var BufferUsage = vtkWebGPUBufferManager.BufferUsage,
 //
 
 var cubeFaceTriangles = [[0, 4, 6], [0, 6, 2], [1, 3, 7], [1, 7, 5], [0, 5, 4], [0, 1, 5], [2, 6, 7], [2, 7, 3], [0, 3, 1], [0, 2, 3], [4, 5, 7], [4, 7, 6]];
-var DepthBoundsFS = "\n//VTK::Renderer::Dec\n\n//VTK::Select::Dec\n\n//VTK::VolumePass::Dec\n\n//VTK::TCoord::Dec\n\n//VTK::RenderEncoder::Dec\n\n//VTK::Mapper::Dec\n\n//VTK::IOStructs::Dec\n\n[[stage(fragment)]]\nfn main(\n//VTK::IOStructs::Input\n)\n//VTK::IOStructs::Output\n{\n  var output : fragmentOutput;\n\n  //VTK::Select::Impl\n\n  //VTK::TCoord::Impl\n\n  //VTK::VolumePass::Impl\n\n  // use the maximum (closest) of the current value and the zbuffer\n  // the blend func will then take the min to find the farthest stop value\n  var stopval: f32 = max(input.fragPos.z, textureLoad(opaquePassDepthTexture, vec2<i32>(i32(input.fragPos.x), i32(input.fragPos.y)), 0));\n\n  //VTK::RenderEncoder::Impl\n  return output;\n}\n";
-var volumeCopyFragTemplate = "\n//VTK::Renderer::Dec\n\n//VTK::Mapper::Dec\n\n//VTK::TCoord::Dec\n\n//VTK::RenderEncoder::Dec\n\n//VTK::IOStructs::Dec\n\n[[stage(fragment)]]\nfn main(\n//VTK::IOStructs::Input\n)\n//VTK::IOStructs::Output\n{\n  var output: fragmentOutput;\n\n  var computedColor: vec4<f32> = textureSample(volumePassSmallColorTexture,\n    volumePassSmallColorTextureSampler, mapperUBO.tscale*input.tcoordVS);\n\n  //VTK::RenderEncoder::Impl\n  return output;\n}\n";
+var DepthBoundsFS = "\n//VTK::Renderer::Dec\n\n//VTK::Select::Dec\n\n//VTK::VolumePass::Dec\n\n//VTK::TCoord::Dec\n\n//VTK::RenderEncoder::Dec\n\n//VTK::Mapper::Dec\n\n//VTK::IOStructs::Dec\n\n@stage(fragment)\nfn main(\n//VTK::IOStructs::Input\n)\n//VTK::IOStructs::Output\n{\n  var output : fragmentOutput;\n\n  //VTK::Select::Impl\n\n  //VTK::TCoord::Impl\n\n  //VTK::VolumePass::Impl\n\n  // use the maximum (closest) of the current value and the zbuffer\n  // the blend func will then take the min to find the farthest stop value\n  var stopval: f32 = max(input.fragPos.z, textureLoad(opaquePassDepthTexture, vec2<i32>(i32(input.fragPos.x), i32(input.fragPos.y)), 0));\n\n  //VTK::RenderEncoder::Impl\n  return output;\n}\n";
+var volumeCopyFragTemplate = "\n//VTK::Renderer::Dec\n\n//VTK::Mapper::Dec\n\n//VTK::TCoord::Dec\n\n//VTK::RenderEncoder::Dec\n\n//VTK::IOStructs::Dec\n\n@stage(fragment)\nfn main(\n//VTK::IOStructs::Input\n)\n//VTK::IOStructs::Output\n{\n  var output: fragmentOutput;\n\n  var computedColor: vec4<f32> = textureSample(volumePassColorTexture,\n    volumePassColorTextureSampler, mapperUBO.tscale*input.tcoordVS);\n\n  //VTK::RenderEncoder::Impl\n  return output;\n}\n";
 /* eslint-disable no-undef */
 
 /* eslint-disable no-bitwise */
@@ -76,9 +76,9 @@ function vtkWebGPUVolumePass(publicAPI, model) {
 
       model._volumeCopyQuad.setFragmentShaderTemplate(volumeCopyFragTemplate);
 
-      model._copyUBO = vtkWebGPUUniformBuffer.newInstance();
-
-      model._copyUBO.setName('mapperUBO');
+      model._copyUBO = vtkWebGPUUniformBuffer.newInstance({
+        label: 'mapperUBO'
+      });
 
       model._copyUBO.addEntry('tscale', 'vec2<f32>');
 
@@ -366,7 +366,9 @@ function vtkWebGPUVolumePass(publicAPI, model) {
 
   publicAPI.createDepthRangeEncoder = function (viewNode) {
     var device = viewNode.getDevice();
-    model._depthRangeEncoder = vtkWebGPURenderEncoder.newInstance();
+    model._depthRangeEncoder = vtkWebGPURenderEncoder.newInstance({
+      label: 'VolumePass DepthRange'
+    });
 
     model._depthRangeEncoder.setPipelineHash('volr');
 
@@ -429,7 +431,9 @@ function vtkWebGPUVolumePass(publicAPI, model) {
     }); // and the textures it needs
 
 
-    model._depthRangeTexture = vtkWebGPUTexture.newInstance();
+    model._depthRangeTexture = vtkWebGPUTexture.newInstance({
+      label: 'volumePassMaxDepth'
+    });
 
     model._depthRangeTexture.create(device, {
       width: viewNode.getCanvas().width,
@@ -438,13 +442,13 @@ function vtkWebGPUVolumePass(publicAPI, model) {
       usage: GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING
     });
 
-    var maxView = model._depthRangeTexture.createView();
-
-    maxView.setName('maxTexture');
+    var maxView = model._depthRangeTexture.createView('maxTexture');
 
     model._depthRangeEncoder.setColorTextureView(0, maxView);
 
-    model._depthRangeTexture2 = vtkWebGPUTexture.newInstance();
+    model._depthRangeTexture2 = vtkWebGPUTexture.newInstance({
+      label: 'volumePassDepthMin'
+    });
 
     model._depthRangeTexture2.create(device, {
       width: viewNode.getCanvas().width,
@@ -453,9 +457,7 @@ function vtkWebGPUVolumePass(publicAPI, model) {
       usage: GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING
     });
 
-    var minView = model._depthRangeTexture2.createView();
-
-    minView.setName('minTexture');
+    var minView = model._depthRangeTexture2.createView('minTexture');
 
     model._depthRangeEncoder.setColorTextureView(1, minView);
 
@@ -465,7 +467,9 @@ function vtkWebGPUVolumePass(publicAPI, model) {
   };
 
   publicAPI.createClearEncoder = function (viewNode) {
-    model._colorTexture = vtkWebGPUTexture.newInstance();
+    model._colorTexture = vtkWebGPUTexture.newInstance({
+      label: 'volumePassColor'
+    });
 
     model._colorTexture.create(viewNode.getDevice(), {
       width: viewNode.getCanvas().width,
@@ -478,16 +482,16 @@ function vtkWebGPUVolumePass(publicAPI, model) {
       usage: GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING | GPUTextureUsage.COPY_SRC
     });
 
-    model._colorTextureView = model._colorTexture.createView();
-
-    model._colorTextureView.setName('volumePassSmallColorTexture');
+    model._colorTextureView = model._colorTexture.createView('volumePassColorTexture');
 
     model._colorTextureView.addSampler(viewNode.getDevice(), {
       minFilter: 'linear',
       magFilter: 'linear'
     });
 
-    model._clearEncoder = vtkWebGPURenderEncoder.newInstance();
+    model._clearEncoder = vtkWebGPURenderEncoder.newInstance({
+      label: 'VolumePass Clear'
+    });
 
     model._clearEncoder.setColorTextureView(0, model._colorTextureView);
 
@@ -524,7 +528,9 @@ function vtkWebGPUVolumePass(publicAPI, model) {
   };
 
   publicAPI.createCopyEncoder = function (viewNode) {
-    model._copyEncoder = vtkWebGPURenderEncoder.newInstance();
+    model._copyEncoder = vtkWebGPURenderEncoder.newInstance({
+      label: 'volumePassCopy'
+    });
 
     model._copyEncoder.setDescription({
       colorAttachments: [{
@@ -559,7 +565,9 @@ function vtkWebGPUVolumePass(publicAPI, model) {
   };
 
   publicAPI.createMergeEncoder = function (viewNode) {
-    model._mergeEncoder = vtkWebGPURenderEncoder.newInstance();
+    model._mergeEncoder = vtkWebGPURenderEncoder.newInstance({
+      label: 'volumePassMerge'
+    });
 
     model._mergeEncoder.setColorTextureView(0, model._colorTextureView);
 
@@ -642,7 +650,7 @@ function extend(publicAPI, model) {
 
   model._mapper.getShaderReplacements().set('replaceShaderVolumePass', function (hash, pipeline, vertexInput) {
     var fDesc = pipeline.getShaderDescription('fragment');
-    fDesc.addBuiltinInput('vec4<f32>', '[[builtin(position)]] fragPos');
+    fDesc.addBuiltinInput('vec4<f32>', '@builtin(position) fragPos');
   });
 
   model._boundsPoly = vtkPolyData.newInstance();