@kitware/vtk.js 24.0.3 → 24.2.1

package/Common/DataModel/BoundingBox.js

@@ -165,6 +165,30 @@ function _scale(bounds, sx, sy, sz) {
 function _getCenter(bounds) {
   return [0.5 * (bounds[0] + bounds[1]), 0.5 * (bounds[2] + bounds[3]), 0.5 * (bounds[4] + bounds[5])];
 }
+function scaleAboutCenter(bounds, sx, sy, sz) {
+  if (!_isValid(bounds)) {
+    return false;
+  }
+
+  var center = _getCenter(bounds);
+
+  bounds[0] -= center[0];
+  bounds[1] -= center[0];
+  bounds[2] -= center[1];
+  bounds[3] -= center[1];
+  bounds[4] -= center[2];
+  bounds[5] -= center[2];
+
+  _scale(bounds, sx, sy, sz);
+
+  bounds[0] += center[0];
+  bounds[1] += center[0];
+  bounds[2] += center[1];
+  bounds[3] += center[1];
+  bounds[4] += center[2];
+  bounds[5] += center[2];
+  return true;
+}
 
 function _getLength(bounds, index) {
   return bounds[index * 2 + 1] - bounds[index * 2];
@@ -253,12 +277,9 @@ function _computeCornerPoints(bounds, point1, point2) {
 
 function _computeScale(bounds) {
   var scale3 = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : [];
-
-  var center = _getCenter(bounds);
-
-  scale3[0] = bounds[1] - center[0];
-  scale3[1] = bounds[3] - center[1];
-  scale3[2] = bounds[5] - center[2];
+  scale3[0] = 0.5 * (bounds[1] - bounds[0]);
+  scale3[1] = 0.5 * (bounds[3] - bounds[2]);
+  scale3[2] = 0.5 * (bounds[5] - bounds[4]);
   return scale3;
 }
 
@@ -756,6 +777,7 @@ var STATIC = {
   setMaxPoint: _setMaxPoint,
   inflate: _inflate,
   scale: _scale,
+  scaleAboutCenter: scaleAboutCenter,
   getCenter: _getCenter,
   getLength: _getLength,
   getLengths: _getLengths,
@@ -783,4 +805,4 @@ var vtkBoundingBox = _objectSpread({
   newInstance: newInstance
 }, STATIC);
 
-export { STATIC, _addBounds as addBounds, _addPoint as addPoint, _computeCornerPoints as computeCornerPoints, _computeLocalBounds as computeLocalBounds, _computeScale as computeScale3, contains, _containsPoint as containsPoint, _cutWithPlane as cutWithPlane, vtkBoundingBox as default, _equals as equals, _getCenter as getCenter, _getCorners as getCorners, _getDiagonalLength as getDiagonalLength, _getLength as getLength, _getLengths as getLengths, _getMaxLength as getMaxLength, _getMaxPoint as getMaxPoint, _getMinPoint as getMinPoint, _getXRange as getXRange, _getYRange as getYRange, _getZRange as getZRange, _inflate as inflate, _intersect as intersect, _intersectBox as intersectBox, _intersectPlane as intersectPlane, _intersects as intersects, _isValid as isValid, _reset as reset, _scale as scale, _setBounds as setBounds, _setMaxPoint as setMaxPoint, _setMinPoint as setMinPoint };
+export { STATIC, _addBounds as addBounds, _addPoint as addPoint, _computeCornerPoints as computeCornerPoints, _computeLocalBounds as computeLocalBounds, _computeScale as computeScale3, contains, _containsPoint as containsPoint, _cutWithPlane as cutWithPlane, vtkBoundingBox as default, _equals as equals, _getCenter as getCenter, _getCorners as getCorners, _getDiagonalLength as getDiagonalLength, _getLength as getLength, _getLengths as getLengths, _getMaxLength as getMaxLength, _getMaxPoint as getMaxPoint, _getMinPoint as getMinPoint, _getXRange as getXRange, _getYRange as getYRange, _getZRange as getZRange, _inflate as inflate, _intersect as intersect, _intersectBox as intersectBox, _intersectPlane as intersectPlane, _intersects as intersects, _isValid as isValid, _reset as reset, _scale as scale, scaleAboutCenter, _setBounds as setBounds, _setMaxPoint as setMaxPoint, _setMinPoint as setMinPoint };

package/Rendering/Core/CubeAxesActor.js

@@ -684,6 +684,21 @@ function vtkCubeAxesActor(publicAPI, model) {
     model.axisTextStyle = _objectSpread(_objectSpread({}, model.axisTextStyle), axisStyle);
     publicAPI.modified();
   };
+
+  publicAPI.get_tmAtlas = function () {
+    return model._tmAtlas;
+  }; // try to get the bounds for the annotation. This is complicated
+  // as it relies on the pixel size of the window. Every time the camera
+  // changes the bounds change. This method simplifies by just expanding
+  // the grid bounds by a user specified factor.
+
+
+  publicAPI.getBounds = function () {
+    publicAPI.update();
+    vtkBoundingBox.setBounds(model.bounds, model.gridActor.getBounds());
+    vtkBoundingBox.scaleAboutCenter(model.bounds, model.boundsScaleFactor);
+    return model.bounds;
+  };
 } // ----------------------------------------------------------------------------
 // Object factory
 // ----------------------------------------------------------------------------
@@ -691,6 +706,7 @@ function vtkCubeAxesActor(publicAPI, model) {
 
 function defaultValues(initialValues) {
   return _objectSpread({
+    boundsScaleFactor: 1.3,
     camera: null,
     dataBounds: _toConsumableArray(vtkBoundingBox.INIT_BOUNDS),
     faceVisibilityAngle: 8,
@@ -741,10 +757,10 @@ function extend(publicAPI, model) {
   model.gridActor.setProperty(publicAPI.getProperty());
   model.gridActor.setParentProp(publicAPI);
   model.textPolyData = vtkPolyData.newInstance();
-  macro.setGet(publicAPI, model, ['axisTitlePixelOffset', 'faceVisibilityAngle', 'gridLines', 'tickLabelPixelOffset']);
+  macro.setGet(publicAPI, model, ['axisTitlePixelOffset', 'boundsScaleFactor', 'faceVisibilityAngle', 'gridLines', 'tickLabelPixelOffset']);
   macro.setGetArray(publicAPI, model, ['dataBounds'], 6);
   macro.setGetArray(publicAPI, model, ['axisLabels'], 3);
-  macro.get(publicAPI, model, ['axisTextStyle', 'tickTextStyle', 'camera', 'tmTexture', 'textValues', 'textPolyData', '_tmAtlas', 'tickCounts', 'gridActor']); // Object methods
+  macro.get(publicAPI, model, ['axisTextStyle', 'tickTextStyle', 'camera', 'tmTexture', 'textValues', 'textPolyData', 'tickCounts', 'gridActor']); // Object methods
 
   vtkCubeAxesActor(publicAPI, model);
 } // ----------------------------------------------------------------------------

package/Rendering/OpenGL/Glyph3DMapper.js

@@ -331,9 +331,10 @@ function vtkOpenGLGlyph3DMapper(publicAPI, model) {
       if (cabo.getElementCount()) {
         // are we drawing edges
         model.drawingEdges = drawSurfaceWithEdges && (i === model.primTypes.TrisEdges || i === model.primTypes.TriStripsEdges);
-        publicAPI.updateShaders(model.primitives[i], ren, actor);
+        model.lastBoundBO = model.primitives[i];
+        model.primitives[i].updateShaders(ren, actor, publicAPI);
         var program = model.primitives[i].getProgram();
-        var mode = publicAPI.getOpenGLMode(representation, i);
+        var mode = model.primitives[i].getOpenGLMode(representation);
         var normalMatrixUsed = program.isUniformUsed('normalMatrix');
         var mcvcMatrixUsed = program.isUniformUsed('MCVCMatrix');
 
@@ -413,6 +414,14 @@ function vtkOpenGLGlyph3DMapper(publicAPI, model) {
     return superClass.getNeedToRebuildBufferObjects(ren, actor);
   };
 
+  publicAPI.getNeedToRebuildShaders = function (cellBO, ren, actor) {
+    if (superClass.getNeedToRebuildShaders(cellBO, ren, actor) || cellBO.getShaderSourceTime().getMTime() < model.renderable.getMTime() || cellBO.getShaderSourceTime().getMTime() < model.currentInput.getMTime()) {
+      return true;
+    }
+
+    return false;
+  };
+
   publicAPI.buildBufferObjects = function (ren, actor) {
     if (model.hardwareSupport) {
       // update the buffer objects if needed

package/Rendering/OpenGL/Helper.js

@@ -2,7 +2,18 @@ import macro from '../../macros.js';
 import vtkCellArrayBufferObject from './CellArrayBufferObject.js';
 import vtkShaderProgram from './ShaderProgram.js';
 import vtkVertexArrayObject from './VertexArrayObject.js';
+import { Representation } from '../Core/Property/Constants.js';
 
+var primTypes = {
+  Start: 0,
+  Points: 0,
+  Lines: 1,
+  Tris: 2,
+  TriStrips: 3,
+  TrisEdges: 4,
+  TriStripsEdges: 5,
+  End: 6
+}; // ----------------------------------------------------------------------------
 // vtkOpenGLHelper methods
 // ----------------------------------------------------------------------------
 
@@ -11,7 +22,8 @@ function vtkOpenGLHelper(publicAPI, model) {
   model.classHierarchy.push('vtkOpenGLHelper');
 
   publicAPI.setOpenGLRenderWindow = function (win) {
-    model.program.setContext(win.getContext());
+    model.context = win.getContext();
+    model.program.setContext(model.context);
     model.VAO.setOpenGLRenderWindow(win);
     model.CABO.setOpenGLRenderWindow(win);
   };
@@ -21,12 +33,141 @@ function vtkOpenGLHelper(publicAPI, model) {
     model.CABO.releaseGraphicsResources();
     model.CABO.setElementCount(0);
   };
+
+  publicAPI.drawArrays = function (ren, actor, rep, oglMapper) {
+    // Are there any entries
+    if (model.CABO.getElementCount()) {
+      // are we drawing edges
+      var mode = publicAPI.getOpenGLMode(rep);
+      var wideLines = publicAPI.haveWideLines(ren, actor);
+      var gl = model.context;
+      var drawingLines = mode === gl.LINES;
+
+      if (drawingLines && wideLines) {
+        publicAPI.updateShaders(ren, actor, oglMapper);
+        gl.drawArraysInstanced(mode, 0, model.CABO.getElementCount(), 2 * Math.ceil(actor.getProperty().getLineWidth()));
+      } else {
+        gl.lineWidth(actor.getProperty().getLineWidth());
+        publicAPI.updateShaders(ren, actor, oglMapper);
+        gl.drawArrays(mode, 0, model.CABO.getElementCount()); // reset the line width
+
+        gl.lineWidth(1);
+      }
+
+      var stride = (mode === gl.POINTS ? 1 : 0) || (mode === gl.LINES ? 2 : 3);
+      return model.CABO.getElementCount() / stride;
+    }
+
+    return 0;
+  };
+
+  publicAPI.getOpenGLMode = function (rep) {
+    var type = model.primitiveType;
+
+    if (rep === Representation.POINTS || type === primTypes.Points) {
+      return model.context.POINTS;
+    }
+
+    if (rep === Representation.WIREFRAME || type === primTypes.Lines || type === primTypes.TrisEdges || type === primTypes.TriStripsEdges) {
+      return model.context.LINES;
+    }
+
+    return model.context.TRIANGLES;
+  };
+
+  publicAPI.haveWideLines = function (ren, actor) {
+    if (actor.getProperty().getLineWidth() > 1.0) {
+      // we have wide lines, but the OpenGL implementation may
+      // actually support them, check the range to see if we
+      // really need have to implement our own wide lines
+      if (model.CABO.getOpenGLRenderWindow()) {
+        if (model.CABO.getOpenGLRenderWindow().getHardwareMaximumLineWidth() >= actor.getProperty().getLineWidth()) {
+          return false;
+        }
+      }
+
+      return true;
+    }
+
+    return false;
+  };
+
+  publicAPI.getNeedToRebuildShaders = function (ren, actor, oglMapper) {
+    // has something changed that would require us to recreate the shader?
+    // candidates are
+    // property modified (representation interpolation and lighting)
+    // input modified
+    // mapper modified (lighting complexity)
+    if (oglMapper.getNeedToRebuildShaders(publicAPI, ren, actor) || publicAPI.getProgram() === 0 || publicAPI.getShaderSourceTime().getMTime() < oglMapper.getMTime() || publicAPI.getShaderSourceTime().getMTime() < actor.getMTime()) {
+      return true;
+    }
+
+    return false;
+  };
+
+  publicAPI.updateShaders = function (ren, actor, oglMapper) {
+    // has something changed that would require us to recreate the shader?
+    if (publicAPI.getNeedToRebuildShaders(ren, actor, oglMapper)) {
+      var shaders = {
+        Vertex: null,
+        Fragment: null,
+        Geometry: null
+      };
+      oglMapper.buildShaders(shaders, ren, actor); // compile and bind the program if needed
+
+      var newShader = model.CABO.getOpenGLRenderWindow().getShaderCache().readyShaderProgramArray(shaders.Vertex, shaders.Fragment, shaders.Geometry); // if the shader changed reinitialize the VAO
+
+      if (newShader !== publicAPI.getProgram()) {
+        publicAPI.setProgram(newShader); // reset the VAO as the shader has changed
+
+        publicAPI.getVAO().releaseGraphicsResources();
+      }
+
+      publicAPI.getShaderSourceTime().modified();
+    } else {
+      model.CABO.getOpenGLRenderWindow().getShaderCache().readyShaderProgram(publicAPI.getProgram());
+    }
+
+    publicAPI.getVAO().bind();
+    oglMapper.setMapperShaderParameters(publicAPI, ren, actor);
+    oglMapper.setPropertyShaderParameters(publicAPI, ren, actor);
+    oglMapper.setCameraShaderParameters(publicAPI, ren, actor);
+    oglMapper.setLightingShaderParameters(publicAPI, ren, actor);
+    oglMapper.invokeShaderCallbacks(publicAPI, ren, actor);
+  };
+
+  publicAPI.setMapperShaderParameters = function (ren, actor, size) {
+    if (publicAPI.haveWideLines(ren, actor)) {
+      publicAPI.getProgram().setUniform2f('viewportSize', size.usize, size.vsize);
+      var lineWidth = parseFloat(actor.getProperty().getLineWidth());
+      var halfLineWidth = lineWidth / 2.0;
+      publicAPI.getProgram().setUniformf('lineWidthStepSize', lineWidth / Math.ceil(lineWidth));
+      publicAPI.getProgram().setUniformf('halfLineWidth', halfLineWidth);
+    }
+  };
+
+  publicAPI.replaceShaderPositionVC = function (shaders, ren, actor) {
+    var VSSource = shaders.Vertex; // for lines, make sure we add the width code
+
+    if (publicAPI.getOpenGLMode(actor.getProperty().getRepresentation()) === model.context.LINES && publicAPI.haveWideLines(ren, actor)) {
+      VSSource = vtkShaderProgram.substitute(VSSource, '//VTK::PositionVC::Dec', ['//VTK::PositionVC::Dec', 'uniform vec2 viewportSize;', 'uniform float lineWidthStepSize;', 'uniform float halfLineWidth;']).result;
+      VSSource = vtkShaderProgram.substitute(VSSource, '//VTK::PositionVC::Impl', ['//VTK::PositionVC::Impl', ' if (halfLineWidth > 0.0)', '   {', '   float offset = float(gl_InstanceID / 2) * lineWidthStepSize - halfLineWidth;', '   vec4 tmpPos = gl_Position;', '   vec3 tmpPos2 = tmpPos.xyz / tmpPos.w;', '   tmpPos2.x = tmpPos2.x + 2.0 * mod(float(gl_InstanceID), 2.0) * offset / viewportSize[0];', '   tmpPos2.y = tmpPos2.y + 2.0 * mod(float(gl_InstanceID + 1), 2.0) * offset / viewportSize[1];', '   gl_Position = vec4(tmpPos2.xyz * tmpPos.w, tmpPos.w);', '   }']).result;
+    } // for points make sure to add in the point size
+
+
+    if (actor.getProperty().getRepresentation() === Representation.POINTS || model.primitiveType === primTypes.Points) {
+      VSSource = vtkShaderProgram.substitute(VSSource, '//VTK::PositionVC::Impl', ['//VTK::PositionVC::Impl', "  gl_PointSize = ".concat(actor.getProperty().getPointSize(), ".0;")], false).result;
+    }
+
+    shaders.Vertex = VSSource;
+  };
 } // ----------------------------------------------------------------------------
 // Object factory
 // ----------------------------------------------------------------------------
 
 
 var DEFAULT_VALUES = {
+  context: null,
   program: null,
   shaderSourceTime: null,
   VAO: null,
@@ -56,7 +197,8 @@ var newInstance = macro.newInstance(extend); // --------------------------------
 
 var vtkHelper = {
   newInstance: newInstance,
-  extend: extend
+  extend: extend,
+  primTypes: primTypes
 };
 
-export { vtkHelper as default, extend, newInstance };
+export { vtkHelper as default, extend, newInstance, primTypes };

package/Rendering/OpenGL/OrderIndependentTranslucentPass.js

@@ -212,7 +212,7 @@ function vtkOpenGLOrderIndependentTranslucentPass(publicAPI, model) {
       return translucentShaderReplacement;
     }
 
-    return {};
+    return null;
   };
 
   publicAPI.releaseGraphicsResources = function (viewNode) {

package/Rendering/OpenGL/PolyDataMapper.js

@@ -15,16 +15,7 @@ import { registerOverride } from './ViewNodeFactory.js';
 
 /* eslint-disable no-lonely-if */
 
-var primTypes = {
-  Start: 0,
-  Points: 0,
-  Lines: 1,
-  Tris: 2,
-  TriStrips: 3,
-  TrisEdges: 4,
-  TriStripsEdges: 5,
-  End: 6
-};
+var primTypes = vtkHelper.primTypes;
 var Representation = vtkProperty.Representation,
     Shading = vtkProperty.Shading;
 var ScalarMode = vtkMapper.ScalarMode;
@@ -326,7 +317,7 @@ function vtkOpenGLPolyDataMapper(publicAPI, model) {
           FSSource = vtkShaderProgram.substitute(FSSource, '//VTK::Normal::Dec', ['uniform mat3 normalMatrix;', 'uniform samplerBuffer textureN;']).result;
           FSSource = vtkShaderProgram.substitute(FSSource, '//VTK::Normal::Impl', ['vec3 normalVCVSOutput = normalize(normalMatrix *', '    texelFetchBuffer(textureN, gl_PrimitiveID + PrimitiveIDOffset).xyz);', '  if (gl_FrontFacing == false) { normalVCVSOutput = -normalVCVSOutput; }']).result;
         } else {
-          if (publicAPI.getOpenGLMode(actor.getProperty().getRepresentation(), model.lastBoundBO.getPrimitiveType()) === model.context.LINES) {
+          if (model.lastBoundBO.getOpenGLMode(actor.getProperty().getRepresentation()) === model.context.LINES) {
             // generate a normal for lines, it will be perpendicular to the line
             // and maximally aligned with the camera view direction
             // no clue if this is the best way to do this.
@@ -361,14 +352,11 @@ function vtkOpenGLPolyDataMapper(publicAPI, model) {
   };
 
   publicAPI.replaceShaderPositionVC = function (shaders, ren, actor) {
+    // replace common shader code
+    model.lastBoundBO.replaceShaderPositionVC(shaders, ren, actor);
     var VSSource = shaders.Vertex;
     var GSSource = shaders.Geometry;
-    var FSSource = shaders.Fragment; // for points make sure to add in the point size
-
-    if (actor.getProperty().getRepresentation() === Representation.POINTS || model.lastBoundBO.getPrimitiveType() === primTypes.Points) {
-      VSSource = vtkShaderProgram.substitute(VSSource, '//VTK::PositionVC::Impl', ['//VTK::PositionVC::Impl', "  gl_PointSize = ".concat(actor.getProperty().getPointSize(), ".0;")], false).result;
-    } // do we need the vertex in the shader in View Coordinates
-
+    var FSSource = shaders.Fragment; // do we need the vertex in the shader in View Coordinates
 
     var lastLightComplexity = model.lastBoundBO.getReferenceByName('lastLightComplexity');
 
@@ -556,7 +544,7 @@ function vtkOpenGLPolyDataMapper(publicAPI, model) {
     var cellNormals = poly.getCellData().getNormals();
     var flat = actor.getProperty().getInterpolation() === Shading.FLAT;
     var representation = actor.getProperty().getRepresentation();
-    var mode = publicAPI.getOpenGLMode(representation, primType); // 1) all surfaces need lighting
+    var mode = cellBO.getOpenGLMode(representation, primType); // 1) all surfaces need lighting
 
     if (mode === model.context.TRIANGLES) {
       needLighting = true; // 2) all cell normals without point normals need lighting
@@ -628,7 +616,7 @@ function vtkOpenGLPolyDataMapper(publicAPI, model) {
     // light complexity changed
 
 
-    if (model.lastHaveSeenDepthRequest !== model.haveSeenDepthRequest || cellBO.getProgram() === 0 || cellBO.getShaderSourceTime().getMTime() < publicAPI.getMTime() || cellBO.getShaderSourceTime().getMTime() < actor.getMTime() || cellBO.getShaderSourceTime().getMTime() < model.renderable.getMTime() || cellBO.getShaderSourceTime().getMTime() < model.currentInput.getMTime() || needRebuild) {
+    if (model.lastHaveSeenDepthRequest !== model.haveSeenDepthRequest || cellBO.getShaderSourceTime().getMTime() < model.renderable.getMTime() || cellBO.getShaderSourceTime().getMTime() < model.currentInput.getMTime() || needRebuild) {
       model.lastHaveSeenDepthRequest = model.haveSeenDepthRequest;
       return true;
     }
@@ -636,36 +624,7 @@ function vtkOpenGLPolyDataMapper(publicAPI, model) {
     return false;
   };
 
-  publicAPI.updateShaders = function (cellBO, ren, actor) {
-    model.lastBoundBO = cellBO; // has something changed that would require us to recreate the shader?
-
-    if (publicAPI.getNeedToRebuildShaders(cellBO, ren, actor)) {
-      var shaders = {
-        Vertex: null,
-        Fragment: null,
-        Geometry: null
-      };
-      publicAPI.buildShaders(shaders, ren, actor); // compile and bind the program if needed
-
-      var newShader = model._openGLRenderWindow.getShaderCache().readyShaderProgramArray(shaders.Vertex, shaders.Fragment, shaders.Geometry); // if the shader changed reinitialize the VAO
-
-
-      if (newShader !== cellBO.getProgram()) {
-        cellBO.setProgram(newShader); // reset the VAO as the shader has changed
-
-        cellBO.getVAO().releaseGraphicsResources();
-      }
-
-      cellBO.getShaderSourceTime().modified();
-    } else {
-      model._openGLRenderWindow.getShaderCache().readyShaderProgram(cellBO.getProgram());
-    }
-
-    cellBO.getVAO().bind();
-    publicAPI.setMapperShaderParameters(cellBO, ren, actor);
-    publicAPI.setPropertyShaderParameters(cellBO, ren, actor);
-    publicAPI.setCameraShaderParameters(cellBO, ren, actor);
-    publicAPI.setLightingShaderParameters(cellBO, ren, actor);
+  publicAPI.invokeShaderCallbacks = function (cellBO, ren, actor) {
     var listCallbacks = model.renderable.getViewSpecificProperties().ShadersCallbacks;
 
     if (listCallbacks) {
@@ -783,8 +742,10 @@ function vtkOpenGLPolyDataMapper(publicAPI, model) {
       if (cellBO.getProgram().isUniformUsed('cfactor')) {
         cellBO.getProgram().setUniformf('cfactor', cp.factor);
       }
-    }
+    } // handle wide lines
+
 
+    cellBO.setMapperShaderParameters(ren, actor, model.openGLRenderer.getTiledSizeAndOrigin());
     var selector = model.openGLRenderer.getSelector();
     cellBO.getProgram().setUniform3fArray('mapperIndex', selector ? selector.getPropColorValue() : [0.0, 0.0, 0.0]);
     cellBO.getProgram().setUniformi('picking', selector ? selector.getCurrentPass() + 1 : 0);
@@ -997,9 +958,7 @@ function vtkOpenGLPolyDataMapper(publicAPI, model) {
 
   publicAPI.renderPieceDraw = function (ren, actor) {
     var representation = actor.getProperty().getRepresentation();
-    var gl = model.context;
-    var drawSurfaceWithEdges = actor.getProperty().getEdgeVisibility() && representation === Representation.SURFACE;
-    gl.lineWidth(actor.getProperty().getLineWidth()); // for every primitive type
+    var drawSurfaceWithEdges = actor.getProperty().getEdgeVisibility() && representation === Representation.SURFACE; // for every primitive type
 
     for (var i = primTypes.Start; i < primTypes.End; i++) {
       // if there are entries
@@ -1008,32 +967,13 @@ function vtkOpenGLPolyDataMapper(publicAPI, model) {
       if (cabo.getElementCount()) {
         // are we drawing edges
         model.drawingEdges = drawSurfaceWithEdges && (i === primTypes.TrisEdges || i === primTypes.TriStripsEdges);
-        var mode = publicAPI.getOpenGLMode(representation, i);
 
         if (!model.drawingEdges || !model.renderDepth) {
-          publicAPI.updateShaders(model.primitives[i], ren, actor);
-          gl.drawArrays(mode, 0, cabo.getElementCount());
+          model.lastBoundBO = model.primitives[i];
+          model.primitiveIDOffset += model.primitives[i].drawArrays(ren, actor, representation, publicAPI);
         }
-
-        var stride = (mode === gl.POINTS ? 1 : 0) || (mode === gl.LINES ? 2 : 3);
-        model.primitiveIDOffset += cabo.getElementCount() / stride;
       }
-    } // reset the line width
-
-
-    gl.lineWidth(1);
-  };
-
-  publicAPI.getOpenGLMode = function (rep, type) {
-    if (rep === Representation.POINTS || type === primTypes.Points) {
-      return model.context.POINTS;
     }
-
-    if (rep === Representation.WIREFRAME || type === primTypes.Lines || type === primTypes.TrisEdges || type === primTypes.TriStripsEdges) {
-      return model.context.LINES;
-    }
-
-    return model.context.TRIANGLES;
   };
 
   publicAPI.renderPieceFinish = function (ren, actor) {
@@ -1299,10 +1239,9 @@ var newInstance = newInstance$1(extend, 'vtkOpenGLPolyDataMapper'); // ---------
 
 var vtkOpenGLPolyDataMapper$1 = {
   newInstance: newInstance,
-  extend: extend,
-  primTypes: primTypes
+  extend: extend
 }; // Register ourself to OpenGL backend if imported
 
 registerOverride('vtkMapper', newInstance);
 
-export { vtkOpenGLPolyDataMapper$1 as default, extend, newInstance, primTypes };
+export { vtkOpenGLPolyDataMapper$1 as default, extend, newInstance };

package/Rendering/OpenGL/PolyDataMapper2D.js

@@ -2,7 +2,6 @@ import { mat4 } from 'gl-matrix';
 import { newInstance as newInstance$1, setGet, obj, vtkErrorMacro as vtkErrorMacro$1 } from '../../macros.js';
 import vtkHelper from './Helper.js';
 import vtkMapper2D from '../Core/Mapper2D.js';
-import vtkOpenGLPolyDataMapper from './PolyDataMapper.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';
@@ -10,12 +9,11 @@ import vtkReplacementShaderMapper from './ReplacementShaderMapper.js';
 import vtkShaderProgram from './ShaderProgram.js';
 import vtkViewNode from '../SceneGraph/ViewNode.js';
 import { K as round } from '../../Common/Core/Math/index.js';
-import { Representation } from '../Core/Property/Constants.js';
 import { DisplayLocation } from '../Core/Property2D/Constants.js';
 import { registerOverride } from './ViewNodeFactory.js';
 
 // import { mat3, mat4, vec3 } from 'gl-matrix';
-var primTypes = vtkOpenGLPolyDataMapper.primTypes;
+var primTypes = vtkHelper.primTypes;
 var ScalarMode = vtkMapper2D.ScalarMode;
 var vtkErrorMacro = vtkErrorMacro$1;
 var StartEvent = {
@@ -146,7 +144,7 @@ function vtkOpenGLPolyDataMapper2D(publicAPI, model) {
     // property modified (representation interpolation and lighting)
     // input modified
     // light complexity changed
-    if (cellBO.getProgram() === 0 || cellBO.getShaderSourceTime().getMTime() < publicAPI.getMTime() || cellBO.getShaderSourceTime().getMTime() < actor.getMTime() || cellBO.getShaderSourceTime().getMTime() < model.renderable.getMTime() || cellBO.getShaderSourceTime().getMTime() < model.currentInput.getMTime()) {
+    if (cellBO.getShaderSourceTime().getMTime() < model.renderable.getMTime() || cellBO.getShaderSourceTime().getMTime() < model.currentInput.getMTime()) {
       return true;
     }
 
@@ -172,18 +170,6 @@ function vtkOpenGLPolyDataMapper2D(publicAPI, model) {
     return false;
   };
 
-  publicAPI.getOpenGLMode = function (rep, type) {
-    if (rep === Representation.POINTS || type === primTypes.Points) {
-      return model.context.POINTS;
-    }
-
-    if (rep === Representation.WIREFRAME || type === primTypes.Lines || type === primTypes.TrisEdges || type === primTypes.TriStripsEdges) {
-      return model.context.LINES;
-    }
-
-    return model.context.TRIANGLES;
-  };
-
   publicAPI.buildBufferObjects = function (ren, actor) {
     var poly = model.currentInput;
 
@@ -252,9 +238,7 @@ function vtkOpenGLPolyDataMapper2D(publicAPI, model) {
 
   publicAPI.renderPieceDraw = function (ren, actor) {
     var representation = actor.getProperty().getRepresentation();
-    var drawSurfaceWithEdges = false;
     var gl = model.context;
-    gl.lineWidth(actor.getProperty().getLineWidth());
     gl.depthMask(true); // for every primitive type
 
     for (var i = primTypes.Start; i < primTypes.End; i++) {
@@ -262,27 +246,15 @@ function vtkOpenGLPolyDataMapper2D(publicAPI, model) {
       var cabo = model.primitives[i].getCABO();
 
       if (cabo.getElementCount()) {
-        // are we drawing edges
-        model.drawingEdges = drawSurfaceWithEdges ;
-        var mode = publicAPI.getOpenGLMode(representation, i);
-
-        if (!model.drawingEdges || !model.renderDepth) {
-          publicAPI.updateShaders(model.primitives[i], ren, actor);
-          gl.drawArrays(mode, 0, cabo.getElementCount());
-        }
-
-        var stride = (mode === gl.POINTS ? 1 : 0) || (mode === gl.LINES ? 2 : 3);
-        model.primitiveIDOffset += cabo.getElementCount() / stride;
+        model.lastBoundBO = model.primitives[i];
+        model.primitiveIDOffset += model.primitives[i].drawArrays(ren, actor, representation, publicAPI);
       }
-    } // reset the line width
-
-
-    gl.lineWidth(1);
+    }
   };
 
   publicAPI.renderPieceFinish = function (ren, actor) {
-    if (model.LastBoundBO) {
-      model.LastBoundBO.getVAO().release();
+    if (model.lastBoundBO) {
+      model.lastBoundBO.getVAO().release();
     }
   };
 
@@ -402,48 +374,11 @@ function vtkOpenGLPolyDataMapper2D(publicAPI, model) {
   };
 
   publicAPI.replaceShaderPositionVC = function (shaders, ren, actor) {
-    var VSSource = shaders.Vertex;
-    var GSSource = shaders.Geometry;
-    var FSSource = shaders.Fragment; // for points make sure to add in the point size
-
-    if (actor.getProperty().getRepresentation() === Representation.POINTS || model.lastBoundBO.getPrimitiveType() === primTypes.Points) {
-      VSSource = vtkShaderProgram.substitute(VSSource, '//VTK::PositionVC::Impl', ['//VTK::PositionVC::Impl', "  gl_PointSize = ".concat(actor.getProperty().getPointSize(), ".0;")], false).result;
-    }
-
-    shaders.Vertex = VSSource;
-    shaders.Geometry = GSSource;
-    shaders.Fragment = FSSource;
+    // replace common shader code
+    model.lastBoundBO.replaceShaderPositionVC(shaders, ren, actor);
   };
 
-  publicAPI.updateShaders = function (cellBO, ren, actor) {
-    model.lastBoundBO = cellBO; // has something changed that would require us to recreate the shader?
-
-    if (publicAPI.getNeedToRebuildShaders(cellBO, ren, actor)) {
-      var shaders = {
-        Vertex: null,
-        Fragment: null,
-        Geometry: null
-      };
-      publicAPI.buildShaders(shaders, ren, actor); // compile and bind the program if needed
-
-      var newShader = model._openGLRenderWindow.getShaderCache().readyShaderProgramArray(shaders.Vertex, shaders.Fragment, shaders.Geometry); // if the shader changed reinitialize the VAO
-
-
-      if (newShader !== cellBO.getProgram()) {
-        cellBO.setProgram(newShader); // reset the VAO as the shader has changed
-
-        cellBO.getVAO().releaseGraphicsResources();
-      }
-
-      cellBO.getShaderSourceTime().modified();
-    } else {
-      model._openGLRenderWindow.getShaderCache().readyShaderProgram(cellBO.getProgram());
-    }
-
-    cellBO.getVAO().bind();
-    publicAPI.setMapperShaderParameters(cellBO, ren, actor);
-    publicAPI.setPropertyShaderParameters(cellBO, ren, actor);
-    publicAPI.setCameraShaderParameters(cellBO, ren, actor);
+  publicAPI.invokeShaderCallbacks = function (cellBO, ren, actor) {
     var listCallbacks = model.renderable.getViewSpecificProperties().ShadersCallbacks;
 
     if (listCallbacks) {
@@ -501,15 +436,7 @@ function vtkOpenGLPolyDataMapper2D(publicAPI, model) {
       } // handle wide lines
 
 
-      if (publicAPI.haveWideLines(ren, actor)) {
-        var gl = model.context;
-        var vp = gl.getParameter(gl.VIEWPORT);
-        var lineWidth = [1, 1];
-        lineWidth[0] = 2.0 * actor.getProperty().getLineWidth() / vp[2];
-        lineWidth[1] = 2.0 * actor.getProperty().getLineWidth() / vp[3];
-        cellBO.getProgram().setUniform2f('lineWidthNVC', lineWidth);
-      }
-
+      cellBO.setMapperShaderParameters(ren, actor, model.openGLRenderer.getTiledSizeAndOrigin());
       var selector = model.openGLRenderer.getSelector();
       cellBO.getProgram().setUniform3fArray('mapperIndex', selector ? selector.getPropColorValue() : [0.0, 0.0, 0.0]);
       cellBO.getProgram().setUniformi('picking', selector ? selector.getCurrentPass() + 1 : 0);
@@ -529,6 +456,9 @@ function vtkOpenGLPolyDataMapper2D(publicAPI, model) {
     }
   };
 
+  publicAPI.setLightingShaderParameters = function (cellBO, ren, actor) {// no-op
+  };
+
   function safeMatrixMultiply(matrixArray, matrixType, tmpMat) {
     matrixType.identity(tmpMat);
     return matrixArray.reduce(function (res, matrix, index) {
@@ -598,20 +528,6 @@ function vtkOpenGLPolyDataMapper2D(publicAPI, model) {
     mat4.transpose(tmpMat4, tmpMat4);
     program.setUniformMatrix('WCVCMatrix', safeMatrixMultiply([tmpMat4, inverseShiftScaleMatrix], mat4, model.tmpMat4));
   };
-
-  publicAPI.haveWideLines = function (ren, actor) {
-    if (model.lastBoundBO === model.lines && actor.getProperty().getLineWidth() > 1.0) {
-      // we have wide lines, but the OpenGL implementation may
-      // actually support them, check the range to see if we
-      // really need have to implement our own wide lines
-      // vtkOpenGLRenderWindow* renWin = vtkOpenGLRenderWindow::SafeDownCast(ren->GetVTKWindow());
-      // return !(
-      //   renWin && renWin->GetMaximumHardwareLineWidth() >= actor->GetProperty()->GetLineWidth());
-      return true;
-    }
-
-    return false;
-  };
 } // ----------------------------------------------------------------------------
 // Object factory
 // ----------------------------------------------------------------------------

package/Rendering/OpenGL/RenderWindow.js

@@ -737,6 +737,12 @@ function vtkOpenGLRenderWindow(publicAPI, model) {
     });
   };
 
+  publicAPI.getHardwareMaximumLineWidth = function () {
+    var gl = publicAPI.get3DContext();
+    var lineWidthRange = gl.getParameter(gl.ALIASED_LINE_WIDTH_RANGE);
+    return lineWidthRange[1];
+  };
+
   publicAPI.getGLInformations = function () {
     var gl = publicAPI.get3DContext();
     var glTextureFloat = gl.getExtension('OES_texture_float');

package/index.d.ts

@@ -2,8 +2,8 @@
 /// <reference path="./interfaces.d.ts" />
 /// <reference path="./macros.d.ts" />
 /// <reference path="./vtk.d.ts" />
-/// <reference path="./Common/Core/Base64.d.ts" />
 /// <reference path="./Common/Core/CellArray.d.ts" />
+/// <reference path="./Common/Core/Base64.d.ts" />
 /// <reference path="./Common/Core/DataArray.d.ts" />
 /// <reference path="./Common/Core/Endian.d.ts" />
 /// <reference path="./Common/Core/HalfFloat.d.ts" />
@@ -135,8 +135,8 @@
 /// <reference path="./Rendering/Misc/SynchronizableRenderWindow.d.ts" />
 /// <reference path="./Rendering/Misc/TextureLODsDownloader.d.ts" />
 /// <reference path="./Rendering/OpenGL/RenderWindow.d.ts" />
-/// <reference path="./Rendering/SceneGraph/RenderPass.d.ts" />
 /// <reference path="./Rendering/SceneGraph/ViewNode.d.ts" />
+/// <reference path="./Rendering/SceneGraph/RenderPass.d.ts" />
 /// <reference path="./Rendering/SceneGraph/ViewNodeFactory.d.ts" />
 /// <reference path="./Widgets/Manipulators/LineManipulator.d.ts" />
 /// <reference path="./Widgets/Manipulators/PlaneManipulator.d.ts" />

package/package.json

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