@kitware/vtk.js 22.2.2 → 22.4.1

package/Rendering/Profiles/Geometry.js

@@ -4,6 +4,7 @@ import '../OpenGL/Actor.js';
 import '../OpenGL/Actor2D.js';
 import '../OpenGL/PolyDataMapper.js';
 import '../OpenGL/PolyDataMapper2D.js';
+import '../OpenGL/ScalarBarActor.js';
 import '../OpenGL/Skybox.js';
 import '../OpenGL/Texture.js';
 import '../OpenGL/PixelSpaceCallbackMapper.js';
@@ -11,5 +12,6 @@ import '../WebGPU/Camera.js';
 import '../WebGPU/Renderer.js';
 import '../WebGPU/Actor.js';
 import '../WebGPU/PolyDataMapper.js';
+import '../WebGPU/ScalarBarActor.js';
 import '../WebGPU/Texture.js';
 import '../WebGPU/PixelSpaceCallbackMapper.js';

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/Glyph3DMapper.js

@@ -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

@@ -290,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 */
 
@@ -316,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

@@ -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
@@ -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

@@ -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

@@ -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,
@@ -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,

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

@@ -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/Profiles/All.js

@@ -2,6 +2,7 @@ import '../Camera.js';
 import '../Renderer.js';
 import '../Actor.js';
 import '../PolyDataMapper.js';
+import '../ScalarBarActor.js';
 import '../Texture.js';
 import '../Glyph3DMapper.js';
 import '../ImageMapper.js';

package/Rendering/WebGPU/Profiles/Geometry.js

@@ -2,5 +2,6 @@ import '../Camera.js';
 import '../Renderer.js';
 import '../Actor.js';
 import '../PolyDataMapper.js';
+import '../ScalarBarActor.js';
 import '../Texture.js';
 import '../PixelSpaceCallbackMapper.js';

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);

package/Rendering/WebGPU/Renderer.js

@@ -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/ScalarBarActor.js

@@ -0,0 +1,61 @@
+import { newInstance as newInstance$1 } from '../../macros.js';
+import vtkScalarBarActor from '../Core/ScalarBarActor.js';
+import vtkViewNode from '../SceneGraph/ViewNode.js';
+import { registerOverride } from './ViewNodeFactory.js';
+
+// vtkWebGPUScalarBarActor methods
+// ----------------------------------------------------------------------------
+
+function vtkWebGPUScalarBarActor(publicAPI, model) {
+  model.classHierarchy.push('vtkWebGPUScalarBarActor'); // Builds myself.
+
+  publicAPI.buildPass = function (prepass) {
+    if (prepass) {
+      model.WebGPURenderer = publicAPI.getFirstAncestorOfType('vtkWebGPURenderer');
+      model.WebGPURenderWindow = model.WebGPURenderer.getParent();
+
+      if (!model.scalarBarActorHelper.getRenderable()) {
+        model.scalarBarActorHelper.setRenderable(model.renderable);
+      }
+
+      publicAPI.prepareNodes();
+      publicAPI.addMissingNode(model.scalarBarActorHelper.getBarActor());
+      publicAPI.addMissingNode(model.scalarBarActorHelper.getTmActor());
+      publicAPI.removeUnusedNodes();
+    }
+  };
+
+  publicAPI.opaquePass = function (prepass, renderPass) {
+    if (prepass) {
+      var camera = model.WebGPURenderer ? model.WebGPURenderer.getRenderable().getActiveCamera() : null;
+      var tsize = model.WebGPURenderer.getTiledSizeAndOrigin();
+      model.scalarBarActorHelper.updateAPISpecificData([tsize.usize, tsize.vsize], camera, model.WebGPURenderWindow.getRenderable());
+    }
+  };
+} // ----------------------------------------------------------------------------
+// Object factory
+// ----------------------------------------------------------------------------
+
+
+var DEFAULT_VALUES = {}; // ----------------------------------------------------------------------------
+
+function extend(publicAPI, model) {
+  var initialValues = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {};
+  Object.assign(model, DEFAULT_VALUES, initialValues); // Inheritance
+
+  vtkViewNode.extend(publicAPI, model, initialValues);
+  model.scalarBarActorHelper = vtkScalarBarActor.newScalarBarActorHelper(); // Object methods
+
+  vtkWebGPUScalarBarActor(publicAPI, model);
+} // ----------------------------------------------------------------------------
+
+var newInstance = newInstance$1(extend, 'vtkWebGPUScalarBarActor'); // ----------------------------------------------------------------------------
+
+var index = {
+  newInstance: newInstance,
+  extend: extend
+}; // Register ourself to WebGPU backend if imported
+
+registerOverride('vtkScalarBarActor', newInstance);
+
+export { index as default, extend, newInstance };