@kitware/vtk.js 34.4.0 → 34.6.0

package/Rendering/OpenGL/ImageMapper.js

@@ -54,7 +54,7 @@ function vtkOpenGLImageMapper(publicAPI, model) {
     // The openGLTexture is not shared
     model.openGLTexture.releaseGraphicsResources(renderWindow);
     // All these other resources are shared
-    [model._colorTransferFunc, model._pwFunc, model._labelOutlineThicknessArray].forEach(coreObject => renderWindow.unregisterGraphicsResourceUser(coreObject, publicAPI));
+    [model._colorTransferFunc, model._pwFunc, model._labelOutlineThicknessArray, model._labelOutlineOpacity].forEach(coreObject => renderWindow.unregisterGraphicsResourceUser(coreObject, publicAPI));
   }
   publicAPI.buildPass = prepass => {
     if (prepass) {
@@ -131,7 +131,14 @@ function vtkOpenGLImageMapper(publicAPI, model) {
     // color shift and scale
     'uniform float cshift0;', 'uniform float cscale0;',
     // pwf shift and scale
-    'uniform float pwfshift0;', 'uniform float pwfscale0;', 'uniform sampler2D texture1;', 'uniform sampler2D colorTexture1;', 'uniform sampler2D pwfTexture1;', 'uniform sampler2D labelOutlineTexture1;', 'uniform float opacity;', 'uniform float outlineOpacity;'];
+    'uniform float pwfshift0;', 'uniform float pwfscale0;', 'uniform sampler2D texture1;', 'uniform sampler2D colorTexture1;', 'uniform sampler2D pwfTexture1;', 'uniform float opacity;'];
+    if (actor.getProperty().getUseLabelOutline()) {
+      tcoordDec = tcoordDec.concat([
+      // outline thickness
+      'uniform sampler2D labelOutlineTexture1;',
+      // outline opacity
+      'uniform sampler2D labelOutlineOpacityTexture1;']);
+    }
     if (iComps) {
       for (let comp = 1; comp < tNumComp; comp++) {
         tcoordDec = tcoordDec.concat([
@@ -167,7 +174,7 @@ function vtkOpenGLImageMapper(publicAPI, model) {
     // check for the outline thickness and opacity
     const vtkImageLabelOutline = actor.getProperty().getUseLabelOutline();
     if (vtkImageLabelOutline === true) {
-      FSSource = vtkShaderProgram.substitute(FSSource, '//VTK::LabelOutline::Dec', ['uniform int outlineThickness;', 'uniform float vpWidth;', 'uniform float vpHeight;', 'uniform float vpOffsetX;', 'uniform float vpOffsetY;', 'uniform mat4 PCWCMatrix;', 'uniform mat4 vWCtoIDX;', 'uniform ivec3 imageDimensions;', 'uniform int sliceAxis;']).result;
+      FSSource = vtkShaderProgram.substitute(FSSource, '//VTK::LabelOutline::Dec', ['uniform float vpWidth;', 'uniform float vpHeight;', 'uniform float vpOffsetX;', 'uniform float vpOffsetY;', 'uniform mat4 PCWCMatrix;', 'uniform mat4 vWCtoIDX;', 'uniform ivec3 imageDimensions;', 'uniform int sliceAxis;']).result;
       FSSource = vtkShaderProgram.substitute(FSSource, '//VTK::ImageLabelOutlineOn', '#define vtkImageLabelOutlineOn').result;
       FSSource = vtkShaderProgram.substitute(FSSource, '//VTK::LabelOutlineHelperFunction', ['#ifdef vtkImageLabelOutlineOn', 'vec3 fragCoordToIndexSpace(vec4 fragCoord) {', '  vec4 pcPos = vec4(', '    (fragCoord.x / vpWidth - vpOffsetX - 0.5) * 2.0,', '    (fragCoord.y / vpHeight - vpOffsetY - 0.5) * 2.0,', '    (fragCoord.z - 0.5) * 2.0,', '    1.0);', '', '  vec4 worldCoord = PCWCMatrix * pcPos;', '  vec4 vertex = (worldCoord/worldCoord.w);', '', '  vec3 index = (vWCtoIDX * vertex).xyz;', '', '  // half voxel fix for labelmapOutline', '  return (index + vec3(0.5)) / vec3(imageDimensions);', '}', 'vec2 getSliceCoords(vec3 coord, int axis) {', '  if (axis == 0) return coord.yz;', '  if (axis == 1) return coord.xz;', '  if (axis == 2) return coord.xy;', '}', '#endif']).result;
     }
@@ -209,6 +216,7 @@ function vtkOpenGLImageMapper(publicAPI, model) {
                   int segmentIndex = int(centerValue * 255.0);
                   float textureCoordinate = float(segmentIndex - 1) / 1024.0;
                   float textureValue = texture2D(labelOutlineTexture1, vec2(textureCoordinate, 0.5)).r;
+                  float outlineOpacity = texture2D(labelOutlineOpacityTexture1, vec2(textureCoordinate, 0.5)).r;
                   int actualThickness = int(textureValue * 255.0);
 
                   if (segmentIndex == 0){
@@ -301,7 +309,7 @@ function vtkOpenGLImageMapper(publicAPI, model) {
     if (!model.currentRenderPass && model.lastRenderPassShaderReplacement || model.currentRenderPass && model.currentRenderPass.getShaderReplacement() !== model.lastRenderPassShaderReplacement) {
       needRebuild = true;
     }
-    if (needRebuild || model.lastHaveSeenDepthRequest !== model.haveSeenDepthRequest || cellBO.getProgram()?.getHandle() === 0 || model.lastTextureComponents !== tNumComp || model.lastIndependentComponents !== iComp) {
+    if (needRebuild || model.lastHaveSeenDepthRequest !== model.haveSeenDepthRequest || cellBO.getProgram()?.getHandle() === 0 || cellBO.getShaderSourceTime().getMTime() < model.renderable.getMTime() || cellBO.getShaderSourceTime().getMTime() < model.currentInput.getMTime() || cellBO.getShaderSourceTime().getMTime() < actor.getProperty().getMTime() || model.lastTextureComponents !== tNumComp || model.lastIndependentComponents !== iComp) {
       model.lastHaveSeenDepthRequest = model.haveSeenDepthRequest;
       model.lastTextureComponents = tNumComp;
       model.lastIndependentComponents = iComp;
@@ -417,8 +425,12 @@ function vtkOpenGLImageMapper(publicAPI, model) {
     cellBO.getProgram().setUniformi('colorTexture1', texColorUnit);
     const texOpacityUnit = model.pwfTexture.getTextureUnit();
     cellBO.getProgram().setUniformi('pwfTexture1', texOpacityUnit);
-    const outlineThicknessUnit = model.labelOutlineThicknessTexture.getTextureUnit();
-    cellBO.getProgram().setUniformi('labelOutlineTexture1', outlineThicknessUnit);
+    if (actor.getProperty().getUseLabelOutline()) {
+      const outlineThicknessUnit = model.labelOutlineThicknessTexture.getTextureUnit();
+      cellBO.getProgram().setUniformi('labelOutlineTexture1', outlineThicknessUnit);
+      const texOutlineOpacityUnit = model.labelOutlineOpacityTexture.getTextureUnit();
+      cellBO.getProgram().setUniformi('labelOutlineOpacityTexture1', texOutlineOpacityUnit);
+    }
     if (model.renderable.getNumberOfClippingPlanes()) {
       // add all the clipping planes
       let numClipPlanes = model.renderable.getNumberOfClippingPlanes();
@@ -449,13 +461,6 @@ function vtkOpenGLImageMapper(publicAPI, model) {
       cellBO.getProgram().setUniformi('numClipPlanes', numClipPlanes);
       cellBO.getProgram().setUniform4fv('clipPlanes', planeEquations);
     }
-
-    // outline thickness and opacity
-    const vtkImageLabelOutline = actor.getProperty().getUseLabelOutline();
-    if (vtkImageLabelOutline === true) {
-      const outlineOpacity = actor.getProperty().getLabelOutlineOpacity();
-      cellBO.getProgram().setUniformf('outlineOpacity', outlineOpacity);
-    }
   };
   publicAPI.setCameraShaderParameters = (cellBO, ren, actor) => {
     const program = cellBO.getProgram();
@@ -516,7 +521,10 @@ function vtkOpenGLImageMapper(publicAPI, model) {
     // activate the texture
     model.openGLTexture.activate();
     model.colorTexture.activate();
-    model.labelOutlineThicknessTexture.activate();
+    if (actor.getProperty().getUseLabelOutline()) {
+      model.labelOutlineThicknessTexture.activate();
+      model.labelOutlineOpacityTexture.activate();
+    }
     model.pwfTexture.activate();
 
     // draw polygons
@@ -528,7 +536,10 @@ function vtkOpenGLImageMapper(publicAPI, model) {
     }
     model.openGLTexture.deactivate();
     model.colorTexture.deactivate();
-    model.labelOutlineThicknessTexture.deactivate();
+    if (actor.getProperty().getUseLabelOutline()) {
+      model.labelOutlineThicknessTexture.deactivate();
+      model.labelOutlineOpacityTexture.deactivate();
+    }
     model.pwfTexture.deactivate();
   };
   publicAPI.renderPieceFinish = (ren, actor) => {};
@@ -560,7 +571,7 @@ function vtkOpenGLImageMapper(publicAPI, model) {
       publicAPI.buildBufferObjects(ren, actor);
     }
   };
-  publicAPI.getNeedToRebuildBufferObjects = (ren, actor) => model.VBOBuildTime.getMTime() < publicAPI.getMTime() || model.VBOBuildTime.getMTime() < actor.getMTime() || model.VBOBuildTime.getMTime() < model.renderable.getMTime() || model.VBOBuildTime.getMTime() < actor.getProperty().getMTime() || model.VBOBuildTime.getMTime() < model.currentInput.getMTime() || !model.openGLTexture?.getHandle() || !model.colorTexture?.getHandle() || !model.labelOutlineThicknessTexture?.getHandle() || !model.pwfTexture?.getHandle();
+  publicAPI.getNeedToRebuildBufferObjects = (ren, actor) => model.VBOBuildTime.getMTime() < publicAPI.getMTime() || model.VBOBuildTime.getMTime() < actor.getMTime() || model.VBOBuildTime.getMTime() < model.renderable.getMTime() || model.VBOBuildTime.getMTime() < actor.getProperty().getMTime() || model.VBOBuildTime.getMTime() < model.currentInput.getMTime() || !model.openGLTexture?.getHandle() || !model.colorTexture?.getHandle() || actor.getProperty().getUseLabelOutline() && (!model.labelOutlineThicknessTexture?.getHandle() || !model.labelOutlineOpacityTexture?.getHandle()) || !model.pwfTexture?.getHandle();
   publicAPI.buildBufferObjects = (ren, actor) => {
     const image = model.currentInput;
     if (!image) {
@@ -740,9 +751,11 @@ function vtkOpenGLImageMapper(publicAPI, model) {
     } else {
       model.pwfTexture = pwfTex.oglObject;
     }
-
-    // Build outline thickness buffer
-    publicAPI.updatelabelOutlineThicknessTexture(actor);
+    if (actor.getProperty().getUseLabelOutline()) {
+      // Build outline thickness + opacity buffers
+      publicAPI.updatelabelOutlineThicknessTexture(actor);
+      publicAPI.updateLabelOutlineOpacityTexture(actor);
+    }
 
     // Find what IJK axis and what direction to slice along
     const {
@@ -955,6 +968,63 @@ function vtkOpenGLImageMapper(publicAPI, model) {
       model.VBOBuildString = toString;
     }
   };
+  publicAPI.updateLabelOutlineOpacityTexture = image => {
+    let labelOutlineOpacity = image.getProperty().getLabelOutlineOpacity();
+
+    // when the labelOutlineOpacity is a number, we use _cachedLabelOutlineOpacityObj
+    // as a stable object reference for `[labelOutlineOpacity]`.
+    if (typeof labelOutlineOpacity === 'number') {
+      if (model._cachedLabelOutlineOpacityObj?.[0] === labelOutlineOpacity) {
+        labelOutlineOpacity = model._cachedLabelOutlineOpacityObj;
+      } else {
+        labelOutlineOpacity = [labelOutlineOpacity];
+      }
+      model._cachedLabelOutlineOpacityObj = labelOutlineOpacity;
+    }
+    const lTex = model._openGLRenderWindow.getGraphicsResourceForObject(labelOutlineOpacity);
+    const toString = `${labelOutlineOpacity.join('-')}`;
+    const reBuildL = !lTex?.oglObject?.getHandle() || lTex?.hash !== toString;
+    if (reBuildL) {
+      let lWidth = model.renderable.getLabelOutlineTextureWidth();
+      if (lWidth <= 0) {
+        lWidth = model.context.getParameter(model.context.MAX_TEXTURE_SIZE);
+      }
+      const lHeight = 1;
+      const lSize = lWidth * lHeight;
+      const lTable = new Float32Array(lSize);
+      for (let i = 0; i < lWidth; ++i) {
+        // Retrieve the opacity value for the current segment index.
+        // If the value is undefined, use the first element's value as a default, otherwise use the value (even if 0)
+        lTable[i] = labelOutlineOpacity[i] ?? labelOutlineOpacity[0];
+      }
+      model.labelOutlineOpacityTexture = vtkOpenGLTexture.newInstance({
+        resizable: false
+      });
+      model.labelOutlineOpacityTexture.setOpenGLRenderWindow(model._openGLRenderWindow);
+      model.labelOutlineOpacityTexture.resetFormatAndType();
+      model.labelOutlineOpacityTexture.setMinificationFilter(Filter.NEAREST);
+      model.labelOutlineOpacityTexture.setMagnificationFilter(Filter.NEAREST);
+
+      // Create a 2D texture (acting as 1D) from the raw data
+      model.labelOutlineOpacityTexture.create2DFromRaw({
+        width: lWidth,
+        height: lHeight,
+        numComps: 1,
+        dataType: VtkDataTypes.FLOAT,
+        data: lTable
+      });
+      if (labelOutlineOpacity) {
+        model._openGLRenderWindow.setGraphicsResourceForObject(labelOutlineOpacity, model.labelOutlineOpacityTexture, toString);
+        if (labelOutlineOpacity !== model._labelOutlineOpacity) {
+          model._openGLRenderWindow.registerGraphicsResourceUser(labelOutlineOpacity, publicAPI);
+          model._openGLRenderWindow.unregisterGraphicsResourceUser(model._labelOutlineOpacity, publicAPI);
+        }
+        model._labelOutlineOpacity = labelOutlineOpacity;
+      }
+    } else {
+      model.labelOutlineOpacityTexture = lTex.oglObject;
+    }
+  };
   publicAPI.updatelabelOutlineThicknessTexture = image => {
     const labelOutlineThicknessArray = image.getProperty().getLabelOutlineThicknessByReference();
     const lTex = model._openGLRenderWindow.getGraphicsResourceForObject(labelOutlineThicknessArray);
@@ -1046,7 +1116,7 @@ const DEFAULT_VALUES = {
   colorTexture: null,
   pwfTexture: null,
   labelOutlineThicknessTexture: null,
-  labelOutlineThicknessTextureString: null,
+  labelOutlineOpacityTexture: null,
   lastHaveSeenDepthRequest: false,
   haveSeenDepthRequest: false,
   lastTextureComponents: 0

package/Rendering/OpenGL/PolyDataMapper2D.js

@@ -1,14 +1,14 @@
 import { mat4 } from 'gl-matrix';
 import { n as newInstance$1, e as setGet, o as obj, c as macro } from '../../macros2.js';
 import vtkHelper from './Helper.js';
-import vtkMapper2D from '../Core/Mapper2D.js';
 import vtkPoints from '../../Common/Core/Points.js';
 import { v as vtkPolyData2DFS } from './glsl/vtkPolyData2DFS.glsl.js';
 import { v as vtkPolyData2DVS } from './glsl/vtkPolyData2DVS.glsl.js';
 import vtkReplacementShaderMapper from './ReplacementShaderMapper.js';
 import vtkShaderProgram from './ShaderProgram.js';
 import vtkViewNode from '../SceneGraph/ViewNode.js';
-import { P as round } from '../../Common/Core/Math/index.js';
+import vtkOpenGLTexture from './Texture.js';
+import { Q as round } from '../../Common/Core/Math/index.js';
 import { DisplayLocation } from '../Core/Property2D/Constants.js';
 import { registerOverride } from './ViewNodeFactory.js';
 
@@ -17,8 +17,9 @@ const {
   primTypes
 } = vtkHelper;
 const {
-  ScalarMode
-} = vtkMapper2D;
+  Filter,
+  Wrap
+} = vtkOpenGLTexture;
 const {
   vtkErrorMacro
 } = macro;
@@ -82,6 +83,11 @@ function vtkOpenGLPolyDataMapper2D(publicAPI, model) {
     if (!model.currentInput.getPoints || !model.currentInput.getPoints().getNumberOfValues()) {
       return;
     }
+
+    // cull back face to avoid double drawing
+    const gl = model.context;
+    model._openGLRenderWindow.enableCullFace();
+    gl.cullFace(gl.BACK);
     publicAPI.renderPieceStart(ren, actor);
     publicAPI.renderPieceDraw(ren, actor);
     publicAPI.renderPieceFinish(ren, actor);
@@ -94,6 +100,13 @@ function vtkOpenGLPolyDataMapper2D(publicAPI, model) {
           model._openGLRenderer.getSelector().renderProp(actor);
       }
     }
+
+    // If we are coloring by texture, then load the texture map.
+    // Use Map as indicator, because texture hangs around.
+    if (model.renderable.getColorTextureMap()) {
+      model.internalColorTexture.activate();
+    }
+
     // make sure the BOs are up to date
     publicAPI.updateBufferObjects(ren, actor);
 
@@ -133,19 +146,44 @@ function vtkOpenGLPolyDataMapper2D(publicAPI, model) {
     }
     model.renderable.mapScalars(poly, actor.getProperty().getOpacity());
     const c = model.renderable.getColorMapColors();
-    model.haveCellScalars = false;
-    const scalarMode = model.renderable.getScalarMode();
-    if (model.renderable.getScalarVisibility()) {
-      // We must figure out how the scalars should be mapped to the polydata.
-      if ((scalarMode === ScalarMode.USE_CELL_DATA || scalarMode === ScalarMode.USE_CELL_FIELD_DATA || scalarMode === ScalarMode.USE_FIELD_DATA || !poly.getPointData().getScalars()) && scalarMode !== ScalarMode.USE_POINT_FIELD_DATA && c) {
-        model.haveCellScalars = true;
-      }
-    }
     const representation = actor.getProperty().getRepresentation();
     let tcoords = poly.getPointData().getTCoords();
     if (!model.openGLActor2D.getActiveTextures()) {
       tcoords = null;
     }
+
+    // Flag to check if tcoords are per cell instead of per point
+    let useTCoordsPerCell = false;
+    // handle color mapping via texture
+    if (model.renderable.getColorCoordinates()) {
+      tcoords = model.renderable.getColorCoordinates();
+      useTCoordsPerCell = model.renderable.getAreScalarsMappedFromCells();
+      if (!model.internalColorTexture) {
+        model.internalColorTexture = vtkOpenGLTexture.newInstance({
+          resizable: true
+        });
+      }
+      const tex = model.internalColorTexture;
+      // the following 4 lines allow for NPOT textures
+      tex.setMinificationFilter(Filter.NEAREST);
+      tex.setMagnificationFilter(Filter.NEAREST);
+      tex.setWrapS(Wrap.CLAMP_TO_EDGE);
+      tex.setWrapT(Wrap.CLAMP_TO_EDGE);
+      tex.setOpenGLRenderWindow(model._openGLRenderWindow);
+      const input = model.renderable.getColorTextureMap();
+      const ext = input.getExtent();
+      const inScalars = input.getPointData().getScalars();
+      tex.create2DFromRaw({
+        width: ext[1] - ext[0] + 1,
+        height: ext[3] - ext[2] + 1,
+        numComps: inScalars.getNumberOfComponents(),
+        dataType: inScalars.getDataType(),
+        data: inScalars.getData()
+      });
+      tex.activate();
+      tex.sendParameters();
+      tex.deactivate();
+    }
     const transformCoordinate = model.renderable.getTransformCoordinate();
     const view = ren.getRenderWindow().getViews()[0];
     const vsize = view.getViewportSize(ren);
@@ -171,7 +209,8 @@ function vtkOpenGLPolyDataMapper2D(publicAPI, model) {
         tcoords,
         colors: c,
         cellOffset: 0,
-        haveCellScalars: model.haveCellSCalars,
+        useTCoordsPerCell,
+        haveCellScalars: model.renderable.getAreScalarsMappedFromCells(),
         customAttributes: model.renderable.getCustomShaderAttributes().map(arrayName => poly.getPointData().getArrayByName(arrayName))
       };
       options.cellOffset += model.primitives[primTypes.Points].getCABO().createVBO(poly.getVerts(), 'verts', representation, options);
@@ -201,6 +240,9 @@ function vtkOpenGLPolyDataMapper2D(publicAPI, model) {
     if (model.lastBoundBO) {
       model.lastBoundBO.getVAO().release();
     }
+    if (model.renderable.getColorTextureMap()) {
+      model.internalColorTexture.deactivate();
+    }
   };
   publicAPI.replaceShaderValues = (shaders, ren, actor) => {
     publicAPI.replaceShaderColor(shaders, ren, actor);
@@ -212,21 +254,28 @@ function vtkOpenGLPolyDataMapper2D(publicAPI, model) {
     let VSSource = shaders.Vertex;
     let GSSource = shaders.Geometry;
     let FSSource = shaders.Fragment;
-    if (model.haveCellScalars) {
-      FSSource = vtkShaderProgram.substitute(FSSource, '//VTK::Color::Dec', ['uniform samplerBuffer texture1;']).result;
-      FSSource = vtkShaderProgram.substitute(FSSource, '//VTK::Color::Impl', ['gl_FragData[0] = texelFetchBuffer(texture1, gl_PrimitiveID + PrimitiveIDOffset);']).result;
-    }
+
+    // create the color property declarations
+    // these are always defined
+    let colorDec = ['uniform vec3 diffuseColorUniform;', 'uniform float opacityUniform;'];
+
+    // now handle the more complex fragment shader implementation
+    let colorImpl = ['vec3 diffuseColor = diffuseColorUniform;', 'float opacity = opacityUniform;'];
+
+    // add scalar vertex colors
     if (model.lastBoundBO.getCABO().getColorComponents() !== 0) {
-      VSSource = vtkShaderProgram.substitute(VSSource, '//VTK::Color::Dec', ['in vec4 diffuseColor;', 'out vec4 fcolorVSOutput;']).result;
-      VSSource = vtkShaderProgram.substitute(VSSource, '//VTK::Color::Impl', ['fcolorVSOutput = diffuseColor;']).result;
-      GSSource = vtkShaderProgram.substitute(GSSource, '//VTK::Color::Dec', ['in vec4 fcolorVSOutput[];\n', 'out vec4 fcolorGSOutput;']).result;
-      GSSource = vtkShaderProgram.substitute(GSSource, '//VTK::Color::Impl', ['fcolorGSOutput = fcolorVSOutput[i];']).result;
-      FSSource = vtkShaderProgram.substitute(FSSource, '//VTK::Color::Dec', ['in vec4 fcolorVSOutput;']).result;
-      FSSource = vtkShaderProgram.substitute(FSSource, '//VTK::Color::Impl', ['gl_FragData[0] = fcolorVSOutput;']).result;
-    } else {
-      FSSource = vtkShaderProgram.substitute(FSSource, '//VTK::Color::Dec', ['uniform vec4 diffuseColor;']).result;
-      FSSource = vtkShaderProgram.substitute(FSSource, '//VTK::Color::Impl', ['gl_FragData[0] = diffuseColor;']).result;
+      colorDec = colorDec.concat(['varying vec4 vertexColorVSOutput;']);
+      VSSource = vtkShaderProgram.substitute(VSSource, '//VTK::Color::Dec', ['attribute vec4 scalarColor;', 'varying vec4 vertexColorVSOutput;']).result;
+      VSSource = vtkShaderProgram.substitute(VSSource, '//VTK::Color::Impl', ['vertexColorVSOutput =  scalarColor;']).result;
+      GSSource = vtkShaderProgram.substitute(GSSource, '//VTK::Color::Dec', ['in vec4 vertexColorVSOutput[];', 'out vec4 vertexColorGSOutput;']).result;
+      GSSource = vtkShaderProgram.substitute(GSSource, '//VTK::Color::Impl', ['vertexColorGSOutput = vertexColorVSOutput[i];']).result;
+      FSSource = vtkShaderProgram.substitute(FSSource, '//VTK::Color::Impl', colorImpl.concat(['  diffuseColor = vertexColorVSOutput.rgb;', '  opacity = opacity*vertexColorVSOutput.a;'])).result;
+    } else if (model.renderable.getAreScalarsMappedFromCells()) {
+      colorImpl = colorImpl.concat(['  vec4 texColor = texture2D(texture1, tcoordVCVSOutput.st);', '  diffuseColor = texColor.rgb;', '  opacity = opacity*texColor.a;']);
     }
+    colorImpl = colorImpl.concat(['gl_FragData[0] = vec4(diffuseColor, opacity);']);
+    FSSource = vtkShaderProgram.substitute(FSSource, '//VTK::Color::Dec', colorDec).result;
+    FSSource = vtkShaderProgram.substitute(FSSource, '//VTK::Color::Impl', colorImpl).result;
     shaders.Vertex = VSSource;
     shaders.Geometry = GSSource;
     shaders.Fragment = FSSource;
@@ -252,7 +301,7 @@ function vtkOpenGLPolyDataMapper2D(publicAPI, model) {
         FSSource = vtkShaderProgram.substitute(FSSource, '//VTK::TCoord::Dec', ['in vec2 tcoordVCVSOutput;', 'uniform sampler2D texture1;']).result;
         FSSource = vtkShaderProgram.substitute(FSSource, '//VTK::TCoord::Impl', ['gl_FragData[0] = gl_FragData[0]*texture2D(texture1, tcoordVCVSOutput.st);']).result;
       }
-      if (model.haveCellScalars) {
+      if (model.renderable.getAreScalarsMappedFromCells()) {
         GSSource = vtkShaderProgram.substitute(GSSource, '//VTK::PrimID::Impl', ['gl_PrimitiveID = gl_PrimitiveIDIn;']).result;
       }
       shaders.Vertex = VSSource;
@@ -303,8 +352,18 @@ function vtkOpenGLPolyDataMapper2D(publicAPI, model) {
       } else {
         cellBO.getVAO().removeAttributeArray('tcoordMC');
       }
+      if (cellBO.getProgram().isAttributeUsed('scalarColor') && cellBO.getCABO().getColorComponents()) {
+        if (!cellBO.getVAO().addAttributeArray(cellBO.getProgram(), cellBO.getCABO().getColorBO(), 'scalarColor', cellBO.getCABO().getColorOffset(), cellBO.getCABO().getColorBOStride(), model.context.UNSIGNED_BYTE, 4, true)) {
+          vtkErrorMacro('Error setting scalarColor in shader VAO.');
+        }
+      } else {
+        cellBO.getVAO().removeAttributeArray('scalarColor');
+      }
       if (model.internalColorTexture && cellBO.getProgram().isUniformUsed('texture1')) {
-        cellBO.getProgram().setUniformi('texture1', model.internalColorTexture.getTextureUnit());
+        const texUnit = model.internalColorTexture.getTextureUnit();
+        if (texUnit > -1) {
+          cellBO.getProgram().setUniformi('texture1', model.internalColorTexture.getTextureUnit());
+        }
       }
       const tus = model.openGLActor2D.getActiveTextures();
       if (tus) {
@@ -331,9 +390,9 @@ function vtkOpenGLPolyDataMapper2D(publicAPI, model) {
       const program = cellBO.getProgram();
       const ppty = actor.getProperty();
       const opacity = ppty.getOpacity();
+      program.setUniformf('opacityUniform', opacity);
       const dColor = ppty.getColor();
-      const diffuseColor = [dColor[0], dColor[1], dColor[2], opacity];
-      program.setUniform4f('diffuseColor', diffuseColor);
+      program.setUniform3fArray('diffuseColorUniform', dColor);
     }
   };
   publicAPI.setLightingShaderParameters = (cellBO, ren, actor) => {

package/Rendering/OpenGL/Texture.js

@@ -3,7 +3,7 @@ import Constants from './Texture/Constants.js';
 import HalfFloat from '../../Common/Core/HalfFloat.js';
 import { n as newInstance$1, o as obj, s as set, e as setGet, g as get, i as moveToProtected, a as newTypedArray, c as macro } from '../../macros2.js';
 import vtkDataArray from '../../Common/Core/DataArray.js';
-import { W as isPowerOfTwo, R as nearestPowerOfTwo } from '../../Common/Core/Math/index.js';
+import { X as isPowerOfTwo, S as nearestPowerOfTwo } from '../../Common/Core/Math/index.js';
 import vtkViewNode from '../SceneGraph/ViewNode.js';
 import { registerOverride } from './ViewNodeFactory.js';
 import supportsNorm16LinearCached from './Texture/supportsNorm16Linear.js';

package/Rendering/OpenGL/VolumeMapper.js

@@ -958,20 +958,28 @@ function vtkOpenGLVolumeMapper(publicAPI, model) {
         });
       }
     }
-    const volumeProperties = actor.getProperties();
-    const firstValidInput = model.currentValidInputs[0];
-    const firstImageData = firstValidInput.imageData;
-    const firstScalars = firstImageData.getPointData().getScalars();
-    const firstVolumeProperty = volumeProperties[firstValidInput.inputIndex];
-
-    // Get the number of lights
     let newNumberOfLights = 0;
-    if (firstVolumeProperty.getShade() && model.renderable.getBlendMode() === BlendMode.COMPOSITE_BLEND) {
-      ren.getLights().forEach(light => {
-        if (light.getSwitch() > 0) {
-          newNumberOfLights++;
-        }
-      });
+    if (model.currentValidInputs.length > 0) {
+      const volumeProperties = actor.getProperties();
+      const firstValidInput = model.currentValidInputs[0];
+      const firstImageData = firstValidInput.imageData;
+      const firstScalars = firstImageData.getPointData().getScalars();
+      const firstVolumeProperty = volumeProperties[firstValidInput.inputIndex];
+
+      // Get the number of lights
+      if (firstVolumeProperty.getShade() && model.renderable.getBlendMode() === BlendMode.COMPOSITE_BLEND) {
+        ren.getLights().forEach(light => {
+          if (light.getSwitch() > 0) {
+            newNumberOfLights++;
+          }
+        });
+      }
+
+      // Number of components
+      const numberOfValidInputs = model.currentValidInputs.length;
+      const multiTexturePerVolumeEnabled = numberOfValidInputs > 1;
+      model.numberOfComponents = multiTexturePerVolumeEnabled ? numberOfValidInputs : firstScalars.getNumberOfComponents();
+      model.useIndependentComponents = getUseIndependentComponents(firstVolumeProperty, model.numberOfComponents);
     }
     if (newNumberOfLights !== model.numberOfLights) {
       model.numberOfLights = newNumberOfLights;
@@ -983,12 +991,6 @@ function vtkOpenGLVolumeMapper(publicAPI, model) {
     if (model.currentValidInputs.length === 0) {
       return;
     }
-
-    // Number of components
-    const numberOfValidInputs = model.currentValidInputs.length;
-    const multiTexturePerVolumeEnabled = numberOfValidInputs > 1;
-    model.numberOfComponents = multiTexturePerVolumeEnabled ? numberOfValidInputs : firstScalars.getNumberOfComponents();
-    model.useIndependentComponents = getUseIndependentComponents(firstVolumeProperty, model.numberOfComponents);
     publicAPI.renderPieceStart(ren, actor);
     publicAPI.renderPieceDraw(ren, actor);
     publicAPI.renderPieceFinish(ren, actor);

package/Widgets/Manipulators/LineManipulator.js

@@ -1,5 +1,5 @@
 import { m as macro } from '../../macros2.js';
-import { d as dot, s as subtract, j as cross, w as multiplyScalar, k as add } from '../../Common/Core/Math/index.js';
+import { d as dot, s as subtract, j as cross, x as multiplyScalar, k as add } from '../../Common/Core/Math/index.js';
 import vtkAbstractManipulator from './AbstractManipulator.js';
 import { EPSILON } from '../../Common/Core/Math/Constants.js';
 

package/Widgets/Representations/PolyLineRepresentation.js

@@ -1,7 +1,7 @@
 import { m as macro } from '../../macros2.js';
 import vtkActor from '../../Rendering/Core/Actor.js';
 import vtkMapper from '../../Rendering/Core/Mapper.js';
-import { D as areEquals } from '../../Common/Core/Math/index.js';
+import { E as areEquals } from '../../Common/Core/Math/index.js';
 import vtkBoundingBox from '../../Common/DataModel/BoundingBox.js';
 import vtkTubeFilter from '../../Filters/General/TubeFilter.js';
 import { getPixelWorldHeightAtCoord } from '../Core/WidgetManager.js';

package/Widgets/Widgets3D/AngleWidget.js

@@ -3,7 +3,7 @@ import vtkAbstractWidgetFactory from '../Core/AbstractWidgetFactory.js';
 import vtkPlanePointManipulator from '../Manipulators/PlaneManipulator.js';
 import vtkPolyLineRepresentation from '../Representations/PolyLineRepresentation.js';
 import vtkSphereHandleRepresentation from '../Representations/SphereHandleRepresentation.js';
-import { s as subtract, X as angleBetweenVectors } from '../../Common/Core/Math/index.js';
+import { s as subtract, Y as angleBetweenVectors } from '../../Common/Core/Math/index.js';
 import widgetBehavior from './AngleWidget/behavior.js';
 import generateState from './AngleWidget/state.js';
 import { ViewTypes } from '../Core/WidgetManager/Constants.js';

package/Widgets/Widgets3D/LineWidget/helpers.js

@@ -1,4 +1,4 @@
-import { s as subtract, w as multiplyScalar, k as add, D as areEquals } from '../../../Common/Core/Math/index.js';
+import { s as subtract, x as multiplyScalar, k as add, E as areEquals } from '../../../Common/Core/Math/index.js';
 
 function calculateTextPosition(model) {
   const vector = [0, 0, 0];

package/Widgets/Widgets3D/ResliceCursorWidget/behavior.js

@@ -1,7 +1,7 @@
 import { m as macro } from '../../../macros2.js';
 import vtkBoundingBox from '../../../Common/DataModel/BoundingBox.js';
 import vtkLine from '../../../Common/DataModel/Line.js';
-import { k as add, l as normalize, s as subtract, d as dot, j as cross, m as multiplyAccumulate, w as multiplyScalar, Y as signedAngleBetweenVectors } from '../../../Common/Core/Math/index.js';
+import { k as add, l as normalize, s as subtract, d as dot, j as cross, m as multiplyAccumulate, x as multiplyScalar, Z as signedAngleBetweenVectors } from '../../../Common/Core/Math/index.js';
 import { getLineNames, getOtherLineName, updateState, boundPointOnPlane, getLinePlaneName, getLineInPlaneName, rotateVector } from './helpers.js';
 import { InteractionMethodsName, ScrollingMethods, planeNameToViewType } from './Constants.js';
 

package/Widgets/Widgets3D/ResliceCursorWidget/helpers.js

@@ -2,7 +2,7 @@ import vtkBoundingBox, { STATIC } from '../../../Common/DataModel/BoundingBox.js
 import vtkCubeSource from '../../../Filters/Sources/CubeSource.js';
 import vtkCutter from '../../../Filters/Core/Cutter.js';
 import vtkPlane from '../../../Common/DataModel/Plane.js';
-import { s as subtract, l as normalize, j as cross, w as multiplyScalar, m as multiplyAccumulate, Y as signedAngleBetweenVectors } from '../../../Common/Core/Math/index.js';
+import { s as subtract, l as normalize, j as cross, x as multiplyScalar, m as multiplyAccumulate, Z as signedAngleBetweenVectors } from '../../../Common/Core/Math/index.js';
 import vtkMatrixBuilder from '../../../Common/Core/MatrixBuilder.js';
 import { viewTypeToPlaneName, planeNameToViewType, planeNames } from './Constants.js';
 

package/Widgets/Widgets3D/ResliceCursorWidget.js

@@ -7,7 +7,7 @@ import vtkPlaneSource from '../../Filters/Sources/PlaneSource.js';
 import vtkPlanePointManipulator from '../Manipulators/PlaneManipulator.js';
 import vtkLineHandleRepresentation from '../Representations/LineHandleRepresentation.js';
 import vtkSphereHandleRepresentation from '../Representations/SphereHandleRepresentation.js';
-import { e as distance2BetweenPoints, m as multiplyAccumulate, s as subtract, l as normalize, w as multiplyScalar, k as add } from '../../Common/Core/Math/index.js';
+import { e as distance2BetweenPoints, m as multiplyAccumulate, s as subtract, l as normalize, x as multiplyScalar, k as add } from '../../Common/Core/Math/index.js';
 import widgetBehavior from './ResliceCursorWidget/behavior.js';
 import generateState from './ResliceCursorWidget/state.js';
 import { updateState, transformPlane, boundPlane } from './ResliceCursorWidget/helpers.js';

package/index.d.ts

@@ -52,6 +52,7 @@
 /// <reference path="./Common/DataModel/Spline3D/Constants.d.ts" />
 /// <reference path="./Common/DataModel/Spline3D.d.ts" />
 /// <reference path="./Common/DataModel/Triangle.d.ts" />
+/// <reference path="./Common/DataModel/TriangleStrip.d.ts" />
 /// <reference path="./Common/Transform/LandmarkTransform.d.ts" />
 /// <reference path="./Common/Transform/Transform.d.ts" />
 /// <reference path="./Filters/Core/ThresholdPoints.d.ts" />
@@ -66,6 +67,7 @@
 /// <reference path="./Filters/General/ImageStreamline.d.ts" />
 /// <reference path="./Filters/General/LineFilter.d.ts" />
 /// <reference path="./Filters/General/OutlineFilter.d.ts" />
+/// <reference path="./Filters/General/TransformPolyDataFilter.d.ts" />
 /// <reference path="./Filters/General/TriangleFilter.d.ts" />
 /// <reference path="./Filters/General/TubeFilter.d.ts" />
 /// <reference path="./Filters/Sources/Arrow2DSource.d.ts" />

package/package.json

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