@kitware/vtk.js 24.13.1 → 24.14.2

package/Interaction/Widgets/OrientationMarkerWidget.js

@@ -25,10 +25,19 @@ function vtkOrientationMarkerWidget(publicAPI, model) {
   var resizeObserver = new ResizeObserver(function (entries) {
     publicAPI.updateViewport();
   });
+  var onCameraChangedSub = null;
+  var onCameraModifiedSub = null;
   var onAnimationSub = null;
   var onEndAnimationSub = null;
   var selfSubscription = null;
 
+  function onCameraModified() {
+    // If animating, marker will be updated on Animation event
+    if (!model._interactor.isAnimating()) {
+      publicAPI.updateMarkerOrientation();
+    }
+  }
+
   publicAPI.computeViewport = function () {
     var parentRen = model.parentRenderer || model._interactor.getCurrentRenderer();
 
@@ -147,6 +156,16 @@ function vtkOrientationMarkerWidget(publicAPI, model) {
       selfRenderer.setInteractive(false);
       selfRenderer.addViewProp(model.actor);
       model.actor.setVisibility(true);
+      onCameraChangedSub = ren.onEvent(function (event) {
+        if (event.type === 'ActiveCameraEvent') {
+          if (onCameraModifiedSub) {
+            onCameraModifiedSub.unsubscribe();
+          }
+
+          onCameraModifiedSub = event.camera.onModified(onCameraModified);
+        }
+      });
+      onCameraModifiedSub = ren.getActiveCamera().onModified(onCameraModified);
       onAnimationSub = model._interactor.onAnimation(publicAPI.updateMarkerOrientation);
       onEndAnimationSub = model._interactor.onEndAnimation(publicAPI.updateMarkerOrientation);
       resizeObserver.observe(model._interactor.getView().getCanvas());
@@ -160,6 +179,10 @@ function vtkOrientationMarkerWidget(publicAPI, model) {
 
       model.enabled = false;
       resizeObserver.disconnect();
+      onCameraChangedSub.unsubscribe();
+      onCameraChangedSub = null;
+      onCameraModifiedSub.unsubscribe();
+      onCameraModifiedSub = null;
       onAnimationSub.unsubscribe();
       onAnimationSub = null;
       onEndAnimationSub.unsubscribe();
@@ -234,6 +257,16 @@ function vtkOrientationMarkerWidget(publicAPI, model) {
       selfSubscription = null;
     }
 
+    if (onCameraChangedSub) {
+      onCameraChangedSub.unsubscribe();
+      onCameraChangedSub = null;
+    }
+
+    if (onCameraModifiedSub) {
+      onCameraModifiedSub.unsubscribe();
+      onCameraModifiedSub = null;
+    }
+
     if (onAnimationSub) {
       onAnimationSub.unsubscribe();
       onAnimationSub = null;

package/Rendering/Core/Actor.js

@@ -165,6 +165,12 @@ function vtkActor(publicAPI, model) {
   publicAPI.getSupportsSelection = function () {
     return model.mapper ? model.mapper.getSupportsSelection() : false;
   };
+
+  publicAPI.processSelectorPixelBuffers = function (selector, pixelOffsets) {
+    if (model.mapper && model.mapper.processSelectorPixelBuffers) {
+      model.mapper.processSelectorPixelBuffers(selector, pixelOffsets);
+    }
+  };
 } // ----------------------------------------------------------------------------
 // Object factory
 // ----------------------------------------------------------------------------

package/Rendering/Core/Mapper.js

@@ -8,10 +8,13 @@ import { N as createUninitializedBounds, i as isNan } from '../../Common/Core/Ma
 import vtkScalarsToColors from '../../Common/Core/ScalarsToColors/Constants.js';
 import CoincidentTopologyHelper from './Mapper/CoincidentTopologyHelper.js';
 import Constants from './Mapper/Constants.js';
+import vtkDataSet from '../../Common/DataModel/DataSet.js';
+import { PassTypes } from '../OpenGL/HardwareSelector/Constants.js';
 
 function ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); enumerableOnly && (symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; })), keys.push.apply(keys, symbols); } return keys; }
 
 function _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = null != arguments[i] ? arguments[i] : {}; i % 2 ? ownKeys(Object(source), !0).forEach(function (key) { _defineProperty(target, key, source[key]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)) : ownKeys(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } return target; }
+var FieldAssociations = vtkDataSet.FieldAssociations;
 var staticOffsetAPI = CoincidentTopologyHelper.staticOffsetAPI,
     otherStaticMethods = CoincidentTopologyHelper.otherStaticMethods;
 var ColorMode = Constants.ColorMode,
