@kitware/vtk.js 22.0.2 → 22.1.0

package/Rendering/Core/RenderWindowInteractor.js

@@ -18,7 +18,7 @@ var vtkWarningMacro = macro.vtkWarningMacro,
 var deviceInputMap = {
   'xr-standard': [Input.Trigger, Input.Grip, Input.TrackPad, Input.Thumbstick, Input.A, Input.B]
 };
-var handledEvents = ['StartAnimation', 'Animation', 'EndAnimation', 'MouseEnter', 'MouseLeave', 'StartMouseMove', 'MouseMove', 'EndMouseMove', 'LeftButtonPress', 'LeftButtonRelease', 'MiddleButtonPress', 'MiddleButtonRelease', 'RightButtonPress', 'RightButtonRelease', 'KeyPress', 'KeyDown', 'KeyUp', 'StartMouseWheel', 'MouseWheel', 'EndMouseWheel', 'StartPinch', 'Pinch', 'EndPinch', 'StartPan', 'Pan', 'EndPan', 'StartRotate', 'Rotate', 'EndRotate', 'Button3D', 'Move3D', 'StartPointerLock', 'EndPointerLock', 'StartInteraction', 'Interaction', 'EndInteraction'];
+var handledEvents = ['StartAnimation', 'Animation', 'EndAnimation', 'MouseEnter', 'MouseLeave', 'StartMouseMove', 'MouseMove', 'EndMouseMove', 'LeftButtonPress', 'LeftButtonRelease', 'MiddleButtonPress', 'MiddleButtonRelease', 'RightButtonPress', 'RightButtonRelease', 'KeyPress', 'KeyDown', 'KeyUp', 'StartMouseWheel', 'MouseWheel', 'EndMouseWheel', 'StartPinch', 'Pinch', 'EndPinch', 'StartPan', 'Pan', 'EndPan', 'StartRotate', 'Rotate', 'EndRotate', 'Button3D', 'Move3D', 'StartPointerLock', 'EndPointerLock', 'StartInteraction', 'Interaction', 'EndInteraction', 'AnimationFrameRateUpdate'];
 
 function preventDefault(event) {
   if (event.cancelable) {
@@ -326,6 +326,8 @@ function vtkRenderWindowInteractor(publicAPI, model) {
     animationRequesters.add(requestor);
 
     if (animationRequesters.size === 1 && !model.xrAnimation) {
+      model._animationStartTime = Date.now();
+      model._animationFrameCount = 0;
       model.lastFrameTime = 0.1;
       model.lastFrameStart = Date.now();
       model.animationRequest = requestAnimationFrame(publicAPI.handleAnimation);
@@ -450,6 +452,14 @@ function vtkRenderWindowInteractor(publicAPI, model) {
 
   publicAPI.handleAnimation = function () {
     var currTime = Date.now();
+    model._animationFrameCount++;
+
+    if (currTime - model._animationStartTime > 1000.0 && model._animationFrameCount > 1) {
+      model.recentAnimationFrameRate = 1000.0 * (model._animationFrameCount - 1) / (currTime - model._animationStartTime);
+      publicAPI.animationFrameRateUpdateEvent();
+      model._animationStartTime = currTime;
+      model._animationFrameCount = 1;
+    }
 
     if (model.FrameTime === -1.0) {
       model.lastFrameTime = 0.1;
@@ -498,7 +508,7 @@ function vtkRenderWindowInteractor(publicAPI, model) {
     model.wheelTimeoutID = setTimeout(function () {
       publicAPI.endMouseWheelEvent();
       model.wheelTimeoutID = 0;
-    }, 200);
+    }, 800);
   };
 
   publicAPI.handleMouseEnter = function (event) {
@@ -924,6 +934,8 @@ function vtkRenderWindowInteractor(publicAPI, model) {
 
   publicAPI.handleVisibilityChange = function () {
     model.lastFrameStart = Date.now();
+    model._animationStartTime = Date.now();
+    model._animationFrameCount = 0;
   };
 
   publicAPI.setCurrentRenderer = function (r) {
@@ -975,6 +987,7 @@ var DEFAULT_VALUES = {
   currentGesture: 'Start',
   animationRequest: null,
   lastFrameTime: 0.1,
+  recentAnimationFrameRate: 10.0,
   wheelTimeoutID: 0,
   moveTimeoutID: 0,
   lastGamepadValues: {}
@@ -990,7 +1003,7 @@ function extend(publicAPI, model) {
     return macro.event(publicAPI, model, eventName);
   }); // Create get-only macros
 
-  macro.get(publicAPI, model, ['initialized', 'container', 'interactorStyle', 'lastFrameTime', 'view']); // Create get-set macros
+  macro.get(publicAPI, model, ['initialized', 'container', 'interactorStyle', 'lastFrameTime', 'recentAnimationFrameRate', 'view']); // Create get-set macros
 
   macro.setGet(publicAPI, model, ['lightFollowCamera', 'enabled', 'enableRender', 'recognizeGestures', 'desiredUpdateRate', 'stillUpdateRate', 'picker']); // For more macro methods, see "Sources/macros.js"
   // Object specific methods

package/Rendering/WebGPU/VolumePass.js

@@ -8,6 +8,7 @@ import vtkWebGPUMapperHelper from './MapperHelper.js';
 import vtkWebGPURenderEncoder from './RenderEncoder.js';
 import vtkWebGPUShaderCache from './ShaderCache.js';
 import vtkWebGPUTexture from './Texture.js';
+import vtkWebGPUFullScreenQuad from './FullScreenQuad.js';
 import vtkWebGPUVolumePassFSQ from './VolumePassFSQ.js';
 import { f as distance2BetweenPoints } from '../../Common/Core/Math/index.js';
 
@@ -32,6 +33,7 @@ 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, input.tcoordVS);\n\n  //VTK::RenderEncoder::Impl\n  return output;\n}\n";
 /* eslint-disable no-undef */
 
 /* eslint-disable no-bitwise */
@@ -39,7 +41,41 @@ var DepthBoundsFS = "\n//VTK::Renderer::Dec\n\n//VTK::Select::Dec\n\n//VTK::Volu
 
 function vtkWebGPUVolumePass(publicAPI, model) {
   // Set our className
-  model.classHierarchy.push('vtkWebGPUVolumePass');
+  model.classHierarchy.push('vtkWebGPUVolumePass'); // create the required textures, encoders, FSQ etc
+
+  publicAPI.initialize = function (viewNode) {
+    if (!model._mergeEncoder) {
+      publicAPI.createMergeEncoder(viewNode);
+    }
+
+    if (!model._clearEncoder) {
+      publicAPI.createClearEncoder(viewNode);
+    }
+
+    if (!model._copyEncoder) {
+      publicAPI.createCopyEncoder(viewNode);
+    }
+
+    if (!model._depthRangeEncoder) {
+      publicAPI.createDepthRangeEncoder(viewNode);
+    }
+
+    if (!model.fullScreenQuad) {
+      model.fullScreenQuad = vtkWebGPUVolumePassFSQ.newInstance();
+      model.fullScreenQuad.setDevice(viewNode.getDevice());
+      model.fullScreenQuad.setTextureViews(_toConsumableArray(model._depthRangeEncoder.getColorTextureViews()));
+    }
+
+    if (!model._volumeCopyQuadQuad) {
+      model._volumeCopyQuad = vtkWebGPUFullScreenQuad.newInstance();
+
+      model._volumeCopyQuad.setPipelineHash('volpassfsq');
+
+      model._volumeCopyQuad.setDevice(viewNode.getDevice());
+
+      model._volumeCopyQuad.setFragmentShaderTemplate(volumeCopyFragTemplate);
+    }
+  };
 
   publicAPI.traverse = function (renNode, viewNode) {
     if (model.deleted) {
@@ -47,29 +83,25 @@ function vtkWebGPUVolumePass(publicAPI, model) {
     } // we just render our delegates in order
 
 
-    model.currentParent = viewNode; // then perform the ray casting using the depth bounds texture
-
-    if (!model.finalEncoder) {
-      publicAPI.createFinalEncoder(viewNode);
-    } // first render the boxes to generate a min max depth
-    // map for all the volumes
+    model.currentParent = viewNode; // create stuff we need
 
+    publicAPI.initialize(viewNode); // determine if we are rendering a small size
 
-    publicAPI.renderDepthBounds(renNode, viewNode);
+    publicAPI.computeTiming(viewNode); // first render the boxes to generate a min max depth
+    // map for all the volumes
 
-    if (!model.fullScreenQuad) {
-      model.fullScreenQuad = vtkWebGPUVolumePassFSQ.newInstance();
-      model.fullScreenQuad.setDevice(viewNode.getDevice());
-      model.fullScreenQuad.setTextureViews(_toConsumableArray(model.depthRangeEncoder.getColorTextureViews()));
-    }
+    publicAPI.renderDepthBounds(renNode, viewNode); // always mark true
 
-    var device = viewNode.getDevice(); // -4 because we use know we use textures for min, max, ofun and tfun
+    model._firstGroup = true;
+    var device = viewNode.getDevice(); // determine how many volumes we can render at a time. We subtract
+    // 4 because we use know we use textures for min, max, ofun and tfun
 
-    var maxVolumes = device.getHandle().limits.maxSampledTexturesPerShaderStage - 4;
-    var cameraPos = renNode.getRenderable().getActiveCamera().getPosition();
+    var maxVolumes = device.getHandle().limits.maxSampledTexturesPerShaderStage - 4; // if we have to make multiple passes then break the volumes up into groups
+    // rendered from farthest to closest
 
     if (model.volumes.length > maxVolumes) {
-      // sort from back to front based on volume centroid
+      var cameraPos = renNode.getRenderable().getActiveCamera().getPosition(); // sort from back to front based on volume centroid
+
       var distances = [];
 
       for (var v = 0; v < model.volumes.length; v++) {
@@ -94,26 +126,116 @@ function vtkWebGPUVolumePass(publicAPI, model) {
         volumesToRender.push(model.volumes[volumeOrder[_v]]);
 
         if (volumesToRender.length >= chunkSize) {
-          publicAPI.finalPass(viewNode, renNode, volumesToRender);
+          publicAPI.rayCastPass(viewNode, renNode, volumesToRender);
           volumesToRender = [];
           chunkSize = maxVolumes;
+          model._firstGroup = false;
         }
       }
     } else {
-      publicAPI.finalPass(viewNode, renNode, model.volumes);
+      // if not rendering in chunks then just draw all of them at once
+      publicAPI.rayCastPass(viewNode, renNode, model.volumes);
+    } // copy back to the original color buffer
+
+
+    if (model.small) {
+      model._volumeCopyQuad.setTextureViews([model._smallColorTextureView]);
+    } else {
+      model._volumeCopyQuad.setTextureViews([model._largeColorTextureView]);
+    } // final composite
+
+
+    model._copyEncoder.setColorTextureView(0, model.colorTextureView);
+
+    model._copyEncoder.attachTextureViews();
+
+    renNode.setRenderEncoder(model._copyEncoder);
+
+    model._copyEncoder.begin(viewNode.getCommandEncoder());
+
+    renNode.scissorAndViewport(model._copyEncoder);
+
+    model._volumeCopyQuad.setWebGPURenderer(renNode);
+
+    model._volumeCopyQuad.render(model._copyEncoder, viewNode.getDevice());
+
+    model._copyEncoder.end();
+  }; // unsubscribe from our listeners
+
+
+  publicAPI.delete = macro.chain(function () {
+    if (model._animationRateSubscription) {
+      model._animationRateSubscription.unsubscribe();
+
+      model._animationRateSubscription = null;
+    }
+  }, publicAPI.delete);
+
+  publicAPI.computeTiming = function (viewNode) {
+    model.small = false;
+    var rwi = viewNode.getRenderable().getInteractor();
+
+    if (rwi.isAnimating() && model._lastScale > 1.5) {
+      model.small = true;
+    }
+
+    if (model.small) {
+      model._activeColorTextureView = model._smallColorTextureView;
+    } else {
+      model._largeColorTexture.resize(viewNode.getCanvas().width, viewNode.getCanvas().height);
+
+      model._activeColorTextureView = model._largeColorTextureView;
+    }
+
+    if (!model._animationRateSubscription) {
+      // when the animation frame rate changes recompute the scale factor
+      model._animationRateSubscription = rwi.onAnimationFrameRateUpdate(function () {
+        var frate = rwi.getRecentAnimationFrameRate();
+        var targetScale = model._lastScale * rwi.getDesiredUpdateRate() / frate; // Do we need a resize? The values below are to provide some stickyness
+        // so that we are not changing texture size every second. Instead the targhet scale
+        // has to be a certain amount larger or smaller than the current value to force a
+        // change in texture size
+
+        if (targetScale > 1.4 * model._lastScale || targetScale < 0.7 * model._lastScale) {
+          model._lastScale = targetScale; // clamp scale to some reasonable values.
+          // Below 1.5 we will just be using full resolution as that is close enough
+          // Above 400 seems like a lot so we limit to that 1/20th per axis
+
+          if (model._lastScale > 400) {
+            model._lastScale = 400;
+          }
+
+          if (model._lastScale < 1.5) {
+            model._lastScale = 1.5;
+          } else {
+            var targetSmallWidth = 64 * Math.ceil(viewNode.getCanvas().width / (Math.sqrt(model._lastScale) * 64));
+            var targetSmallHeight = Math.ceil(targetSmallWidth * viewNode.getCanvas().height / viewNode.getCanvas().width);
+
+            model._smallColorTexture.resize(targetSmallWidth, targetSmallHeight);
+          }
+        }
+      });
     }
   };
 
-  publicAPI.finalPass = function (viewNode, renNode, volumes) {
-    model.finalEncoder.setColorTextureView(0, model.colorTextureView);
-    model.finalEncoder.attachTextureViews();
-    renNode.setRenderEncoder(model.finalEncoder);
-    model.finalEncoder.begin(viewNode.getCommandEncoder());
-    renNode.scissorAndViewport(model.finalEncoder);
+  publicAPI.rayCastPass = function (viewNode, renNode, volumes) {
+    var encoder = model._firstGroup ? model._clearEncoder : model._mergeEncoder;
+    encoder.setColorTextureView(0, model._activeColorTextureView);
+    encoder.attachTextureViews();
+    renNode.setRenderEncoder(encoder);
+    encoder.begin(viewNode.getCommandEncoder());
+
+    var width = model._activeColorTextureView.getTexture().getWidth();
+
+    var height = model._activeColorTextureView.getTexture().getHeight();
+
+    encoder.getHandle().setViewport(0, 0, width, height, 0.0, 1.0); // set scissor
+
+    encoder.getHandle().setScissorRect(0, 0, width, height);
     model.fullScreenQuad.setWebGPURenderer(renNode);
     model.fullScreenQuad.setVolumes(volumes);
-    model.fullScreenQuad.render(model.finalEncoder, viewNode.getDevice());
-    model.finalEncoder.end();
+    model.fullScreenQuad.render(encoder, viewNode.getDevice());
+    encoder.end();
   };
 
   publicAPI.renderDepthBounds = function (renNode, viewNode) {
@@ -211,55 +333,32 @@ function vtkWebGPUVolumePass(publicAPI, model) {
   publicAPI.drawDepthRange = function (renNode, viewNode) {
     var device = viewNode.getDevice(); // copy current depth buffer to
 
-    if (!model.depthRangeEncoder) {
-      publicAPI.createDepthRangeEncoder();
-      model.depthRangeTexture = vtkWebGPUTexture.newInstance();
-      model.depthRangeTexture.create(device, {
-        width: viewNode.getCanvas().width,
-        height: viewNode.getCanvas().height,
-        format: 'r16float',
-        usage: GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING
-      });
-      var maxView = model.depthRangeTexture.createView();
-      maxView.setName('maxTexture');
-      model.depthRangeEncoder.setColorTextureView(0, maxView);
-      model.depthRangeTexture2 = vtkWebGPUTexture.newInstance();
-      model.depthRangeTexture2.create(device, {
-        width: viewNode.getCanvas().width,
-        height: viewNode.getCanvas().height,
-        format: 'r16float',
-        usage: GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING
-      });
-      var minView = model.depthRangeTexture2.createView();
-      minView.setName('minTexture');
-      model.depthRangeEncoder.setColorTextureView(1, minView);
+    model._depthRangeTexture.resizeToMatch(model.colorTextureView.getTexture());
 
-      model._mapper.setDevice(viewNode.getDevice());
+    model._depthRangeTexture2.resizeToMatch(model.colorTextureView.getTexture());
 
-      model._mapper.setTextureViews([model.depthTextureView]);
-    } else {
-      model.depthRangeTexture.resizeToMatch(model.colorTextureView.getTexture());
-      model.depthRangeTexture2.resizeToMatch(model.colorTextureView.getTexture());
-    }
+    model._depthRangeEncoder.attachTextureViews();
 
-    model.depthRangeEncoder.attachTextureViews();
     publicAPI.setCurrentOperation('volumeDepthRangePass');
-    renNode.setRenderEncoder(model.depthRangeEncoder);
+    renNode.setRenderEncoder(model._depthRangeEncoder);
     renNode.volumeDepthRangePass(true);
 
     model._mapper.setWebGPURenderer(renNode);
 
-    model._mapper.build(model.depthRangeEncoder, device);
+    model._mapper.build(model._depthRangeEncoder, device);
 
     model._mapper.registerToDraw();
 
     renNode.volumeDepthRangePass(false);
   };
 
-  publicAPI.createDepthRangeEncoder = function () {
-    model.depthRangeEncoder = vtkWebGPURenderEncoder.newInstance();
-    model.depthRangeEncoder.setPipelineHash('volr');
-    model.depthRangeEncoder.setReplaceShaderCodeFunction(function (pipeline) {
+  publicAPI.createDepthRangeEncoder = function (viewNode) {
+    var device = viewNode.getDevice();
+    model._depthRangeEncoder = vtkWebGPURenderEncoder.newInstance();
+
+    model._depthRangeEncoder.setPipelineHash('volr');
+
+    model._depthRangeEncoder.setReplaceShaderCodeFunction(function (pipeline) {
       var fDesc = pipeline.getShaderDescription('fragment');
       fDesc.addOutput('vec4<f32>', 'outColor1');
       fDesc.addOutput('vec4<f32>', 'outColor2');
@@ -267,7 +366,8 @@ function vtkWebGPUVolumePass(publicAPI, model) {
       code = vtkWebGPUShaderCache.substitute(code, '//VTK::RenderEncoder::Impl', ['output.outColor1 = vec4<f32>(input.fragPos.z, 0.0, 0.0, 0.0);', 'output.outColor2 = vec4<f32>(stopval, 0.0, 0.0, 0.0);']).result;
       fDesc.setCode(code);
     });
-    model.depthRangeEncoder.setDescription({
+
+    model._depthRangeEncoder.setDescription({
       colorAttachments: [{
         view: null,
         loadValue: [0.0, 0.0, 0.0, 0.0],
@@ -278,7 +378,8 @@ function vtkWebGPUVolumePass(publicAPI, model) {
         storeOp: 'store'
       }]
     });
-    model.depthRangeEncoder.setPipelineSettings({
+
+    model._depthRangeEncoder.setPipelineSettings({
       primitive: {
         cullMode: 'none'
       },
@@ -313,27 +414,184 @@ function vtkWebGPUVolumePass(publicAPI, model) {
           }
         }]
       }
+    }); // and the textures it needs
+
+
+    model._depthRangeTexture = vtkWebGPUTexture.newInstance();
+
+    model._depthRangeTexture.create(device, {
+      width: viewNode.getCanvas().width,
+      height: viewNode.getCanvas().height,
+      format: 'r16float',
+      usage: GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING
+    });
+
+    var maxView = model._depthRangeTexture.createView();
+
+    maxView.setName('maxTexture');
+
+    model._depthRangeEncoder.setColorTextureView(0, maxView);
+
+    model._depthRangeTexture2 = vtkWebGPUTexture.newInstance();
+
+    model._depthRangeTexture2.create(device, {
+      width: viewNode.getCanvas().width,
+      height: viewNode.getCanvas().height,
+      format: 'r16float',
+      usage: GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING
+    });
+
+    var minView = model._depthRangeTexture2.createView();
+
+    minView.setName('minTexture');
+
+    model._depthRangeEncoder.setColorTextureView(1, minView);
+
+    model._mapper.setDevice(viewNode.getDevice());
+
+    model._mapper.setTextureViews([model.depthTextureView]);
+  };
+
+  publicAPI.createClearEncoder = function (viewNode) {
+    model._smallColorTexture = vtkWebGPUTexture.newInstance(); // multiple of 64 pixels to help with texture alignment/size issues
+    // as webgpu textures have to be multiples of 256 bytes wide
+    // for data transfers (just in case)
+
+    var targetSmallWidth = 64 * Math.ceil(0.7 * viewNode.getCanvas().width / 64);
+
+    model._smallColorTexture.create(viewNode.getDevice(), {
+      width: targetSmallWidth,
+      height: Math.ceil(targetSmallWidth * viewNode.getCanvas().height / viewNode.getCanvas().width),
+      format: 'bgra8unorm',
+
+      /* eslint-disable no-undef */
+
+      /* eslint-disable no-bitwise */
+      usage: GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING | GPUTextureUsage.COPY_SRC
+    });
+
+    model._smallColorTextureView = model._smallColorTexture.createView();
+
+    model._smallColorTextureView.setName('volumePassSmallColorTexture');
+
+    model._smallColorTextureView.addSampler(viewNode.getDevice(), {
+      minFilter: 'linear',
+      magFilter: 'linear'
+    });
+
+    model._largeColorTexture = vtkWebGPUTexture.newInstance();
+
+    model._largeColorTexture.create(viewNode.getDevice(), {
+      width: viewNode.getCanvas().width,
+      height: viewNode.getCanvas().height,
+      format: 'bgra8unorm',
+
+      /* eslint-disable no-undef */
+
+      /* eslint-disable no-bitwise */
+      usage: GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING | GPUTextureUsage.COPY_SRC
+    });
+
+    model._largeColorTextureView = model._largeColorTexture.createView();
+
+    model._largeColorTextureView.setName('volumePassSmallColorTexture');
+
+    model._largeColorTextureView.addSampler(viewNode.getDevice(), {
+      minFilter: 'linear',
+      magFilter: 'linear'
+    });
+
+    model._clearEncoder = vtkWebGPURenderEncoder.newInstance();
+
+    model._clearEncoder.setDescription({
+      colorAttachments: [{
+        view: null,
+        loadValue: [0.0, 0.0, 0.0, 0.0],
+        storeOp: 'store'
+      }]
+    });
+
+    model._clearEncoder.setPipelineHash('volpf');
+
+    model._clearEncoder.setPipelineSettings({
+      primitive: {
+        cullMode: 'none'
+      },
+      fragment: {
+        targets: [{
+          format: 'bgra8unorm',
+          blend: {
+            color: {
+              srcFactor: 'src-alpha',
+              dstFactor: 'one-minus-src-alpha'
+            },
+            alpha: {
+              srcfactor: 'one',
+              dstFactor: 'one-minus-src-alpha'
+            }
+          }
+        }]
+      }
     });
   };
 
-  publicAPI.createFinalEncoder = function (viewNode) {
-    model.finalEncoder = vtkWebGPURenderEncoder.newInstance();
-    model.finalEncoder.setDescription({
+  publicAPI.createCopyEncoder = function (viewNode) {
+    model._copyEncoder = vtkWebGPURenderEncoder.newInstance();
+
+    model._copyEncoder.setDescription({
       colorAttachments: [{
         view: null,
         loadValue: 'load',
         storeOp: 'store'
       }]
     });
-    model.finalEncoder.setReplaceShaderCodeFunction(function (pipeline) {
+
+    model._copyEncoder.setPipelineHash('volcopypf');
+
+    model._copyEncoder.setPipelineSettings({
+      primitive: {
+        cullMode: 'none'
+      },
+      fragment: {
+        targets: [{
+          format: 'bgra8unorm',
+          blend: {
+            color: {
+              srcFactor: 'one',
+              dstFactor: 'one-minus-src-alpha'
+            },
+            alpha: {
+              srcfactor: 'one',
+              dstFactor: 'one-minus-src-alpha'
+            }
+          }
+        }]
+      }
+    });
+  };
+
+  publicAPI.createMergeEncoder = function (viewNode) {
+    model._mergeEncoder = vtkWebGPURenderEncoder.newInstance();
+
+    model._mergeEncoder.setDescription({
+      colorAttachments: [{
+        view: null,
+        loadValue: 'load',
+        storeOp: 'store'
+      }]
+    });
+
+    model._mergeEncoder.setReplaceShaderCodeFunction(function (pipeline) {
       var fDesc = pipeline.getShaderDescription('fragment');
       fDesc.addOutput('vec4<f32>', 'outColor');
       var code = fDesc.getCode();
-      code = vtkWebGPUShaderCache.substitute(code, '//VTK::RenderEncoder::Impl', ['output.outColor = vec4<f32>(computedColor.rgb*computedColor.a, computedColor.a);']).result;
+      code = vtkWebGPUShaderCache.substitute(code, '//VTK::RenderEncoder::Impl', ['output.outColor = vec4<f32>(computedColor.rgb, computedColor.a);']).result;
       fDesc.setCode(code);
     });
-    model.finalEncoder.setPipelineHash('volpf');
-    model.finalEncoder.setPipelineSettings({
+
+    model._mergeEncoder.setPipelineHash('volpf');
+
+    model._mergeEncoder.setPipelineSettings({
       primitive: {
         cullMode: 'none'
       },
@@ -342,7 +600,7 @@ function vtkWebGPUVolumePass(publicAPI, model) {
           format: 'bgra8unorm',
           blend: {
             color: {
-              srcFactor: 'one',
+              srcFactor: 'src-alpha',
               dstFactor: 'one-minus-src-alpha'
             },
             alpha: {
@@ -387,6 +645,7 @@ function extend(publicAPI, model) {
   Object.assign(model, DEFAULT_VALUES, initialValues); // Build VTK API
 
   vtkRenderPass.extend(publicAPI, model, initialValues);
+  model._lastScale = 2.0;
   model._mapper = vtkWebGPUMapperHelper.newInstance();
 
   model._mapper.setFragmentShaderTemplate(DepthBoundsFS);

package/Rendering/WebGPU/VolumePassFSQ.js

@@ -9,7 +9,7 @@ import vtkWebGPUSampler from './Sampler.js';
 import vtkWebGPUTypes from './Types.js';
 import { BlendMode } from '../Core/VolumeMapper/Constants.js';
 
-var volFragTemplate = "\n//VTK::Renderer::Dec\n\n//VTK::Mapper::Dec\n\n//VTK::TCoord::Dec\n\n//VTK::Volume::TraverseDec\n\n//VTK::RenderEncoder::Dec\n\n//VTK::IOStructs::Dec\n\nfn getTextureValue(vTex: texture_3d<f32>, tpos: vec4<f32>) -> f32\n{\n  // todo multicomponent support\n  return textureSampleLevel(vTex, clampSampler, tpos.xyz, 0.0).r;\n}\n\nfn getGradient(vTex: texture_3d<f32>, tpos: vec4<f32>, vNum: i32, scalar: f32) -> vec4<f32>\n{\n  var result: vec4<f32>;\n\n  var tstep: vec4<f32> = volumeSSBO.values[vNum].tstep;\n  result.x = getTextureValue(vTex, tpos + vec4<f32>(tstep.x, 0.0, 0.0, 1.0)) - scalar;\n  result.y = getTextureValue(vTex, tpos + vec4<f32>(0.0, tstep.y, 0.0, 1.0)) - scalar;\n  result.z = getTextureValue(vTex, tpos + vec4<f32>(0.0, 0.0, tstep.z, 1.0)) - scalar;\n\n  // divide by spacing\n  result = result / volumeSSBO.values[vNum].spacing;\n\n  var grad: f32 = length(result.xyz);\n\n  // // rotate to View Coords, needed for lighting and shading\n  // result.xyz =\n  //   result.x * vPlaneNormal0 +\n  //   result.y * vPlaneNormal2 +\n  //   result.z * vPlaneNormal4;\n\n  if (grad > 0.0)\n  {\n    result = result * (1.0 / grad);\n  }\n\n  result.w = grad;\n\n  return result;\n}\n\nfn processVolume(vTex: texture_3d<f32>, vNum: i32, cNum: i32, posSC: vec4<f32>, tfunRows: f32) -> vec4<f32>\n{\n  var outColor: vec4<f32> = vec4<f32>(0.0, 0.0, 0.0, 0.0);\n\n  // convert to tcoords and reject if outside the volume\n  var tpos: vec4<f32> = volumeSSBO.values[vNum].SCTCMatrix*posSC;\n  if (tpos.x < 0.0 || tpos.y < 0.0 || tpos.z < 0.0 ||\n      tpos.x > 1.0 || tpos.y > 1.0 || tpos.z > 1.0) { return outColor; }\n\n  var scalar: f32 = getTextureValue(vTex, tpos);\n\n  var coord: vec2<f32> =\n    vec2<f32>(scalar * componentSSBO.values[cNum].cScale + componentSSBO.values[cNum].cShift,\n      (0.5 + 2.0 * f32(vNum)) / tfunRows);\n  var color: vec4<f32> = textureSampleLevel(tfunTexture, clampSampler, coord, 0.0);\n\n  var gofactor: f32 = 1.0;\n  if (componentSSBO.values[cNum].gomin <  1.0)\n  {\n    var normal: vec4<f32> = getGradient(vTex, tpos, vNum, scalar);\n    gofactor = clamp(normal.a*componentSSBO.values[cNum].goScale + componentSSBO.values[cNum].goShift,\n      componentSSBO.values[cNum].gomin, componentSSBO.values[cNum].gomax);\n  }\n\n  coord.x = (scalar * componentSSBO.values[cNum].oScale + componentSSBO.values[cNum].oShift);\n  var opacity: f32 = textureSampleLevel(ofunTexture, clampSampler, coord, 0.0).r;\n\n  outColor = vec4<f32>(color.rgb, gofactor * opacity);\n\n//VTK::Volume::Process\n\n  return outColor;\n}\n\n// adjust the start and end point of a raycast such that it intersects the unit cube.\n// This function is used to take a raycast starting point and step vector\n// and numSteps and return the startijng and ending steps for intersecting the\n// unit cube. Recall for a 3D texture, the unit cube is the range of texture coordsinates\n// that have valid values. So this funtion can be used to take a ray in texture coordinates\n// and bound it to intersecting the texture.\n//\nfn adjustBounds(tpos: vec4<f32>, tstep: vec4<f32>, numSteps: f32) -> vec2<f32>\n{\n  var result: vec2<f32> = vec2<f32>(0.0, numSteps);\n  var tpos2: vec4<f32> = tpos + tstep*numSteps;\n\n  // move tpos to the start of the volume\n  var adjust: f32 =\n    min(\n      max(tpos.x/tstep.x, (tpos.x - 1.0)/tstep.x),\n      min(\n        max((tpos.y - 1.0)/tstep.y, tpos.y/tstep.y),\n        max((tpos.z - 1.0)/tstep.z, tpos.z/tstep.z)));\n  if (adjust < 0.0)\n  {\n    result.x = result.x - adjust;\n  }\n\n  // adjust length to the end\n  adjust =\n    max(\n      min(tpos2.x/tstep.x, (tpos2.x - 1.0)/tstep.x),\n      max(\n        min((tpos2.y - 1.0)/tstep.y, tpos2.y/tstep.y),\n        min((tpos2.z - 1.0)/tstep.z, tpos2.z/tstep.z)));\n  if (adjust > 0.0)\n  {\n    result.y = result.y - adjust;\n  }\n\n  return result;\n}\n\nfn getSimpleColor(scalar: f32, vNum: i32, cNum: i32) -> vec4<f32>\n{\n  // how many rows (tfuns) do we have in our tfunTexture\n  var tfunRows: f32 = f32(textureDimensions(tfunTexture).y);\n\n  var coord: vec2<f32> =\n    vec2<f32>(scalar * componentSSBO.values[cNum].cScale + componentSSBO.values[cNum].cShift,\n      (0.5 + 2.0 * f32(vNum)) / tfunRows);\n  var color: vec4<f32> = textureSampleLevel(tfunTexture, clampSampler, coord, 0.0);\n  coord.x = (scalar * componentSSBO.values[cNum].oScale + componentSSBO.values[cNum].oShift);\n  var opacity: f32 = textureSampleLevel(ofunTexture, clampSampler, coord, 0.0).r;\n  return vec4<f32>(color.rgb, opacity);\n}\n\nfn traverseMax(vTex: texture_3d<f32>, vNum: i32, cNum: i32, rayLengthSC: f32, minPosSC: vec4<f32>, rayStepSC: vec4<f32>)\n{\n  // convert to tcoords and reject if outside the volume\n  var numSteps: f32 = rayLengthSC/mapperUBO.SampleDistance;\n  var tpos: vec4<f32> = volumeSSBO.values[vNum].SCTCMatrix*minPosSC;\n  var tpos2: vec4<f32> = volumeSSBO.values[vNum].SCTCMatrix*(minPosSC + rayStepSC);\n  var tstep: vec4<f32> = tpos2 - tpos;\n\n  var rayBounds: vec2<f32> = adjustBounds(tpos, tstep, numSteps);\n\n  // did we hit anything\n  if (rayBounds.x >= rayBounds.y)\n  {\n    traverseVals[vNum] = vec4<f32>(0.0,0.0,0.0,0.0);\n    return;\n  }\n\n  tpos = tpos + tstep*rayBounds.x;\n  var curDist: f32 = rayBounds.x;\n  var maxVal: f32 = -1.0e37;\n  loop\n  {\n    var scalar: f32 = getTextureValue(vTex, tpos);\n    if (scalar > maxVal)\n    {\n      maxVal = scalar;\n    }\n\n    // increment position\n    curDist = curDist + 1.0;\n    tpos = tpos + tstep;\n\n    // check if we have reached a terminating condition\n    if (curDist > rayBounds.y) { break; }\n  }\n\n  // process to get the color and opacity\n  traverseVals[vNum] = getSimpleColor(maxVal, vNum, cNum);\n}\n\nfn traverseMin(vTex: texture_3d<f32>, vNum: i32, cNum: i32, rayLengthSC: f32, minPosSC: vec4<f32>, rayStepSC: vec4<f32>)\n{\n  // convert to tcoords and reject if outside the volume\n  var numSteps: f32 = rayLengthSC/mapperUBO.SampleDistance;\n  var tpos: vec4<f32> = volumeSSBO.values[vNum].SCTCMatrix*minPosSC;\n  var tpos2: vec4<f32> = volumeSSBO.values[vNum].SCTCMatrix*(minPosSC + rayStepSC);\n  var tstep: vec4<f32> = tpos2 - tpos;\n\n  var rayBounds: vec2<f32> = adjustBounds(tpos, tstep, numSteps);\n\n  // did we hit anything\n  if (rayBounds.x >= rayBounds.y)\n  {\n    traverseVals[vNum] = vec4<f32>(0.0,0.0,0.0,0.0);\n    return;\n  }\n\n  tpos = tpos + tstep*rayBounds.x;\n  var curDist: f32 = rayBounds.x;\n  var minVal: f32 = 1.0e37;\n  loop\n  {\n    var scalar: f32 = getTextureValue(vTex, tpos);\n    if (scalar < minVal)\n    {\n      minVal = scalar;\n    }\n\n    // increment position\n    curDist = curDist + 1.0;\n    tpos = tpos + tstep;\n\n    // check if we have reached a terminating condition\n    if (curDist > rayBounds.y) { break; }\n  }\n\n  // process to get the color and opacity\n  traverseVals[vNum] = getSimpleColor(minVal, vNum, cNum);\n}\n\nfn traverseAverage(vTex: texture_3d<f32>, vNum: i32, cNum: i32, rayLengthSC: f32, minPosSC: vec4<f32>, rayStepSC: vec4<f32>)\n{\n  // convert to tcoords and reject if outside the volume\n  var numSteps: f32 = rayLengthSC/mapperUBO.SampleDistance;\n  var tpos: vec4<f32> = volumeSSBO.values[vNum].SCTCMatrix*minPosSC;\n  var tpos2: vec4<f32> = volumeSSBO.values[vNum].SCTCMatrix*(minPosSC + rayStepSC);\n  var tstep: vec4<f32> = tpos2 - tpos;\n\n  var rayBounds: vec2<f32> = adjustBounds(tpos, tstep, numSteps);\n\n  // did we hit anything\n  if (rayBounds.x >= rayBounds.y)\n  {\n    traverseVals[vNum] = vec4<f32>(0.0,0.0,0.0,0.0);\n    return;\n  }\n\n  let ipRange: vec4<f32> = volumeSSBO.values[vNum].ipScalarRange;\n  tpos = tpos + tstep*rayBounds.x;\n  var curDist: f32 = rayBounds.x;\n  var avgVal: f32 = 0.0;\n  var sampleCount: f32 = 0.0;\n  loop\n  {\n    var sample: f32 = getTextureValue(vTex, tpos);\n    // right now leave filtering off until WebGL changes get merged\n    // if (ipRange.z == 0.0 || sample >= ipRange.x && sample <= ipRange.y)\n    // {\n      avgVal = avgVal + sample;\n      sampleCount = sampleCount + 1.0;\n    // }\n\n    // increment position\n    curDist = curDist + 1.0;\n    tpos = tpos + tstep;\n\n    // check if we have reached a terminating condition\n    if (curDist > rayBounds.y) { break; }\n  }\n\n  if (sampleCount <= 0.0)\n  {\n    traverseVals[vNum] = vec4<f32>(0.0,0.0,0.0,0.0);\n  }\n\n  // process to get the color and opacity\n  traverseVals[vNum] = getSimpleColor(avgVal/sampleCount, vNum, cNum);\n}\n\nfn traverseAdditive(vTex: texture_3d<f32>, vNum: i32, cNum: i32, rayLengthSC: f32, minPosSC: vec4<f32>, rayStepSC: vec4<f32>)\n{\n  // convert to tcoords and reject if outside the volume\n  var numSteps: f32 = rayLengthSC/mapperUBO.SampleDistance;\n  var tpos: vec4<f32> = volumeSSBO.values[vNum].SCTCMatrix*minPosSC;\n  var tpos2: vec4<f32> = volumeSSBO.values[vNum].SCTCMatrix*(minPosSC + rayStepSC);\n  var tstep: vec4<f32> = tpos2 - tpos;\n\n  var rayBounds: vec2<f32> = adjustBounds(tpos, tstep, numSteps);\n\n  // did we hit anything\n  if (rayBounds.x >= rayBounds.y)\n  {\n    traverseVals[vNum] = vec4<f32>(0.0,0.0,0.0,0.0);\n    return;\n  }\n\n  let ipRange: vec4<f32> = volumeSSBO.values[vNum].ipScalarRange;\n  tpos = tpos + tstep*rayBounds.x;\n  var curDist: f32 = rayBounds.x;\n  var sumVal: f32 = 0.0;\n  loop\n  {\n    var sample: f32 = getTextureValue(vTex, tpos);\n    // right now leave filtering off until WebGL changes get merged\n    // if (ipRange.z == 0.0 || sample >= ipRange.x && sample <= ipRange.y)\n    // {\n      sumVal = sumVal + sample;\n    // }\n\n    // increment position\n    curDist = curDist + 1.0;\n    tpos = tpos + tstep;\n\n    // check if we have reached a terminating condition\n    if (curDist > rayBounds.y) { break; }\n  }\n\n  // process to get the color and opacity\n  traverseVals[vNum] = getSimpleColor(sumVal, vNum, cNum);\n}\n\nfn composite(rayLengthSC: f32, minPosSC: vec4<f32>, rayStepSC: vec4<f32>) -> vec4<f32>\n{\n  // initial ray position is at the beginning\n  var rayPosSC: vec4<f32> = minPosSC;\n\n  // how many rows (tfuns) do we have in our tfunTexture\n  var tfunRows: f32 = f32(textureDimensions(tfunTexture).y);\n\n  var curDist: f32 = 0.0;\n  var computedColor: vec4<f32> = vec4<f32>(0.0, 0.0, 0.0, 0.0);\n  var sampleColor: vec4<f32>;\n//VTK::Volume::TraverseCalls\n\n  loop\n  {\n    // for each volume, sample and accumulate color\n//VTK::Volume::CompositeCalls\n\n    // increment position\n    curDist = curDist + mapperUBO.SampleDistance;\n    rayPosSC = rayPosSC + rayStepSC;\n\n    // check if we have reached a terminating condition\n    if (curDist > rayLengthSC) { break; }\n    if (computedColor.a > 0.98) { break; }\n  }\n  return computedColor;\n}\n\n[[stage(fragment)]]\nfn main(\n//VTK::IOStructs::Input\n)\n//VTK::IOStructs::Output\n{\n  var output: fragmentOutput;\n\n  var rayMax: f32 = textureSampleLevel(maxTexture, clampSampler, input.tcoordVS, 0.0).r;\n  var rayMin: f32 = textureSampleLevel(minTexture, clampSampler, input.tcoordVS, 0.0).r;\n\n  // discard empty rays\n  if (rayMax <= rayMin) { discard; }\n  else\n  {\n    var winDimsI32: vec2<i32> = textureDimensions(minTexture);\n    var winDims: vec2<f32> = vec2<f32>(f32(winDimsI32.x), f32(winDimsI32.y));\n\n    // compute start and end ray positions in view coordinates\n    var minPosSC: vec4<f32> = rendererUBO.PCSCMatrix*vec4<f32>(2.0*input.fragPos.x/winDims.x - 1.0, 1.0 - 2.0 * input.fragPos.y/winDims.y, rayMax, 1.0);\n    minPosSC = minPosSC * (1.0 / minPosSC.w);\n    var maxPosSC: vec4<f32> = rendererUBO.PCSCMatrix*vec4<f32>(2.0*input.fragPos.x/winDims.x - 1.0, 1.0 - 2.0 * input.fragPos.y/winDims.y, rayMin, 1.0);\n    maxPosSC = maxPosSC * (1.0 / maxPosSC.w);\n\n    var rayLengthSC: f32 = distance(minPosSC.xyz, maxPosSC.xyz);\n    var rayStepSC: vec4<f32> = (maxPosSC - minPosSC)*(mapperUBO.SampleDistance/rayLengthSC);\n    rayStepSC.w = 0.0;\n\n    var computedColor: vec4<f32>;\n\n//VTK::Volume::Loop\n\n//VTK::RenderEncoder::Impl\n  }\n\n  return output;\n}\n";
+var volFragTemplate = "\n//VTK::Renderer::Dec\n\n//VTK::Mapper::Dec\n\n//VTK::TCoord::Dec\n\n//VTK::Volume::TraverseDec\n\n//VTK::RenderEncoder::Dec\n\n//VTK::IOStructs::Dec\n\nfn getTextureValue(vTex: texture_3d<f32>, tpos: vec4<f32>) -> f32\n{\n  // todo multicomponent support\n  return textureSampleLevel(vTex, clampSampler, tpos.xyz, 0.0).r;\n}\n\nfn getGradient(vTex: texture_3d<f32>, tpos: vec4<f32>, vNum: i32, scalar: f32) -> vec4<f32>\n{\n  var result: vec4<f32>;\n\n  var tstep: vec4<f32> = volumeSSBO.values[vNum].tstep;\n  result.x = getTextureValue(vTex, tpos + vec4<f32>(tstep.x, 0.0, 0.0, 1.0)) - scalar;\n  result.y = getTextureValue(vTex, tpos + vec4<f32>(0.0, tstep.y, 0.0, 1.0)) - scalar;\n  result.z = getTextureValue(vTex, tpos + vec4<f32>(0.0, 0.0, tstep.z, 1.0)) - scalar;\n\n  // divide by spacing\n  result = result / volumeSSBO.values[vNum].spacing;\n\n  var grad: f32 = length(result.xyz);\n\n  // // rotate to View Coords, needed for lighting and shading\n  // result.xyz =\n  //   result.x * vPlaneNormal0 +\n  //   result.y * vPlaneNormal2 +\n  //   result.z * vPlaneNormal4;\n\n  if (grad > 0.0)\n  {\n    result = result * (1.0 / grad);\n  }\n\n  result.w = grad;\n\n  return result;\n}\n\nfn processVolume(vTex: texture_3d<f32>, vNum: i32, cNum: i32, posSC: vec4<f32>, tfunRows: f32) -> vec4<f32>\n{\n  var outColor: vec4<f32> = vec4<f32>(0.0, 0.0, 0.0, 0.0);\n\n  // convert to tcoords and reject if outside the volume\n  var tpos: vec4<f32> = volumeSSBO.values[vNum].SCTCMatrix*posSC;\n  if (tpos.x < 0.0 || tpos.y < 0.0 || tpos.z < 0.0 ||\n      tpos.x > 1.0 || tpos.y > 1.0 || tpos.z > 1.0) { return outColor; }\n\n  var scalar: f32 = getTextureValue(vTex, tpos);\n\n  var coord: vec2<f32> =\n    vec2<f32>(scalar * componentSSBO.values[cNum].cScale + componentSSBO.values[cNum].cShift,\n      (0.5 + 2.0 * f32(vNum)) / tfunRows);\n  var color: vec4<f32> = textureSampleLevel(tfunTexture, clampSampler, coord, 0.0);\n\n  var gofactor: f32 = 1.0;\n  if (componentSSBO.values[cNum].gomin <  1.0)\n  {\n    var normal: vec4<f32> = getGradient(vTex, tpos, vNum, scalar);\n    gofactor = clamp(normal.a*componentSSBO.values[cNum].goScale + componentSSBO.values[cNum].goShift,\n      componentSSBO.values[cNum].gomin, componentSSBO.values[cNum].gomax);\n  }\n\n  coord.x = (scalar * componentSSBO.values[cNum].oScale + componentSSBO.values[cNum].oShift);\n  var opacity: f32 = textureSampleLevel(ofunTexture, clampSampler, coord, 0.0).r;\n\n  outColor = vec4<f32>(color.rgb, gofactor * opacity);\n\n//VTK::Volume::Process\n\n  return outColor;\n}\n\n// adjust the start and end point of a raycast such that it intersects the unit cube.\n// This function is used to take a raycast starting point and step vector\n// and numSteps and return the startijng and ending steps for intersecting the\n// unit cube. Recall for a 3D texture, the unit cube is the range of texture coordsinates\n// that have valid values. So this funtion can be used to take a ray in texture coordinates\n// and bound it to intersecting the texture.\n//\nfn adjustBounds(tpos: vec4<f32>, tstep: vec4<f32>, numSteps: f32) -> vec2<f32>\n{\n  var result: vec2<f32> = vec2<f32>(0.0, numSteps);\n  var tpos2: vec4<f32> = tpos + tstep*numSteps;\n\n  // move tpos to the start of the volume\n  var adjust: f32 =\n    min(\n      max(tpos.x/tstep.x, (tpos.x - 1.0)/tstep.x),\n      min(\n        max((tpos.y - 1.0)/tstep.y, tpos.y/tstep.y),\n        max((tpos.z - 1.0)/tstep.z, tpos.z/tstep.z)));\n  if (adjust < 0.0)\n  {\n    result.x = result.x - adjust;\n  }\n\n  // adjust length to the end\n  adjust =\n    max(\n      min(tpos2.x/tstep.x, (tpos2.x - 1.0)/tstep.x),\n      max(\n        min((tpos2.y - 1.0)/tstep.y, tpos2.y/tstep.y),\n        min((tpos2.z - 1.0)/tstep.z, tpos2.z/tstep.z)));\n  if (adjust > 0.0)\n  {\n    result.y = result.y - adjust;\n  }\n\n  return result;\n}\n\nfn getSimpleColor(scalar: f32, vNum: i32, cNum: i32) -> vec4<f32>\n{\n  // how many rows (tfuns) do we have in our tfunTexture\n  var tfunRows: f32 = f32(textureDimensions(tfunTexture).y);\n\n  var coord: vec2<f32> =\n    vec2<f32>(scalar * componentSSBO.values[cNum].cScale + componentSSBO.values[cNum].cShift,\n      (0.5 + 2.0 * f32(vNum)) / tfunRows);\n  var color: vec4<f32> = textureSampleLevel(tfunTexture, clampSampler, coord, 0.0);\n  coord.x = (scalar * componentSSBO.values[cNum].oScale + componentSSBO.values[cNum].oShift);\n  var opacity: f32 = textureSampleLevel(ofunTexture, clampSampler, coord, 0.0).r;\n  return vec4<f32>(color.rgb, opacity);\n}\n\nfn traverseMax(vTex: texture_3d<f32>, vNum: i32, cNum: i32, rayLengthSC: f32, minPosSC: vec4<f32>, rayStepSC: vec4<f32>)\n{\n  // convert to tcoords and reject if outside the volume\n  var numSteps: f32 = rayLengthSC/mapperUBO.SampleDistance;\n  var tpos: vec4<f32> = volumeSSBO.values[vNum].SCTCMatrix*minPosSC;\n  var tpos2: vec4<f32> = volumeSSBO.values[vNum].SCTCMatrix*(minPosSC + rayStepSC);\n  var tstep: vec4<f32> = tpos2 - tpos;\n\n  var rayBounds: vec2<f32> = adjustBounds(tpos, tstep, numSteps);\n\n  // did we hit anything\n  if (rayBounds.x >= rayBounds.y)\n  {\n    traverseVals[vNum] = vec4<f32>(0.0,0.0,0.0,0.0);\n    return;\n  }\n\n  tpos = tpos + tstep*rayBounds.x;\n  var curDist: f32 = rayBounds.x;\n  var maxVal: f32 = -1.0e37;\n  loop\n  {\n    var scalar: f32 = getTextureValue(vTex, tpos);\n    if (scalar > maxVal)\n    {\n      maxVal = scalar;\n    }\n\n    // increment position\n    curDist = curDist + 1.0;\n    tpos = tpos + tstep;\n\n    // check if we have reached a terminating condition\n    if (curDist > rayBounds.y) { break; }\n  }\n\n  // process to get the color and opacity\n  traverseVals[vNum] = getSimpleColor(maxVal, vNum, cNum);\n}\n\nfn traverseMin(vTex: texture_3d<f32>, vNum: i32, cNum: i32, rayLengthSC: f32, minPosSC: vec4<f32>, rayStepSC: vec4<f32>)\n{\n  // convert to tcoords and reject if outside the volume\n  var numSteps: f32 = rayLengthSC/mapperUBO.SampleDistance;\n  var tpos: vec4<f32> = volumeSSBO.values[vNum].SCTCMatrix*minPosSC;\n  var tpos2: vec4<f32> = volumeSSBO.values[vNum].SCTCMatrix*(minPosSC + rayStepSC);\n  var tstep: vec4<f32> = tpos2 - tpos;\n\n  var rayBounds: vec2<f32> = adjustBounds(tpos, tstep, numSteps);\n\n  // did we hit anything\n  if (rayBounds.x >= rayBounds.y)\n  {\n    traverseVals[vNum] = vec4<f32>(0.0,0.0,0.0,0.0);\n    return;\n  }\n\n  tpos = tpos + tstep*rayBounds.x;\n  var curDist: f32 = rayBounds.x;\n  var minVal: f32 = 1.0e37;\n  loop\n  {\n    var scalar: f32 = getTextureValue(vTex, tpos);\n    if (scalar < minVal)\n    {\n      minVal = scalar;\n    }\n\n    // increment position\n    curDist = curDist + 1.0;\n    tpos = tpos + tstep;\n\n    // check if we have reached a terminating condition\n    if (curDist > rayBounds.y) { break; }\n  }\n\n  // process to get the color and opacity\n  traverseVals[vNum] = getSimpleColor(minVal, vNum, cNum);\n}\n\nfn traverseAverage(vTex: texture_3d<f32>, vNum: i32, cNum: i32, rayLengthSC: f32, minPosSC: vec4<f32>, rayStepSC: vec4<f32>)\n{\n  // convert to tcoords and reject if outside the volume\n  var numSteps: f32 = rayLengthSC/mapperUBO.SampleDistance;\n  var tpos: vec4<f32> = volumeSSBO.values[vNum].SCTCMatrix*minPosSC;\n  var tpos2: vec4<f32> = volumeSSBO.values[vNum].SCTCMatrix*(minPosSC + rayStepSC);\n  var tstep: vec4<f32> = tpos2 - tpos;\n\n  var rayBounds: vec2<f32> = adjustBounds(tpos, tstep, numSteps);\n\n  // did we hit anything\n  if (rayBounds.x >= rayBounds.y)\n  {\n    traverseVals[vNum] = vec4<f32>(0.0,0.0,0.0,0.0);\n    return;\n  }\n\n  let ipRange: vec4<f32> = volumeSSBO.values[vNum].ipScalarRange;\n  tpos = tpos + tstep*rayBounds.x;\n  var curDist: f32 = rayBounds.x;\n  var avgVal: f32 = 0.0;\n  var sampleCount: f32 = 0.0;\n  loop\n  {\n    var sample: f32 = getTextureValue(vTex, tpos);\n    // right now leave filtering off until WebGL changes get merged\n    // if (ipRange.z == 0.0 || sample >= ipRange.x && sample <= ipRange.y)\n    // {\n      avgVal = avgVal + sample;\n      sampleCount = sampleCount + 1.0;\n    // }\n\n    // increment position\n    curDist = curDist + 1.0;\n    tpos = tpos + tstep;\n\n    // check if we have reached a terminating condition\n    if (curDist > rayBounds.y) { break; }\n  }\n\n  if (sampleCount <= 0.0)\n  {\n    traverseVals[vNum] = vec4<f32>(0.0,0.0,0.0,0.0);\n  }\n\n  // process to get the color and opacity\n  traverseVals[vNum] = getSimpleColor(avgVal/sampleCount, vNum, cNum);\n}\n\nfn traverseAdditive(vTex: texture_3d<f32>, vNum: i32, cNum: i32, rayLengthSC: f32, minPosSC: vec4<f32>, rayStepSC: vec4<f32>)\n{\n  // convert to tcoords and reject if outside the volume\n  var numSteps: f32 = rayLengthSC/mapperUBO.SampleDistance;\n  var tpos: vec4<f32> = volumeSSBO.values[vNum].SCTCMatrix*minPosSC;\n  var tpos2: vec4<f32> = volumeSSBO.values[vNum].SCTCMatrix*(minPosSC + rayStepSC);\n  var tstep: vec4<f32> = tpos2 - tpos;\n\n  var rayBounds: vec2<f32> = adjustBounds(tpos, tstep, numSteps);\n\n  // did we hit anything\n  if (rayBounds.x >= rayBounds.y)\n  {\n    traverseVals[vNum] = vec4<f32>(0.0,0.0,0.0,0.0);\n    return;\n  }\n\n  let ipRange: vec4<f32> = volumeSSBO.values[vNum].ipScalarRange;\n  tpos = tpos + tstep*rayBounds.x;\n  var curDist: f32 = rayBounds.x;\n  var sumVal: f32 = 0.0;\n  loop\n  {\n    var sample: f32 = getTextureValue(vTex, tpos);\n    // right now leave filtering off until WebGL changes get merged\n    // if (ipRange.z == 0.0 || sample >= ipRange.x && sample <= ipRange.y)\n    // {\n      sumVal = sumVal + sample;\n    // }\n\n    // increment position\n    curDist = curDist + 1.0;\n    tpos = tpos + tstep;\n\n    // check if we have reached a terminating condition\n    if (curDist > rayBounds.y) { break; }\n  }\n\n  // process to get the color and opacity\n  traverseVals[vNum] = getSimpleColor(sumVal, vNum, cNum);\n}\n\nfn composite(rayLengthSC: f32, minPosSC: vec4<f32>, rayStepSC: vec4<f32>) -> vec4<f32>\n{\n  // initial ray position is at the beginning\n  var rayPosSC: vec4<f32> = minPosSC;\n\n  // how many rows (tfuns) do we have in our tfunTexture\n  var tfunRows: f32 = f32(textureDimensions(tfunTexture).y);\n\n  var curDist: f32 = 0.0;\n  var computedColor: vec4<f32> = vec4<f32>(0.0, 0.0, 0.0, 0.0);\n  var sampleColor: vec4<f32>;\n//VTK::Volume::TraverseCalls\n\n  loop\n  {\n    // for each volume, sample and accumulate color\n//VTK::Volume::CompositeCalls\n\n    // increment position\n    curDist = curDist + mapperUBO.SampleDistance;\n    rayPosSC = rayPosSC + rayStepSC;\n\n    // check if we have reached a terminating condition\n    if (curDist > rayLengthSC) { break; }\n    if (computedColor.a > 0.98) { break; }\n  }\n  return computedColor;\n}\n\n[[stage(fragment)]]\nfn main(\n//VTK::IOStructs::Input\n)\n//VTK::IOStructs::Output\n{\n  var output: fragmentOutput;\n\n  var rayMax: f32 = textureSampleLevel(maxTexture, clampSampler, input.tcoordVS, 0.0).r;\n  var rayMin: f32 = textureSampleLevel(minTexture, clampSampler, input.tcoordVS, 0.0).r;\n\n  // discard empty rays\n  if (rayMax <= rayMin) { discard; }\n  else\n  {\n    // compute start and end ray positions in view coordinates\n    var minPosSC: vec4<f32> = rendererUBO.PCSCMatrix*vec4<f32>(2.0 * input.tcoordVS.x - 1.0, 1.0 - 2.0 * input.tcoordVS.y, rayMax, 1.0);\n    minPosSC = minPosSC * (1.0 / minPosSC.w);\n    var maxPosSC: vec4<f32> = rendererUBO.PCSCMatrix*vec4<f32>(2.0 * input.tcoordVS.x - 1.0, 1.0 - 2.0 * input.tcoordVS.y, rayMin, 1.0);\n    maxPosSC = maxPosSC * (1.0 / maxPosSC.w);\n\n    var rayLengthSC: f32 = distance(minPosSC.xyz, maxPosSC.xyz);\n    var rayStepSC: vec4<f32> = (maxPosSC - minPosSC)*(mapperUBO.SampleDistance/rayLengthSC);\n    rayStepSC.w = 0.0;\n\n    var computedColor: vec4<f32>;\n\n//VTK::Volume::Loop\n\n//VTK::RenderEncoder::Impl\n  }\n\n  return output;\n}\n";
 var tmpMat4 = new Float64Array(16);
 var tmp2Mat4 = new Float64Array(16); // ----------------------------------------------------------------------------
 // vtkWebGPUVolumePassFSQ methods

package/package.json

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