@kitware/vtk.js 22.2.0 → 22.3.0

package/Rendering/OpenGL/RenderWindow.js

@@ -816,6 +816,12 @@ function vtkOpenGLRenderWindow(publicAPI, model) {
     return true;
   };
 
+  publicAPI.createSelector = function () {
+    var ret = vtkHardwareSelector.newInstance();
+    ret.setOpenGLRenderWindow(publicAPI);
+    return ret;
+  };
+
   publicAPI.delete = macro.chain(publicAPI.delete, publicAPI.setViewStream, deleteGLContext);
 } // ----------------------------------------------------------------------------
 // Object factory

package/Rendering/SceneGraph/RenderWindowViewNode.js

@@ -123,6 +123,11 @@ function vtkRenderWindowViewNode(publicAPI, model) {
     macro.vtkErrorMacro('not implemented');
     return undefined;
   };
+
+  publicAPI.createSelector = function () {
+    macro.vtkErrorMacro('not implemented');
+    return undefined;
+  };
 } // ----------------------------------------------------------------------------
 // Object factory
 // ----------------------------------------------------------------------------

package/Rendering/WebGPU/BindGroup.js

@@ -66,7 +66,8 @@ function vtkWebGPUBindGroup(publicAPI, model) {
 
     model.bindGroup = device.getHandle().createBindGroup({
       layout: publicAPI.getBindGroupLayout(device),
-      entries: entries
+      entries: entries,
+      label: model.label
     });
     model.bindGroupTime.modified();
     return model.bindGroup;
@@ -74,7 +75,7 @@ function vtkWebGPUBindGroup(publicAPI, model) {
 
   publicAPI.getShaderCode = function (pipeline) {
     var lines = [];
-    var bgroup = pipeline.getBindGroupLayoutCount(model.name);
+    var bgroup = pipeline.getBindGroupLayoutCount(model.label);
 
     for (var i = 0; i < model.bindables.length; i++) {
       lines.push(model.bindables[i].getShaderCode(i, bgroup));
@@ -90,7 +91,7 @@ function vtkWebGPUBindGroup(publicAPI, model) {
 var DEFAULT_VALUES = {
   device: null,
   handle: null,
-  name: null
+  label: null
 }; // ----------------------------------------------------------------------------
 
 function extend(publicAPI, model) {
@@ -104,7 +105,7 @@ function extend(publicAPI, model) {
     mtime: 0
   });
   macro.get(publicAPI, model, ['bindGroupTime', 'handle', 'sizeInBytes', 'usage']);
-  macro.setGet(publicAPI, model, ['name', 'device', 'arrayInformation', 'sourceTime']);
+  macro.setGet(publicAPI, model, ['label', 'device', 'arrayInformation', 'sourceTime']);
   vtkWebGPUBindGroup(publicAPI, model);
 } // ----------------------------------------------------------------------------
 

package/Rendering/WebGPU/Buffer.js

@@ -41,7 +41,8 @@ function vtkWebGPUBuffer(publicAPI, model) {
   publicAPI.create = function (sizeInBytes, usage) {
     model.handle = model.device.getHandle().createBuffer({
       size: sizeInBytes,
-      usage: usage
+      usage: usage,
+      label: model.label
     });
     model.sizeInBytes = sizeInBytes;
     model.usage = usage;
@@ -55,7 +56,8 @@ function vtkWebGPUBuffer(publicAPI, model) {
     model.handle = model.device.getHandle().createBuffer({
       size: data.byteLength,
       usage: usage,
-      mappedAtCreation: true
+      mappedAtCreation: true,
+      label: model.label
     });
     model.sizeInBytes = data.byteLength;
     model.usage = usage;
@@ -88,6 +90,7 @@ var DEFAULT_VALUES = {
   strideInBytes: 0,
   arrayInformation: null,
   usage: null,
+  label: null,
   sourceTime: null
 }; // ----------------------------------------------------------------------------
 
@@ -97,7 +100,7 @@ function extend(publicAPI, model) {
 
   macro.obj(publicAPI, model);
   macro.get(publicAPI, model, ['handle', 'sizeInBytes', 'usage']);
-  macro.setGet(publicAPI, model, ['strideInBytes', 'device', 'arrayInformation', 'sourceTime']);
+  macro.setGet(publicAPI, model, ['strideInBytes', 'device', 'arrayInformation', 'label', 'sourceTime']);
   vtkWebGPUBuffer(publicAPI, model);
 } // ----------------------------------------------------------------------------
 

package/Rendering/WebGPU/BufferManager.js

@@ -406,7 +406,9 @@ function vtkWebGPUBufferManager(publicAPI, model) {
     } // create one
 
 
-    var buffer = vtkWebGPUBuffer.newInstance();
+    var buffer = vtkWebGPUBuffer.newInstance({
+      label: req.label
+    });
     buffer.setDevice(model.device);
     var gpuUsage = null; // handle uniform buffers
 

package/Rendering/WebGPU/Device.js

@@ -83,7 +83,7 @@ function vtkWebGPUDevice(publicAPI, model) {
   };
 
   publicAPI.createPipeline = function (hash, pipeline) {
-    pipeline.initialize(publicAPI);
+    pipeline.initialize(publicAPI, hash);
     model.pipelines[hash] = pipeline;
   };
 

package/Rendering/WebGPU/FullScreenQuad.js

@@ -11,7 +11,7 @@ function vtkWebGPUFullScreenQuad(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.tcoordVS = vec2<f32>(vertexBC.x * 0.5 + 0.5, 1.0 - vertexBC.y * 0.5 - 0.5);', 'output.Position = vec4<f32>(vertexBC, 1.0);']).result;
     vDesc.setCode(code);

package/Rendering/WebGPU/Glyph3DMapper.js

@@ -21,8 +21,8 @@ function vtkWebGPUGlyph3DMapper(publicAPI, model) {
 
   publicAPI.replaceShaderPosition = function (hash, pipeline, vertexInput) {
     var vDesc = pipeline.getShaderDescription('vertex');
-    vDesc.addBuiltinInput('u32', '[[builtin(instance_index)]] instanceIndex');
-    vDesc.addBuiltinOutput('vec4<f32>', '[[builtin(position)]] Position');
+    vDesc.addBuiltinInput('u32', '@builtin(instance_index) instanceIndex');
+    vDesc.addBuiltinOutput('vec4<f32>', '@builtin(position) Position');
     var code = vDesc.getCode();
     code = vtkWebGPUShaderCache.substitute(code, '//VTK::Position::Impl', ['    output.Position = rendererUBO.SCPCMatrix*mapperUBO.BCSCMatrix', '      *glyphSSBO.values[input.instanceIndex].matrix', '      *vertexBC;']).result;
     vDesc.setCode(code);
@@ -126,8 +126,9 @@ function extend(publicAPI, model) {
   obj(model.glyphBOBuildTime, {
     mtime: 0
   });
-  model.SSBO = vtkWebGPUStorageBuffer.newInstance();
-  model.SSBO.setName('glyphSSBO'); // Object methods
+  model.SSBO = vtkWebGPUStorageBuffer.newInstance({
+    label: 'glyphSSBO'
+  }); // Object methods
 
   vtkWebGPUGlyph3DMapper(publicAPI, model);
 

package/Rendering/WebGPU/HardwareSelectionPass.js

@@ -25,7 +25,9 @@ function vtkWebGPUHardwareSelectionPass(publicAPI, model) {
     if (!model.selectionRenderEncoder) {
       publicAPI.createRenderEncoder(); // create color texture
 
-      model.colorTexture = vtkWebGPUTexture.newInstance();
+      model.colorTexture = vtkWebGPUTexture.newInstance({
+        label: 'hardwareSelectorColor'
+      });
       model.colorTexture.create(device, {
         width: viewNode.getCanvas().width,
         height: viewNode.getCanvas().height,
@@ -36,11 +38,12 @@ function vtkWebGPUHardwareSelectionPass(publicAPI, model) {
         /* eslint-disable no-bitwise */
         usage: GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.COPY_SRC
       });
-      var v1 = model.colorTexture.createView();
-      v1.setName('hardwareSelectColorTexture');
+      var v1 = model.colorTexture.createView('hardwareSelectColorTexture');
       model.selectionRenderEncoder.setColorTextureView(0, v1); // create depth texture
 
-      model.depthTexture = vtkWebGPUTexture.newInstance();
+      model.depthTexture = vtkWebGPUTexture.newInstance({
+        label: 'hardwareSelectorDepth'
+      });
       model.depthTexture.create(device, {
         width: viewNode.getCanvas().width,
         height: viewNode.getCanvas().height,
@@ -51,8 +54,7 @@ function vtkWebGPUHardwareSelectionPass(publicAPI, model) {
         /* eslint-disable no-bitwise */
         usage: GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.COPY_SRC
       });
-      var v2 = model.depthTexture.createView();
-      v2.setName('hardwareSelectDepthTexture');
+      var v2 = model.depthTexture.createView('hardwareSelectDepthTexture');
       model.selectionRenderEncoder.setDepthTextureView(v2);
     } else {
       model.colorTexture.resize(viewNode.getCanvas().width, viewNode.getCanvas().height);
@@ -69,7 +71,9 @@ function vtkWebGPUHardwareSelectionPass(publicAPI, model) {
   };
 
   publicAPI.createRenderEncoder = function () {
-    model.selectionRenderEncoder = vtkWebGPURenderEncoder.newInstance(); // default settings are fine for this
+    model.selectionRenderEncoder = vtkWebGPURenderEncoder.newInstance({
+      label: 'HardwareSelectionPass'
+    }); // default settings are fine for this
 
     model.selectionRenderEncoder.setPipelineHash('sel');
     model.selectionRenderEncoder.setReplaceShaderCodeFunction(function (pipeline) {

package/Rendering/WebGPU/HardwareSelector.js

@@ -278,6 +278,7 @@ function vtkWebGPUHardwareSelector(publicAPI, model) {
               // result object (by value in most cases)
 
               result = {
+                area: [0, 0, texture.getWidth() - 1, texture.getHeight() - 1],
                 captureZValues: model.captureZValues,
                 fieldAssociation: model.fieldAssociation,
                 renderer: renderer,
@@ -289,7 +290,9 @@ function vtkWebGPUHardwareSelector(publicAPI, model) {
 
               result.colorBufferWidth = 16 * Math.floor((result.width + 15) / 16);
               result.colorBufferSizeInBytes = result.colorBufferWidth * result.height * 4 * 4;
-              colorBuffer = vtkWebGPUBuffer.newInstance();
+              colorBuffer = vtkWebGPUBuffer.newInstance({
+                label: 'hardwareSelectColorBuffer'
+              });
               colorBuffer.setDevice(device);
               /* eslint-disable no-bitwise */
 
@@ -315,7 +318,9 @@ function vtkWebGPUHardwareSelector(publicAPI, model) {
 
               if (model.captureZValues) {
                 result.zbufferBufferWidth = 64 * Math.floor((result.width + 63) / 64);
-                zbuffer = vtkWebGPUBuffer.newInstance();
+                zbuffer = vtkWebGPUBuffer.newInstance({
+                  label: 'hardwareSelectDepthBuffer'
+                });
                 zbuffer.setDevice(device);
                 result.zbufferSizeInBytes = result.height * result.zbufferBufferWidth * 4;
                 /* eslint-disable no-bitwise */

package/Rendering/WebGPU/ImageMapper.js

@@ -11,7 +11,7 @@ import { InterpolationType } from '../Core/ImageProperty/Constants.js';
 import { registerOverride } from './ViewNodeFactory.js';
 
 var SlicingMode = Constants.SlicingMode;
-var imgFragTemplate = "\n//VTK::Renderer::Dec\n\n//VTK::Mapper::Dec\n\n//VTK::TCoord::Dec\n\n//VTK::Image::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  //VTK::Image::Sample\n\n  // var computedColor: vec4<f32> = vec4<f32>(1.0,0.7, 0.5, 1.0);\n\n//VTK::RenderEncoder::Impl\n\n  return output;\n}\n"; // ----------------------------------------------------------------------------
+var imgFragTemplate = "\n//VTK::Renderer::Dec\n\n//VTK::Mapper::Dec\n\n//VTK::TCoord::Dec\n\n//VTK::Image::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  //VTK::Image::Sample\n\n  // var computedColor: vec4<f32> = vec4<f32>(1.0,0.7, 0.5, 1.0);\n\n//VTK::RenderEncoder::Impl\n\n  return output;\n}\n"; // ----------------------------------------------------------------------------
 // helper methods
 // ----------------------------------------------------------------------------
 
@@ -258,8 +258,7 @@ function vtkWebGPUImageMapper(publicAPI, model) {
           format: 'rgba8unorm'
         };
         var newTex = device.getTextureManager().getTexture(treq);
-        var tview = newTex.createView();
-        tview.setName('tfunTexture');
+        var tview = newTex.createView('tfunTexture');
         var tViews = model.helper.getTextureViews();
         tViews[1] = tview;
       }
@@ -276,8 +275,7 @@ function vtkWebGPUImageMapper(publicAPI, model) {
     var tViews = model.helper.getTextureViews();
 
     if (!tViews[0] || tViews[0].getTexture() !== newTex) {
-      var tview = newTex.createView();
-      tview.setName("imgTexture");
+      var tview = newTex.createView('imgTexture');
       tViews[0] = tview;
     }
 
@@ -293,8 +291,9 @@ function vtkWebGPUImageMapper(publicAPI, model) {
     var iType = actorProperty.getInterpolationType() === InterpolationType.NEAREST ? 'nearest' : 'linear';
 
     if (!model.clampSampler || iType !== model.clampSampler.getOptions().minFilter) {
-      model.clampSampler = vtkWebGPUSampler.newInstance();
-      model.clampSampler.setName('clampSampler');
+      model.clampSampler = vtkWebGPUSampler.newInstance({
+        label: 'clampSampler'
+      });
       model.clampSampler.create(device, {
         minFilter: iType,
         magFilter: iType
@@ -318,7 +317,7 @@ function vtkWebGPUImageMapper(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();
     var lines = ['var pos: vec4<f32> = mapperUBO.Origin +', '   (vertexBC.x * 0.5 + 0.5) * mapperUBO.Axis1 + (vertexBC.y * 0.5 + 0.5) * mapperUBO.Axis2;', 'pos.w = 1.0;'];
 
@@ -389,8 +388,9 @@ function extend(publicAPI, model) {
   vtkViewNode.extend(publicAPI, model, initialValues);
   model.helper = vtkWebGPUFullScreenQuad.newInstance();
   model.helper.setFragmentShaderTemplate(imgFragTemplate);
-  model.UBO = vtkWebGPUUniformBuffer.newInstance();
-  model.UBO.setName('mapperUBO');
+  model.UBO = vtkWebGPUUniformBuffer.newInstance({
+    label: 'mapperUBO'
+  });
   model.UBO.addEntry('SCTCMatrix', 'mat4x4<f32>');
   model.UBO.addEntry('Origin', 'vec4<f32>');
   model.UBO.addEntry('Axis2', 'vec4<f32>');
@@ -398,10 +398,12 @@ function extend(publicAPI, model) {
   model.UBO.addEntry('cScale', 'vec4<f32>');
   model.UBO.addEntry('cShift', 'vec4<f32>');
   model.helper.setUBO(model.UBO);
-  model.SSBO = vtkWebGPUStorageBuffer.newInstance();
-  model.SSBO.setName('volumeSSBO');
-  model.componentSSBO = vtkWebGPUStorageBuffer.newInstance();
-  model.componentSSBO.setName('componentSSBO');
+  model.SSBO = vtkWebGPUStorageBuffer.newInstance({
+    label: 'volumeSSBO'
+  });
+  model.componentSSBO = vtkWebGPUStorageBuffer.newInstance({
+    label: 'componentSSBO'
+  });
   model.lutBuildTime = {};
   obj(model.lutBuildTime, {
     mtime: 0

package/Rendering/WebGPU/MapperHelper.js

@@ -6,8 +6,8 @@ import vtkWebGPUShaderCache from './ShaderCache.js';
 import vtkWebGPUShaderDescription from './ShaderDescription.js';
 import vtkWebGPUVertexInput from './VertexInput.js';
 
-var vtkWebGPUMapperHelperVS = "\n//VTK::Renderer::Dec\n\n//VTK::Color::Dec\n\n//VTK::Normal::Dec\n\n//VTK::TCoord::Dec\n\n//VTK::Select::Dec\n\n//VTK::Mapper::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 vertex: vec4<f32> = vertexBC;\n\n  //VTK::Color::Impl\n\n  //VTK::Normal::Impl\n\n  //VTK::TCoord::Impl\n\n  //VTK::Select::Impl\n\n  //VTK::Position::Impl\n\n  return output;\n}\n";
-var vtkWebGPUMapperHelperFS = "\n//VTK::Renderer::Dec\n\n//VTK::Color::Dec\n\n//VTK::Normal::Dec\n\n//VTK::TCoord::Dec\n\n//VTK::Select::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::Color::Impl\n\n  //VTK::Normal::Impl\n\n  //VTK::Light::Impl\n\n  //VTK::TCoord::Impl\n\n  //VTK::Select::Impl\n\n  // var computedColor:vec4<f32> = vec4<f32>(1.0,0.5,0.5,1.0);\n\n  //VTK::RenderEncoder::Impl\n  return output;\n}\n"; // ----------------------------------------------------------------------------
+var vtkWebGPUMapperHelperVS = "\n//VTK::Renderer::Dec\n\n//VTK::Color::Dec\n\n//VTK::Normal::Dec\n\n//VTK::TCoord::Dec\n\n//VTK::Select::Dec\n\n//VTK::Mapper::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 vertex: vec4<f32> = vertexBC;\n\n  //VTK::Color::Impl\n\n  //VTK::Normal::Impl\n\n  //VTK::TCoord::Impl\n\n  //VTK::Select::Impl\n\n  //VTK::Position::Impl\n\n  return output;\n}\n";
+var vtkWebGPUMapperHelperFS = "\n//VTK::Renderer::Dec\n\n//VTK::Color::Dec\n\n//VTK::Normal::Dec\n\n//VTK::TCoord::Dec\n\n//VTK::Select::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::Color::Impl\n\n  //VTK::Normal::Impl\n\n  //VTK::Light::Impl\n\n  //VTK::TCoord::Impl\n\n  //VTK::Select::Impl\n\n  // var computedColor:vec4<f32> = vec4<f32>(1.0,0.5,0.5,1.0);\n\n  //VTK::RenderEncoder::Impl\n  return output;\n}\n"; // ----------------------------------------------------------------------------
 // vtkWebGPUMapperHelper methods
 // ----------------------------------------------------------------------------
 
@@ -94,7 +94,7 @@ function vtkWebGPUMapperHelper(publicAPI, model) {
     code = vtkWebGPUShaderCache.substitute(code, '//VTK::Mapper::Dec', [ubocode]).result;
     vDesc.setCode(code);
     var fDesc = pipeline.getShaderDescription('fragment');
-    fDesc.addBuiltinInput('bool', '[[builtin(front_facing)]] frontFacing');
+    fDesc.addBuiltinInput('bool', '@builtin(front_facing) frontFacing');
     code = fDesc.getCode();
     code = vtkWebGPUShaderCache.substitute(code, '//VTK::Mapper::Dec', [ubocode]).result;
     fDesc.setCode(code);
@@ -104,7 +104,7 @@ function vtkWebGPUMapperHelper(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.SCPCMatrix*vertexBC;']).result;
     vDesc.setCode(code);
@@ -230,8 +230,9 @@ function extend(publicAPI, model) {
   macro.obj(publicAPI, model);
   model.textureViews = [];
   model.vertexInput = vtkWebGPUVertexInput.newInstance();
-  model.bindGroup = vtkWebGPUBindGroup.newInstance();
-  model.bindGroup.setName('mapperBG');
+  model.bindGroup = vtkWebGPUBindGroup.newInstance({
+    label: 'mapperBG'
+  });
   model.additionalBindables = [];
   model.fragmentShaderTemplate = model.fragmentShaderTemplate || vtkWebGPUMapperHelperFS;
   model.vertexShaderTemplate = model.vertexShaderTemplate || vtkWebGPUMapperHelperVS;

package/Rendering/WebGPU/OpaquePass.js

@@ -21,7 +21,9 @@ function vtkWebGPUOpaquePass(publicAPI, model) {
 
     if (!model.renderEncoder) {
       publicAPI.createRenderEncoder();
-      model.colorTexture = vtkWebGPUTexture.newInstance();
+      model.colorTexture = vtkWebGPUTexture.newInstance({
+        label: 'opaquePassColor'
+      });
       model.colorTexture.create(device, {
         width: viewNode.getCanvas().width,
         height: viewNode.getCanvas().height,
@@ -32,19 +34,19 @@ function vtkWebGPUOpaquePass(publicAPI, model) {
         /* eslint-disable no-bitwise */
         usage: GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING | GPUTextureUsage.COPY_SRC
       });
-      var ctView = model.colorTexture.createView();
-      ctView.setName('opaquePassColorTexture');
+      var ctView = model.colorTexture.createView('opaquePassColorTexture');
       model.renderEncoder.setColorTextureView(0, ctView);
       model.depthFormat = 'depth32float';
-      model.depthTexture = vtkWebGPUTexture.newInstance();
+      model.depthTexture = vtkWebGPUTexture.newInstance({
+        label: 'opaquePassDepth'
+      });
       model.depthTexture.create(device, {
         width: viewNode.getCanvas().width,
         height: viewNode.getCanvas().height,
         format: model.depthFormat,
         usage: GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING | GPUTextureUsage.COPY_SRC
       });
-      var dView = model.depthTexture.createView();
-      dView.setName('opaquePassDepthTexture');
+      var dView = model.depthTexture.createView('opaquePassDepthTexture');
       model.renderEncoder.setDepthTextureView(dView);
     } else {
       model.colorTexture.resize(viewNode.getCanvas().width, viewNode.getCanvas().height);
@@ -66,7 +68,9 @@ function vtkWebGPUOpaquePass(publicAPI, model) {
   };
 
   publicAPI.createRenderEncoder = function () {
-    model.renderEncoder = vtkWebGPURenderEncoder.newInstance(); // default settings are fine for this
+    model.renderEncoder = vtkWebGPURenderEncoder.newInstance({
+      label: 'OpaquePass'
+    }); // default settings are fine for this
 
     model.renderEncoder.setPipelineHash('op');
   };

package/Rendering/WebGPU/OrderIndependentTranslucentPass.js

@@ -5,7 +5,7 @@ import vtkWebGPUShaderCache from './ShaderCache.js';
 import vtkRenderPass from '../SceneGraph/RenderPass.js';
 import vtkWebGPUFullScreenQuad from './FullScreenQuad.js';
 
-var oitpFragTemplate = "\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 tcoord: vec2<i32> = vec2<i32>(i32(input.fragPos.x), i32(input.fragPos.y));\n  var reveal: f32 = textureLoad(oitpAccumTexture, tcoord, 0).r;\n  if (reveal == 1.0) { discard; }\n  var tcolor: vec4<f32> = textureLoad(oitpColorTexture, tcoord, 0);\n  var total: f32 = max(tcolor.a, 0.01);\n  var computedColor: vec4<f32> = vec4<f32>(tcolor.r/total, tcolor.g/total, tcolor.b/total, 1.0 - reveal);\n\n  //VTK::RenderEncoder::Impl\n  return output;\n}\n";
+var oitpFragTemplate = "\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 tcoord: vec2<i32> = vec2<i32>(i32(input.fragPos.x), i32(input.fragPos.y));\n  var reveal: f32 = textureLoad(oitpAccumTexture, tcoord, 0).r;\n  if (reveal == 1.0) { discard; }\n  var tcolor: vec4<f32> = textureLoad(oitpColorTexture, tcoord, 0);\n  var total: f32 = max(tcolor.a, 0.01);\n  var computedColor: vec4<f32> = vec4<f32>(tcolor.r/total, tcolor.g/total, tcolor.b/total, 1.0 - reveal);\n\n  //VTK::RenderEncoder::Impl\n  return output;\n}\n";
 
 function vtkWebGPUOrderIndependentTranslucentPass(publicAPI, model) {
   // Set our className
@@ -26,7 +26,9 @@ function vtkWebGPUOrderIndependentTranslucentPass(publicAPI, model) {
     if (!model.translucentRenderEncoder) {
       publicAPI.createRenderEncoder();
       publicAPI.createFinalEncoder();
-      model.translucentColorTexture = vtkWebGPUTexture.newInstance();
+      model.translucentColorTexture = vtkWebGPUTexture.newInstance({
+        label: 'translucentPassColor'
+      });
       model.translucentColorTexture.create(device, {
         width: viewNode.getCanvas().width,
         height: viewNode.getCanvas().height,
@@ -37,10 +39,11 @@ function vtkWebGPUOrderIndependentTranslucentPass(publicAPI, model) {
         /* eslint-disable no-bitwise */
         usage: GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING
       });
-      var v1 = model.translucentColorTexture.createView();
-      v1.setName('oitpColorTexture');
+      var v1 = model.translucentColorTexture.createView('oitpColorTexture');
       model.translucentRenderEncoder.setColorTextureView(0, v1);
-      model.translucentAccumulateTexture = vtkWebGPUTexture.newInstance();
+      model.translucentAccumulateTexture = vtkWebGPUTexture.newInstance({
+        label: 'translucentPassAccumulate'
+      });
       model.translucentAccumulateTexture.create(device, {
         width: viewNode.getCanvas().width,
         height: viewNode.getCanvas().height,
@@ -51,8 +54,7 @@ function vtkWebGPUOrderIndependentTranslucentPass(publicAPI, model) {
         /* eslint-disable no-bitwise */
         usage: GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING
       });
-      var v2 = model.translucentAccumulateTexture.createView();
-      v2.setName('oitpAccumTexture');
+      var v2 = model.translucentAccumulateTexture.createView('oitpAccumTexture');
       model.translucentRenderEncoder.setColorTextureView(1, v2);
       model.fullScreenQuad = vtkWebGPUFullScreenQuad.newInstance();
       model.fullScreenQuad.setDevice(viewNode.getDevice());
@@ -88,7 +90,9 @@ function vtkWebGPUOrderIndependentTranslucentPass(publicAPI, model) {
   };
 
   publicAPI.createRenderEncoder = function () {
-    model.translucentRenderEncoder = vtkWebGPURenderEncoder.newInstance();
+    model.translucentRenderEncoder = vtkWebGPURenderEncoder.newInstance({
+      label: 'translucentRender'
+    });
     var rDesc = model.translucentRenderEncoder.getDescription();
     rDesc.colorAttachments = [{
       view: undefined,
@@ -110,7 +114,7 @@ function vtkWebGPUOrderIndependentTranslucentPass(publicAPI, model) {
       var fDesc = pipeline.getShaderDescription('fragment');
       fDesc.addOutput('vec4<f32>', 'outColor');
       fDesc.addOutput('f32', 'outAccum');
-      fDesc.addBuiltinInput('vec4<f32>', '[[builtin(position)]] fragPos');
+      fDesc.addBuiltinInput('vec4<f32>', '@builtin(position) fragPos');
       var code = fDesc.getCode();
       code = vtkWebGPUShaderCache.substitute(code, '//VTK::RenderEncoder::Impl', [// very simple depth weighting in w
       'var w: f32 = 1.0 - input.fragPos.z * 0.9;', 'output.outColor = vec4<f32>(computedColor.rgb*computedColor.a, computedColor.a) * w;', 'output.outAccum = computedColor.a;']).result;
@@ -157,7 +161,9 @@ function vtkWebGPUOrderIndependentTranslucentPass(publicAPI, model) {
   };
 
   publicAPI.createFinalEncoder = function () {
-    model.translucentFinalEncoder = vtkWebGPURenderEncoder.newInstance();
+    model.translucentFinalEncoder = vtkWebGPURenderEncoder.newInstance({
+      label: 'translucentFinal'
+    });
     model.translucentFinalEncoder.setDescription({
       colorAttachments: [{
         view: null,
@@ -168,7 +174,7 @@ function vtkWebGPUOrderIndependentTranslucentPass(publicAPI, model) {
     model.translucentFinalEncoder.setReplaceShaderCodeFunction(function (pipeline) {
       var fDesc = pipeline.getShaderDescription('fragment');
       fDesc.addOutput('vec4<f32>', 'outColor');
-      fDesc.addBuiltinInput('vec4<f32>', '[[builtin(position)]] fragPos');
+      fDesc.addBuiltinInput('vec4<f32>', '@builtin(position) fragPos');
       var code = fDesc.getCode();
       code = vtkWebGPUShaderCache.substitute(code, '//VTK::RenderEncoder::Impl', ['output.outColor = vec4<f32>(computedColor.rgb*computedColor.a, computedColor.a);']).result;
       fDesc.setCode(code);

package/Rendering/WebGPU/Pipeline.js

@@ -11,11 +11,12 @@ function vtkWebGPUPipeline(publicAPI, model) {
     return model.shaderDescriptions;
   };
 
-  publicAPI.initialize = function (device) {
+  publicAPI.initialize = function (device, hash) {
     // start with the renderencoder settings
     model.pipelineDescription = model.renderEncoder.getPipelineSettings();
     model.pipelineDescription.primitive.topology = model.topology;
-    model.pipelineDescription.vertex = model.vertexState; // add in bind group layouts
+    model.pipelineDescription.vertex = model.vertexState;
+    model.pipelineDescription.label = hash; // add in bind group layouts
 
     var bindGroupLayouts = [];
 
@@ -61,7 +62,7 @@ function vtkWebGPUPipeline(publicAPI, model) {
 
     model.layouts.push({
       layout: bindGroup.getBindGroupLayout(model.device),
-      name: bindGroup.getName()
+      label: bindGroup.getLabel()
     });
   };
 
@@ -69,9 +70,9 @@ function vtkWebGPUPipeline(publicAPI, model) {
     return model.layouts[idx].layout;
   };
 
-  publicAPI.getBindGroupLayoutCount = function (lname) {
+  publicAPI.getBindGroupLayoutCount = function (llabel) {
     for (var i = 0; i < model.layouts.length; i++) {
-      if (model.layouts[i].name === lname) {
+      if (model.layouts[i].label === llabel) {
         return i;
       }
     }

package/Rendering/WebGPU/PolyDataMapper.js

@@ -20,8 +20,8 @@ var StartEvent = {
 var EndEvent = {
   type: 'EndEvent'
 };
-var vtkWebGPUPolyDataVS = "\n//VTK::Renderer::Dec\n\n//VTK::Color::Dec\n\n//VTK::Normal::Dec\n\n//VTK::TCoord::Dec\n\n//VTK::Select::Dec\n\n//VTK::Mapper::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 vertex: vec4<f32> = vertexBC;\n\n  //VTK::Color::Impl\n\n  //VTK::Normal::Impl\n\n  //VTK::TCoord::Impl\n\n  //VTK::Select::Impl\n\n  //VTK::Position::Impl\n\n  return output;\n}\n";
-var vtkWebGPUPolyDataFS = "\n//VTK::Renderer::Dec\n\n//VTK::Color::Dec\n\n// optional surface normal declaration\n//VTK::Normal::Dec\n\n//VTK::TCoord::Dec\n\n//VTK::Select::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  var ambientColor: vec4<f32> = mapperUBO.AmbientColor;\n  var diffuseColor: vec4<f32> = mapperUBO.DiffuseColor;\n  var opacity: f32 = mapperUBO.Opacity;\n\n  //VTK::Color::Impl\n\n  //VTK::Normal::Impl\n\n  //VTK::Light::Impl\n\n  var computedColor: vec4<f32> = vec4<f32>(ambientColor.rgb * mapperUBO.AmbientIntensity\n     + diffuse * mapperUBO.DiffuseIntensity\n     + specular * mapperUBO.SpecularIntensity,\n     opacity);\n\n  //VTK::TCoord::Impl\n\n  //VTK::Select::Impl\n\n  if (computedColor.a == 0.0) { discard; };\n\n  //VTK::Position::Impl\n\n  //VTK::RenderEncoder::Impl\n  return output;\n}\n";
+var vtkWebGPUPolyDataVS = "\n//VTK::Renderer::Dec\n\n//VTK::Color::Dec\n\n//VTK::Normal::Dec\n\n//VTK::TCoord::Dec\n\n//VTK::Select::Dec\n\n//VTK::Mapper::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 vertex: vec4<f32> = vertexBC;\n\n  //VTK::Color::Impl\n\n  //VTK::Normal::Impl\n\n  //VTK::TCoord::Impl\n\n  //VTK::Select::Impl\n\n  //VTK::Position::Impl\n\n  return output;\n}\n";
+var vtkWebGPUPolyDataFS = "\n//VTK::Renderer::Dec\n\n//VTK::Color::Dec\n\n// optional surface normal declaration\n//VTK::Normal::Dec\n\n//VTK::TCoord::Dec\n\n//VTK::Select::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  var ambientColor: vec4<f32> = mapperUBO.AmbientColor;\n  var diffuseColor: vec4<f32> = mapperUBO.DiffuseColor;\n  var opacity: f32 = mapperUBO.Opacity;\n\n  //VTK::Color::Impl\n\n  //VTK::Normal::Impl\n\n  //VTK::Light::Impl\n\n  var computedColor: vec4<f32> = vec4<f32>(ambientColor.rgb * mapperUBO.AmbientIntensity\n     + diffuse * mapperUBO.DiffuseIntensity\n     + specular * mapperUBO.SpecularIntensity,\n     opacity);\n\n  //VTK::TCoord::Impl\n\n  //VTK::Select::Impl\n\n  if (computedColor.a == 0.0) { discard; };\n\n  //VTK::Position::Impl\n\n  //VTK::RenderEncoder::Impl\n  return output;\n}\n";
 
 function isEdges(hash) {
   // edge pipelines have "edge" in them
@@ -104,11 +104,11 @@ function vtkWebGPUPolyDataMapper(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();
 
     if (isEdges(hash)) {
-      vDesc.addBuiltinInput('u32', '[[builtin(instance_index)]] instanceIndex'); // widen the edge
+      vDesc.addBuiltinInput('u32', '@builtin(instance_index) instanceIndex'); // widen the edge
 
       code = vtkWebGPUShaderCache.substitute(code, '//VTK::Position::Impl', ['    var tmpPos: vec4<f32> = rendererUBO.SCPCMatrix*mapperUBO.BCSCMatrix*vertexBC;', '    var tmpPos2: vec3<f32> = tmpPos.xyz / tmpPos.w;', '    tmpPos2.x = tmpPos2.x + 1.4*(f32(input.instanceIndex % 2u) - 0.5)/rendererUBO.viewportSize.x;', '    tmpPos2.y = tmpPos2.y + 1.4*(f32(input.instanceIndex / 2u) - 0.5)/rendererUBO.viewportSize.y;', '    tmpPos2.z = tmpPos2.z + 0.00001;', // could become a setting
       '    output.Position = vec4<f32>(tmpPos2.xyz * tmpPos.w, tmpPos.w);']).result;
@@ -419,7 +419,9 @@ function vtkWebGPUPolyDataMapper(publicAPI, model) {
 
     if (idata) {
       if (!model.colorTexture) {
-        model.colorTexture = vtkTexture.newInstance();
+        model.colorTexture = vtkTexture.newInstance({
+          label: 'polyDataColor'
+        });
       }
 
       model.colorTexture.setInputData(idata);
@@ -470,8 +472,7 @@ function vtkWebGPUPolyDataMapper(publicAPI, model) {
 
         if (!found) {
           usedTextures[model.textures.length] = true;
-          var tview = newTex.createView();
-          tview.setName("Texture".concat(usedCount++));
+          var tview = newTex.createView("Texture".concat(usedCount++));
           model.textures.push(newTex);
           model.textureViews.push(tview);
           var interpolate = srcTexture.getInterpolate() ? 'linear' : 'nearest';
@@ -631,8 +632,9 @@ function extend(publicAPI, model) {
   model.tmpMat4 = mat4.identity(new Float64Array(16));
   model.fragmentShaderTemplate = model.fragmentShaderTemplate || vtkWebGPUPolyDataFS;
   model.vertexShaderTemplate = model.vertexShaderTemplate || vtkWebGPUPolyDataVS;
-  model.UBO = vtkWebGPUUniformBuffer.newInstance();
-  model.UBO.setName('mapperUBO');
+  model.UBO = vtkWebGPUUniformBuffer.newInstance({
+    label: 'mapperUBO'
+  });
   model.UBO.addEntry('BCWCMatrix', 'mat4x4<f32>');
   model.UBO.addEntry('BCSCMatrix', 'mat4x4<f32>');
   model.UBO.addEntry('MCWCNormals', 'mat4x4<f32>');

package/Rendering/WebGPU/RenderEncoder.js

@@ -11,9 +11,17 @@ function vtkWebGPURenderEncoder(publicAPI, model) {
 
   publicAPI.begin = function (encoder) {
     model.handle = encoder.beginRenderPass(model.description);
+
+    if (model.label) {
+      model.handle.pushDebugGroup(model.label);
+    }
   };
 
   publicAPI.end = function () {
+    if (model.label) {
+      model.handle.popDebugGroup();
+    }
+
     model.handle.endPass();
   };
 
@@ -65,7 +73,7 @@ function vtkWebGPURenderEncoder(publicAPI, model) {
 
   publicAPI.activateBindGroup = function (bg) {
     var device = model.boundPipeline.getDevice();
-    var midx = model.boundPipeline.getBindGroupLayoutCount(bg.getName());
+    var midx = model.boundPipeline.getBindGroupLayoutCount(bg.getLabel());
     model.handle.setBindGroup(midx, bg.getBindGroup(device)); // verify bind group layout matches
 
     var bgl1 = device.getBindGroupLayoutDescription(bg.getBindGroupLayout(device));
@@ -118,7 +126,8 @@ var DEFAULT_VALUES = {
   pipelineHash: null,
   pipelineSettings: null,
   replaceShaderCodeFunction: null,
-  depthTextureView: null
+  depthTextureView: null,
+  label: null
 }; // ----------------------------------------------------------------------------
 
 function extend(publicAPI, model) {
@@ -177,7 +186,7 @@ function extend(publicAPI, model) {
   };
   model.colorTextureViews = [];
   get(publicAPI, model, ['boundPipeline', 'colorTextureViews']);
-  setGet(publicAPI, model, ['depthTextureView', 'description', 'handle', 'pipelineHash', 'pipelineSettings', 'replaceShaderCodeFunction']); // For more macro methods, see "Sources/macros.js"
+  setGet(publicAPI, model, ['depthTextureView', 'description', 'handle', 'label', 'pipelineHash', 'pipelineSettings', 'replaceShaderCodeFunction']); // For more macro methods, see "Sources/macros.js"
   // Object specific methods
 
   vtkWebGPURenderEncoder(publicAPI, model);