@@ -455,6 +458,64 @@ function vtkMapper(publicAPI, model) {
   publicAPI.colorToValue = notImplemented('ColorToValue');
   publicAPI.useInvertibleColorFor = notImplemented('UseInvertibleColorFor');
   publicAPI.clearInvertibleColor = notImplemented('ClearInvertibleColor');
+
+  publicAPI.processSelectorPixelBuffers = function (selector, pixelOffsets) {
+    /* eslint-disable no-bitwise */
+    if (!selector || !model.selectionWebGLIdsToVTKIds || !model.populateSelectionSettings) {
+      return;
+    }
+
+    var rawLowData = selector.getRawPixelBuffer(PassTypes.ID_LOW24);
+    var rawHighData = selector.getRawPixelBuffer(PassTypes.ID_HIGH24);
+    var currentPass = selector.getCurrentPass();
+    var fieldAssociation = selector.getFieldAssociation();
+    var idMap = null;
+
+    if (fieldAssociation === FieldAssociations.FIELD_ASSOCIATION_POINTS) {
+      idMap = model.selectionWebGLIdsToVTKIds.points;
+    } else if (fieldAssociation === FieldAssociations.FIELD_ASSOCIATION_CELLS) {
+      idMap = model.selectionWebGLIdsToVTKIds.cells;
+    }
+
+    if (!idMap) {
+      return;
+    }
+
+    pixelOffsets.forEach(function (pos) {
+      if (currentPass === PassTypes.ID_LOW24) {
+        var inValue = 0;
+
+        if (rawHighData) {
+          inValue += rawHighData[pos];
+          inValue *= 256;
+        }
+
+        inValue += rawLowData[pos + 2];
+        inValue *= 256;
+        inValue += rawLowData[pos + 1];
+        inValue *= 256;
+        inValue += rawLowData[pos];
+        var outValue = idMap[inValue];
+        var lowData = selector.getPixelBuffer(PassTypes.ID_LOW24);
+        lowData[pos] = outValue & 0xff;
+        lowData[pos + 1] = (outValue & 0xff00) >> 8;
+        lowData[pos + 2] = (outValue & 0xff0000) >> 16;
+      } else if (currentPass === PassTypes.ID_HIGH24 && rawHighData) {
+        var _inValue = 0;
+        _inValue += rawHighData[pos];
+        _inValue *= 256;
+        _inValue += rawLowData[pos];
+        _inValue *= 256;
+        _inValue += rawLowData[pos + 1];
+        _inValue *= 256;
+        _inValue += rawLowData[pos + 2];
+        var _outValue = idMap[_inValue];
+        var highData = selector.getPixelBuffer(PassTypes.ID_HIGH24);
+        highData[pos] = (_outValue & 0xff000000) >> 24;
+      }
+    });
+    /* eslint-enable no-bitwise */
+  };
 } // ----------------------------------------------------------------------------
 // Object factory
 // ----------------------------------------------------------------------------
@@ -475,6 +536,8 @@ var DEFAULT_VALUES = {
   renderTime: 0,
   colorByArrayName: null,
   fieldDataTupleId: -1,
+  populateSelectionSettings: true,
+  selectionWebGLIdsToVTKIds: null,
   interpolateScalarsBeforeMapping: false,
   colorCoordinates: null,
   colorTextureMap: null,
@@ -491,7 +554,7 @@ function extend(publicAPI, model) {
 
   vtkAbstractMapper3D.extend(publicAPI, model, initialValues);
   macro.get(publicAPI, model, ['colorCoordinates', 'colorMapColors', 'colorTextureMap']);
-  macro.setGet(publicAPI, model, ['colorByArrayName', 'arrayAccessMode', 'colorMode', 'fieldDataTupleId', 'interpolateScalarsBeforeMapping', 'lookupTable', 'renderTime', 'scalarMode', 'scalarVisibility', 'static', 'useLookupTableScalarRange', 'viewSpecificProperties', 'customShaderAttributes' // point data array names that will be transferred to the VBO
+  macro.setGet(publicAPI, model, ['colorByArrayName', 'arrayAccessMode', 'colorMode', 'fieldDataTupleId', 'interpolateScalarsBeforeMapping', 'lookupTable', 'populateSelectionSettings', 'renderTime', 'scalarMode', 'scalarVisibility', 'selectionWebGLIdsToVTKIds', 'static', 'useLookupTableScalarRange', 'viewSpecificProperties', 'customShaderAttributes' // point data array names that will be transferred to the VBO
   ]);
   macro.setGetArray(publicAPI, model, ['scalarRange'], 2);
 

package/Rendering/Core/Prop.js

@@ -27,6 +27,8 @@ function vtkProp(publicAPI, model) {
     return m1;
   };
 
+  publicAPI.processSelectorPixelBuffers = function (selector, pixeloffsets) {};
+
   publicAPI.getNestedProps = function () {
     return null;
   };

package/Rendering/Core/ScalarBarActor.js

@@ -198,7 +198,7 @@ function vtkScalarBarActorHelper(publicAPI, model) {
     model.camera = camera;
     model.renderWindow = renderWindow; // did something significant change? If so rebuild a lot of things
 
-    if (model.forceUpdate || Math.max(scalarsToColors.getMTime(), publicAPI.getMTime()) > model.lastRebuildTime.getMTime()) {
+    if (model.forceUpdate || Math.max(scalarsToColors.getMTime(), publicAPI.getMTime(), model.renderable.getMTime()) > model.lastRebuildTime.getMTime()) {
       var range = scalarsToColors.getMappingRange();
       model.lastTickBounds = _toConsumableArray(range); // compute tick marks for axes (update for log scale)
 

package/Rendering/OpenGL/CellArrayBufferObject.js

@@ -33,6 +33,8 @@ function vtkOpenGLCellArrayBufferObject(publicAPI, model) {
   publicAPI.setType(ObjectType.ARRAY_BUFFER);
 
   publicAPI.createVBO = function (cellArray, inRep, outRep, options) {
+    var selectionMaps = arguments.length > 4 && arguments[4] !== undefined ? arguments[4] : null;
+
     if (!cellArray.getData() || !cellArray.getData().length) {
       model.elementCount = 0;
       return 0;
@@ -263,10 +265,34 @@ function vtkOpenGLCellArrayBufferObject(publicAPI, model) {
     } else if (model.coordShiftAndScaleEnabled === true) {
       // Make sure to reset
       publicAPI.setCoordShiftAndScale(null, null);
+    } // Initialize the structures used to keep track of point ids and cell ids for selectors
+
+
+    if (selectionMaps) {
+      if (!selectionMaps.points && !selectionMaps.cells) {
+        selectionMaps.points = new Int32Array(caboCount);
+        selectionMaps.cells = new Int32Array(caboCount);
+      } else {
+        var newPoints = new Int32Array(caboCount + selectionMaps.points.length);
+        newPoints.set(selectionMaps.points);
+        selectionMaps.points = newPoints;
+        var newCells = new Int32Array(caboCount + selectionMaps.points.length);
+        newCells.set(selectionMaps.cells);
+        selectionMaps.cells = newCells;
+      }
     }
 
+    var pointCount = options.vertexOffset;
+
     addAPoint = function addAPointFunc(i) {
-      // Vertices
+      // Keep track of original point and cell ids, for selection
+      if (selectionMaps) {
+        selectionMaps.points[pointCount] = i;
+        selectionMaps.cells[pointCount] = cellCount;
+      }
+
+      ++pointCount; // Vertices
+
       pointIdx = i * 3;
 
       if (!model.coordShiftAndScaleEnabled) {

package/Rendering/OpenGL/HardwareSelector/Constants.js

@@ -3,7 +3,8 @@ var PassTypes = {
   ACTOR_PASS: 0,
   COMPOSITE_INDEX_PASS: 1,
   ID_LOW24: 2,
-  MAX_KNOWN_PASS: 2
+  ID_HIGH24: 3,
+  MAX_KNOWN_PASS: 3
 };
 var Constants = {
   PassTypes: PassTypes

package/Rendering/OpenGL/HardwareSelector.js

@@ -23,6 +23,15 @@ function getInfoHash(info) {
   return "".concat(info.propID, " ").concat(info.compositeID);
 }
 
+function getAlpha(xx, yy, pb, area) {
+  if (!pb) {
+    return 0;
+  }
+
+  var offset = (yy * (area[2] - area[0] + 1) + xx) * 4;
+  return pb[offset + 3];
+}
+
 function convert(xx, yy, pb, area) {
   if (!pb) {
     return 0;
@@ -41,6 +50,15 @@ function convert(xx, yy, pb, area) {
   return val;
 }
 
+function getID(low24, high8) {
+  /* eslint-disable no-bitwise */
+  var val = high8;
+  val <<= 24;
+  val |= low24;
+  return val;
+  /* eslint-enable no-bitwise */
+}
+
 function getPixelInformationWithData(buffdata, inDisplayPosition, maxDistance, outSelectedPosition) {
   // Base case
   var maxDist = maxDistance < 0 ? 0 : maxDistance;
@@ -80,6 +98,15 @@ function getPixelInformationWithData(buffdata, inDisplayPosition, maxDistance, o
       _info.displayPosition = inDisplayPosition;
     }
 
+    if (buffdata.pixBuffer[PassTypes.ID_LOW24]) {
+      if (getAlpha(displayPosition[0], displayPosition[1], buffdata.pixBuffer[PassTypes.ID_LOW24], buffdata.area) === 0.0) {
+        return _info;
+      }
+    }
+
+    var low24 = convert(displayPosition[0], displayPosition[1], buffdata.pixBuffer[PassTypes.ID_LOW24], buffdata.area);
+    var high24 = convert(displayPosition[0], displayPosition[1], buffdata.pixBuffer[PassTypes.ID_HIGH24], buffdata.area);
+    _info.attributeID = getID(low24, high24);
     return _info;
   } // Iterate over successively growing boxes.
   // They recursively call the base case to handle single pixels.
@@ -167,6 +194,7 @@ function convertSelection(fieldassociation, dataMap, captureZValues, renderer, o
     child.getProperties().propID = value.info.propID;
     child.getProperties().prop = value.info.prop;
     child.getProperties().compositeID = value.info.compositeID;
+    child.getProperties().attributeID = value.info.attributeID;
     child.getProperties().pixelCount = value.pixelCount;
 
     if (captureZValues) {
@@ -233,6 +261,7 @@ function vtkOpenGLHardwareSelector(publicAPI, model) {
   model.classHierarchy.push('vtkOpenGLHardwareSelector'); //----------------------------------------------------------------------------
 
   publicAPI.releasePixBuffers = function () {
+    model.rawPixBuffer = [];
     model.pixBuffer = [];
     model.zBuffer = null;
   }; //----------------------------------------------------------------------------
@@ -270,8 +299,24 @@ function vtkOpenGLHardwareSelector(publicAPI, model) {
     model._openGLRenderer.setSelector(publicAPI);
 
     model.hitProps = {};
+    model.propPixels = {};
     model.props = [];
     publicAPI.releasePixBuffers();
+
+    if (model.fieldAssociation === FieldAssociations.FIELD_ASSOCIATION_POINTS) {
+      var gl = model._openGLRenderWindow.getContext();
+
+      var originalBlending = gl.isEnabled(gl.BLEND);
+      gl.disable(gl.BLEND);
+
+      model._openGLRenderWindow.traverseAllPasses();
+
+      model._renderer.setPreserveDepthBuffer(true);
+
+      if (originalBlending) {
+        gl.enable(gl.BLEND);
+      }
+    }
   }; //----------------------------------------------------------------------------
 
 
@@ -281,11 +326,26 @@ function vtkOpenGLHardwareSelector(publicAPI, model) {
     model._openGLRenderer.setSelector(null);
 
     model.framebuffer.restorePreviousBindingsAndBuffers();
+
+    model._renderer.setPreserveDepthBuffer(false);
+  };
+
+  publicAPI.preCapturePass = function () {
+    var gl = model._openGLRenderWindow.getContext(); // Disable blending
+
+
+    model.originalBlending = gl.isEnabled(gl.BLEND);
+    gl.disable(gl.BLEND);
   };
 
-  publicAPI.preCapturePass = function () {};
+  publicAPI.postCapturePass = function () {
+    var gl = model._openGLRenderWindow.getContext(); // Restore blending if it was enabled prior to the capture
+
 
-  publicAPI.postCapturePass = function () {}; //----------------------------------------------------------------------------
+    if (model.originalBlending) {
+      gl.enable(gl.BLEND);
+    }
+  }; //----------------------------------------------------------------------------
 
 
   publicAPI.select = function () {
@@ -385,13 +445,13 @@ function vtkOpenGLHardwareSelector(publicAPI, model) {
 
     model.originalBackground = model._renderer.getBackgroundByReference();
 
-    model._renderer.setBackground(0.0, 0.0, 0.0);
+    model._renderer.setBackground(0.0, 0.0, 0.0, 0.0);
 
     var rpasses = model._openGLRenderWindow.getRenderPasses();
 
     publicAPI.beginSelection();
 
-    for (model.currentPass = PassTypes.MIN_KNOWN_PASS; model.currentPass <= PassTypes.COMPOSITE_INDEX_PASS; model.currentPass++) {
+    for (model.currentPass = PassTypes.MIN_KNOWN_PASS; model.currentPass <= PassTypes.MAX_KNOWN_PASS; model.currentPass++) {
       if (publicAPI.passRequired(model.currentPass)) {
         publicAPI.preCapturePass(model.currentPass);
 
@@ -405,6 +465,7 @@ function vtkOpenGLHardwareSelector(publicAPI, model) {
 
         publicAPI.postCapturePass(model.currentPass);
         publicAPI.savePixelBuffer(model.currentPass);
+        publicAPI.processPixelBuffers();
       }
     }
 
@@ -418,10 +479,28 @@ function vtkOpenGLHardwareSelector(publicAPI, model) {
     // model._openGLRenderWindow.traverseAllPasses();
 
     return true;
+  };
+
+  publicAPI.processPixelBuffers = function () {
+    model.props.forEach(function (prop, index) {
+      if (publicAPI.isPropHit(index)) {
+        prop.processSelectorPixelBuffers(publicAPI, model.propPixels[index]);
+      }
+    });
   }; //----------------------------------------------------------------------------
 
 
   publicAPI.passRequired = function (pass) {
+    if (pass === PassTypes.ID_HIGH24) {
+      if (model.fieldAssociation === FieldAssociations.FIELD_ASSOCIATION_POINTS) {
+        return model.maximumPointId > 0x00ffffff;
+      }
+
+      if (model.fieldAssociation === FieldAssociations.FIELD_ASSOCIATION_CELLS) {
+        return model.maximumCellId > 0x00ffffff;
+      }
+    }
+
     return true;
   }; //----------------------------------------------------------------------------
 
@@ -429,6 +508,12 @@ function vtkOpenGLHardwareSelector(publicAPI, model) {
   publicAPI.savePixelBuffer = function (passNo) {
     model.pixBuffer[passNo] = model._openGLRenderWindow.getPixelData(model.area[0], model.area[1], model.area[2], model.area[3]);
 
+    if (!model.rawPixBuffer[passNo]) {
+      var size = (model.area[2] - model.area[0] + 1) * (model.area[3] - model.area[1] + 1) * 4;
+      model.rawPixBuffer[passNo] = new Uint8Array(size);
+      model.rawPixBuffer[passNo].set(model.pixBuffer[passNo]);
+    }
+
     if (passNo === PassTypes.ACTOR_PASS) {
       if (model.captureZValues) {
         var rpasses = model._openGLRenderWindow.getRenderPasses();
@@ -442,12 +527,14 @@ function vtkOpenGLHardwareSelector(publicAPI, model) {
         }
       }
 
-      publicAPI.buildPropHitList(model.pixBuffer[passNo]);
+      publicAPI.buildPropHitList(model.rawPixBuffer[passNo]);
     }
   }; //----------------------------------------------------------------------------
 
 
   publicAPI.buildPropHitList = function (pixelbuffer) {
+    var offset = 0;
+
     for (var yy = 0; yy <= model.area[3] - model.area[1]; yy++) {
       for (var xx = 0; xx <= model.area[2] - model.area[0]; xx++) {
         var val = convert(xx, yy, pixelbuffer, model.area);
@@ -457,8 +544,13 @@ function vtkOpenGLHardwareSelector(publicAPI, model) {
 
           if (!(val in model.hitProps)) {
             model.hitProps[val] = true;
+            model.propPixels[val] = [];
           }
+
+          model.propPixels[val].push(offset * 4);
         }
+
+        ++offset;
       }
     }
   }; //----------------------------------------------------------------------------
@@ -552,8 +644,18 @@ function vtkOpenGLHardwareSelector(publicAPI, model) {
         var offset = (displayPosition[1] * (model.area[2] - model.area[0] + 1) + displayPosition[0]) * 4;
         _info2.zValue = (256 * model.zBuffer[offset] + model.zBuffer[offset + 1]) / 65535.0;
         _info2.displayPosition = inDisplayPosition;
+      } // Skip attribute ids if alpha is zero (missed)
+
+
+      if (model.pixBuffer[PassTypes.ID_LOW24]) {
+        if (getAlpha(displayPosition[0], displayPosition[1], model.pixBuffer[PassTypes.ID_LOW24], model.area) === 0.0) {
+          return _info2;
+        }
       }
 
+      var low24 = convert(displayPosition[0], displayPosition[1], model.pixBuffer[PassTypes.ID_LOW24], model.area);
+      var high24 = convert(displayPosition[0], displayPosition[1], model.pixBuffer[PassTypes.ID_HIGH24], model.area);
+      _info2.attributeID = getID(low24, high24);
       return _info2;
     } // Iterate over successively growing boxes.
     // They recursively call the base case to handle single pixels.
@@ -659,6 +761,14 @@ function vtkOpenGLHardwareSelector(publicAPI, model) {
     }
 
     return convertSelection(model.fieldAssociation, dataMap, model.captureZValues, model._renderer, model._openGLRenderWindow);
+  };
+
+  publicAPI.getRawPixelBuffer = function (passNo) {
+    return model.rawPixBuffer[passNo];
+  };
+
+  publicAPI.getPixelBuffer = function (passNo) {
+    return model.pixBuffer[passNo];
   }; //----------------------------------------------------------------------------
 
 
@@ -694,6 +804,8 @@ var DEFAULT_VALUES = {
   currentPass: -1,
   propColorValue: null,
   props: null,
+  maximumPointId: 0,
+  maximumCellId: 0,
   idOffset: 1
 }; // ----------------------------------------------------------------------------
 
@@ -710,7 +822,7 @@ function extend(publicAPI, model) {
   }
 
   macro.setGetArray(publicAPI, model, ['area'], 4);
-  macro.setGet(publicAPI, model, ['_renderer', 'currentPass', '_openGLRenderWindow']);
+  macro.setGet(publicAPI, model, ['_renderer', 'currentPass', '_openGLRenderWindow', 'maximumPointId', 'maximumCellId']);
   macro.setGetArray(publicAPI, model, ['propColorValue'], 3);
   macro.moveToProtected(publicAPI, model, ['renderer', 'openGLRenderWindow']);
   macro.event(publicAPI, model, 'event'); // Object methods

package/Rendering/OpenGL/Helper.js

@@ -41,6 +41,12 @@ function vtkOpenGLHelper(publicAPI, model) {
       var mode = publicAPI.getOpenGLMode(rep);
       var wideLines = publicAPI.haveWideLines(ren, actor);
       var gl = model.context;
+      var depthMask = gl.getParameter(gl.DEPTH_WRITEMASK);
+
+      if (model.pointPicking) {
+        gl.depthMask(false);
+      }
+
       var drawingLines = mode === gl.LINES;
 
       if (drawingLines && wideLines) {
@@ -55,6 +61,11 @@ function vtkOpenGLHelper(publicAPI, model) {
       }
 
       var stride = (mode === gl.POINTS ? 1 : 0) || (mode === gl.LINES ? 2 : 3);
+
+      if (model.pointPicking) {
+        gl.depthMask(depthMask);
+      }
+
       return model.CABO.getElementCount() / stride;
     }
 
@@ -62,6 +73,10 @@ function vtkOpenGLHelper(publicAPI, model) {
   };
 
   publicAPI.getOpenGLMode = function (rep) {
+    if (model.pointPicking) {
+      return model.context.POINTS;
+    }
+
     var type = model.primitiveType;
 
     if (rep === Representation.POINTS || type === primTypes.Points) {
@@ -144,22 +159,38 @@ function vtkOpenGLHelper(publicAPI, model) {
       publicAPI.getProgram().setUniformf('lineWidthStepSize', lineWidth / Math.ceil(lineWidth));
       publicAPI.getProgram().setUniformf('halfLineWidth', halfLineWidth);
     }
+
+    if (model.primitiveType === primTypes.Points || actor.getProperty().getRepresentation() === Representation.POINTS) {
+      publicAPI.getProgram().setUniformf('pointSize', actor.getProperty().getPointSize());
+    } else if (model.pointPicking) {
+      publicAPI.getProgram().setUniformf('pointSize', publicAPI.getPointPickingPrimitiveSize());
+    }
   };
 
   publicAPI.replaceShaderPositionVC = function (shaders, ren, actor) {
-    var VSSource = shaders.Vertex; // for lines, make sure we add the width code
+    var VSSource = shaders.Vertex; // Always set point size in case we need picking
+
+    VSSource = vtkShaderProgram.substitute(VSSource, '//VTK::PositionVC::Dec', ['//VTK::PositionVC::Dec', 'uniform float pointSize;']).result;
+    VSSource = vtkShaderProgram.substitute(VSSource, '//VTK::PositionVC::Impl', ['//VTK::PositionVC::Impl', '  gl_PointSize = pointSize;'], false).result; // 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
+    }
 
+    shaders.Vertex = VSSource;
+  };
 
-    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;
+  publicAPI.getPointPickingPrimitiveSize = function () {
+    if (model.primitiveType === primTypes.Points) {
+      return 2;
     }
 
-    shaders.Vertex = VSSource;
+    if (model.primitiveType === primTypes.Lines) {
+      return 4;
+    }
+
+    return 6;
   };
 } // ----------------------------------------------------------------------------
 // Object factory
@@ -173,7 +204,8 @@ var DEFAULT_VALUES = {
   VAO: null,
   attributeUpdateTime: null,
   CABO: null,
-  primitiveType: 0
+  primitiveType: 0,
+  pointPicking: false
 }; // ----------------------------------------------------------------------------
 
 function extend(publicAPI, model) {
@@ -185,7 +217,7 @@ function extend(publicAPI, model) {
   macro.obj(model.shaderSourceTime);
   model.attributeUpdateTime = {};
   macro.obj(model.attributeUpdateTime);
-  macro.setGet(publicAPI, model, ['program', 'shaderSourceTime', 'VAO', 'attributeUpdateTime', 'CABO', 'primitiveType']);
+  macro.setGet(publicAPI, model, ['program', 'shaderSourceTime', 'VAO', 'attributeUpdateTime', 'CABO', 'primitiveType', 'pointPicking']);
   model.program = vtkShaderProgram.newInstance();
   model.VAO = vtkVertexArrayObject.newInstance();
   model.CABO = vtkCellArrayBufferObject.newInstance(); // Object methods

package/Rendering/OpenGL/PolyDataMapper.js

@@ -12,7 +12,10 @@ import { v as vtkPolyDataVS } from './glsl/vtkPolyDataVS.glsl.js';
 import { v as vtkPolyDataFS } from './glsl/vtkPolyDataFS.glsl.js';
 import vtkReplacementShaderMapper from './ReplacementShaderMapper.js';
 import { registerOverride } from './ViewNodeFactory.js';
+import { PassTypes } from './HardwareSelector/Constants.js';
+import vtkDataSet from '../../Common/DataModel/DataSet.js';
 
+var FieldAssociations = vtkDataSet.FieldAssociations;
 /* eslint-disable no-lonely-if */
 
 var primTypes = vtkHelper.primTypes;
@@ -31,6 +34,16 @@ var EndEvent = {
 // vtkOpenGLPolyDataMapper methods
 // ----------------------------------------------------------------------------
 
+function getPickState(renderer) {
+  var selector = renderer.getSelector();
+
+  if (selector) {
+    return selector.getCurrentPass();
+  }
+
+  return PassTypes.MIN_KNOWN_PASS - 1;
+}
+
 function vtkOpenGLPolyDataMapper(publicAPI, model) {
   // Set our className
   model.classHierarchy.push('vtkOpenGLPolyDataMapper');
@@ -475,7 +488,10 @@ function vtkOpenGLPolyDataMapper(publicAPI, model) {
   publicAPI.getCoincidentParameters = function (ren, actor) {
     // 1. ResolveCoincidentTopology is On and non zero for this primitive
     // type
-    var cp = null;
+    var cp = {
+      factor: 0.0,
+      offset: 0.0
+    };
     var prop = actor.getProperty();
 
     if (model.renderable.getResolveCoincidentTopology() || prop.getEdgeVisibility() && prop.getRepresentation() === Representation.SURFACE) {
@@ -496,23 +512,49 @@ function vtkOpenGLPolyDataMapper(publicAPI, model) {
       }
     } // hardware picking always offset due to saved zbuffer
     // This gets you above the saved surface depth buffer.
-    // vtkHardwareSelector* selector = ren->GetSelector();
-    // if (selector &&
-    //     selector->GetFieldAssociation() == vtkDataObject::FIELD_ASSOCIATION_POINTS)
-    // {
-    //   offset -= 2.0;
-    //   return;
-    // }
 
 
+    var selector = model.openGLRenderer.getSelector();
+
+    if (selector && selector.getFieldAssociation() === FieldAssociations.FIELD_ASSOCIATION_POINTS) {
+      cp.offset -= 2.0;
+    }
+
     return cp;
   };
 
   publicAPI.replaceShaderPicking = function (shaders, ren, actor) {
     var FSSource = shaders.Fragment;
-    FSSource = vtkShaderProgram.substitute(FSSource, '//VTK::Picking::Dec', ['uniform vec3 mapperIndex;', 'uniform int picking;']).result;
-    FSSource = vtkShaderProgram.substitute(FSSource, '//VTK::Picking::Impl', '  gl_FragData[0] = picking != 0 ? vec4(mapperIndex,1.0) : gl_FragData[0];').result;
+    var VSSource = shaders.Vertex;
+    FSSource = vtkShaderProgram.substitute(FSSource, '//VTK::Picking::Dec', ['uniform int picking;', '//VTK::Picking::Dec']).result;
+
+    if (!model.openGLRenderer.getSelector()) {
+      return;
+    }
+
+    if (model.lastSelectionState === PassTypes.ID_LOW24 || model.lastSelectionState === PassTypes.ID_HIGH24) {
+      VSSource = vtkShaderProgram.substitute(VSSource, '//VTK::Picking::Dec', ['flat out int vertexIDVSOutput;\n', 'uniform int VertexIDOffset;\n']).result;
+      VSSource = vtkShaderProgram.substitute(VSSource, '//VTK::Picking::Impl', '  vertexIDVSOutput = gl_VertexID + VertexIDOffset;\n').result;
+      FSSource = vtkShaderProgram.substitute(FSSource, '//VTK::Picking::Dec', 'flat in int vertexIDVSOutput;\n').result;
+      FSSource = vtkShaderProgram.substitute(FSSource, '//VTK::Picking::Impl', ['  int idx = vertexIDVSOutput;', '//VTK::Picking::Impl']).result;
+    }
+
+    switch (model.lastSelectionState) {
+      case PassTypes.ID_LOW24:
+        FSSource = vtkShaderProgram.substitute(FSSource, '//VTK::Picking::Impl', '  gl_FragData[0] = vec4(float(idx%256)/255.0, float((idx/256)%256)/255.0, float((idx/65536)%256)/255.0, 1.0);').result;
+        break;
+
+      case PassTypes.ID_HIGH24:
+        FSSource = vtkShaderProgram.substitute(FSSource, '//VTK::Picking::Impl', '  gl_FragData[0] = vec4(float(idx)/255.0, 0.0, 0.0, 1.0);').result;
+        break;
+
+      default:
+        FSSource = vtkShaderProgram.substitute(FSSource, '//VTK::Picking::Dec', 'uniform vec3 mapperIndex;').result;
+        FSSource = vtkShaderProgram.substitute(FSSource, '//VTK::Picking::Impl', '  gl_FragData[0] = picking != 0 ? vec4(mapperIndex,1.0) : gl_FragData[0];').result;
+    }
+
     shaders.Fragment = FSSource;
+    shaders.Vertex = VSSource;
   };
 
   publicAPI.replaceShaderValues = function (shaders, ren, actor) {
@@ -616,7 +658,7 @@ function vtkOpenGLPolyDataMapper(publicAPI, model) {
     // light complexity changed
 
 
-    if (model.lastHaveSeenDepthRequest !== model.haveSeenDepthRequest || 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() || cellBO.getShaderSourceTime().getMTime() < model.selectionStateChanged.getMTime() || needRebuild) {
       model.lastHaveSeenDepthRequest = model.haveSeenDepthRequest;
       return true;
     }
@@ -640,6 +682,10 @@ function vtkOpenGLPolyDataMapper(publicAPI, model) {
       cellBO.getProgram().setUniformi('PrimitiveIDOffset', model.primitiveIDOffset);
     }
 
+    if (cellBO.getProgram().isUniformUsed('VertexIDOffset')) {
+      cellBO.getProgram().setUniformi('VertexIDOffset', model.vertexIDOffset);
+    }
+
     if (cellBO.getCABO().getElementCount() && (model.VBOBuildTime.getMTime() > cellBO.getAttributeUpdateTime().getMTime() || cellBO.getShaderSourceTime().getMTime() > cellBO.getAttributeUpdateTime().getMTime())) {
       var lastLightComplexity = model.lastBoundBO.getReferenceByName('lastLightComplexity');
 
@@ -934,11 +980,44 @@ function vtkOpenGLPolyDataMapper(publicAPI, model) {
     }
   };
 
+  publicAPI.updateMaximumPointCellIds = function (ren, actor) {
+    var _model$selectionWebGL, _model$selectionWebGL2, _model$selectionWebGL3, _model$selectionWebGL4;
+
+    var selector = model.openGLRenderer.getSelector();
+
+    if (!selector) {
+      return;
+    }
+
+    if ((_model$selectionWebGL = model.selectionWebGLIdsToVTKIds) !== null && _model$selectionWebGL !== void 0 && (_model$selectionWebGL2 = _model$selectionWebGL.points) !== null && _model$selectionWebGL2 !== void 0 && _model$selectionWebGL2.length) {
+      var length = model.selectionWebGLIdsToVTKIds.points.length;
+      selector.setMaximumPointId(length - 1);
+    }
+
+    if ((_model$selectionWebGL3 = model.selectionWebGLIdsToVTKIds) !== null && _model$selectionWebGL3 !== void 0 && (_model$selectionWebGL4 = _model$selectionWebGL3.cells) !== null && _model$selectionWebGL4 !== void 0 && _model$selectionWebGL4.length) {
+      var _length = model.selectionWebGLIdsToVTKIds.cells.length;
+      selector.setMaximumCellId(_length - 1);
+    }
+
+    var fieldAssociation = selector.getFieldAssociation();
+
+    if (fieldAssociation === FieldAssociations.FIELD_ASSOCIATION_POINTS) {
+      model.pointPicking = true;
+    }
+  };
+
   publicAPI.renderPieceStart = function (ren, actor) {
     model.primitiveIDOffset = 0;
+    model.vertexIDOffset = 0;
+    var picking = getPickState(model.openGLRenderer);
+
+    if (model.lastSelectionState !== picking) {
+      model.selectionStateChanged.modified();
+      model.lastSelectionState = picking;
+    }
 
     if (model.openGLRenderer.getSelector()) {
-      switch (model.openGLRenderer.getSelector().getCurrentPass()) {
+      switch (picking) {
         default:
           model.openGLRenderer.getSelector().renderProp(actor);
       }
@@ -958,10 +1037,13 @@ function vtkOpenGLPolyDataMapper(publicAPI, model) {
 
   publicAPI.renderPieceDraw = function (ren, actor) {
     var representation = actor.getProperty().getRepresentation();
-    var drawSurfaceWithEdges = actor.getProperty().getEdgeVisibility() && representation === Representation.SURFACE; // for every primitive type
+    var drawSurfaceWithEdges = actor.getProperty().getEdgeVisibility() && representation === Representation.SURFACE;
+    var selector = model.openGLRenderer.getSelector(); // If we are picking points, we need to tell it to the helper
+
+    var pointPicking = selector && selector.getFieldAssociation() === FieldAssociations.FIELD_ASSOCIATION_POINTS && (model.lastSelectionState === PassTypes.ID_LOW24 || model.lastSelectionState === PassTypes.ID_HIGH24); // for every primitive type
 
     for (var i = primTypes.Start; i < primTypes.End; i++) {
-      // if there are entries
+      model.primitives[i].setPointPicking(pointPicking);
       var cabo = model.primitives[i].getCABO();
 
       if (cabo.getElementCount()) {
@@ -971,6 +1053,7 @@ function vtkOpenGLPolyDataMapper(publicAPI, model) {
         if (!model.drawingEdges || !model.renderDepth) {
           model.lastBoundBO = model.primitives[i];
           model.primitiveIDOffset += model.primitives[i].drawArrays(ren, actor, representation, publicAPI);
+          model.vertexIDOffset += model.primitives[i].getCABO().getElementCount();
         }
       }
     }
@@ -1134,41 +1217,70 @@ function vtkOpenGLPolyDataMapper(publicAPI, model) {
         tcoords: tcoords,
         colors: c,
         cellOffset: 0,
+        vertexOffset: 0,
+        // Used to keep track of vertex ids across primitives for selection
         haveCellScalars: model.haveCellScalars,
         haveCellNormals: model.haveCellNormals,
         customAttributes: model.renderable.getCustomShaderAttributes().map(function (arrayName) {
           return poly.getPointData().getArrayByName(arrayName);
         })
       };
-      options.cellOffset += model.primitives[primTypes.Points].getCABO().createVBO(poly.getVerts(), 'verts', representation, options);
-      options.cellOffset += model.primitives[primTypes.Lines].getCABO().createVBO(poly.getLines(), 'lines', representation, options);
-      options.cellOffset += model.primitives[primTypes.Tris].getCABO().createVBO(poly.getPolys(), 'polys', representation, options);
-      options.cellOffset += model.primitives[primTypes.TriStrips].getCABO().createVBO(poly.getStrips(), 'strips', representation, options);
-      var drawSurfaceWithEdges = actor.getProperty().getEdgeVisibility() && representation === Representation.SURFACE; // if we have edge visibility build the edge VBOs
-
-      if (drawSurfaceWithEdges) {
-        model.primitives[primTypes.TrisEdges].getCABO().createVBO(poly.getPolys(), 'polys', Representation.WIREFRAME, {
-          points: points,
-          normals: n,
-          tcoords: null,
-          colors: null,
-          cellOffset: 0,
-          haveCellScalars: false,
-          haveCellNormals: false
-        });
-        model.primitives[primTypes.TriStripsEdges].getCABO().createVBO(poly.getStrips(), 'strips', Representation.WIREFRAME, {
-          points: points,
-          normals: n,
-          tcoords: null,
-          colors: null,
-          cellOffset: 0,
-          haveCellScalars: false,
-          haveCellNormals: false
-        });
-      } else {
-        // otherwise free them
-        model.primitives[primTypes.TrisEdges].releaseGraphicsResources(model._openGLRenderWindow);
-        model.primitives[primTypes.TriStripsEdges].releaseGraphicsResources(model._openGLRenderWindow);
+
+      if (model.renderable.getPopulateSelectionSettings()) {
+        model.selectionWebGLIdsToVTKIds = {
+          points: null,
+          cells: null
+        };
+      }
+
+      var primitives = [{
+        inRep: 'verts',
+        cells: poly.getVerts()
+      }, {
+        inRep: 'lines',
+        cells: poly.getLines()
+      }, {
+        inRep: 'polys',
+        cells: poly.getPolys()
+      }, {
+        inRep: 'strips',
+        cells: poly.getStrips()
+      }, {
+        inRep: 'polys',
+        cells: poly.getPolys()
+      }, {
+        inRep: 'strips',
+        cells: poly.getStrips()
+      }];
+      var drawSurfaceWithEdges = // TODO: false if picking
+      actor.getProperty().getEdgeVisibility() && representation === Representation.SURFACE;
+
+      for (var i = primTypes.Start; i < primTypes.End; i++) {
+        if (i !== primTypes.TrisEdges && i !== primTypes.TriStripsEdges) {
+          options.cellOffset += model.primitives[i].getCABO().createVBO(primitives[i].cells, primitives[i].inRep, representation, options, model.selectionWebGLIdsToVTKIds);
+          options.vertexOffset += model.primitives[i].getCABO().getElementCount();
+        } else {
+          // if we have edge visibility build the edge VBOs
+          if (drawSurfaceWithEdges) {
+            model.primitives[i].getCABO().createVBO(primitives[i].cells, primitives[i].inRep, Representation.WIREFRAME, {
+              points: points,
+              normals: n,
+              tcoords: null,
+              colors: null,
+              cellOffset: 0,
+              haveCellScalars: false,
+              haveCellNormals: false
+            });
+          } else {
+            // otherwise free them
+            model.primitives[i].releaseGraphicsResources();
+          }
+        }
+      }
+
+      if (model.renderable.getPopulateSelectionSettings()) {
+        model.renderable.setSelectionWebGLIdsToVTKIds(model.selectionWebGLIdsToVTKIds);
+        publicAPI.updateMaximumPointCellIds();
       }
 
       model.VBOBuildTime.modified();
@@ -1201,7 +1313,11 @@ var DEFAULT_VALUES = {
   lightDirection: [],
   // used internally
   lastHaveSeenDepthRequest: false,
-  haveSeenDepthRequest: false
+  haveSeenDepthRequest: false,
+  lastSelectionState: PassTypes.MIN_KNOWN_PASS - 1,
+  selectionStateChanged: null,
+  selectionWebGLIdsToVTKIds: null,
+  pointPicking: false
 }; // ----------------------------------------------------------------------------
 
 function extend(publicAPI, model) {
@@ -1230,6 +1346,10 @@ function extend(publicAPI, model) {
   model.VBOBuildTime = {};
   obj(model.VBOBuildTime, {
     mtime: 0
+  });
+  model.selectionStateChanged = {};
+  obj(model.selectionStateChanged, {
+    mtime: 0
   }); // Object methods
 
   vtkOpenGLPolyDataMapper(publicAPI, model);

package/package.json

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