@kitware/vtk.js 24.13.0 → 24.14.1

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/Widgets/Representations/ArrowHandleRepresentation.js

@@ -321,7 +321,9 @@ function vtkArrowHandleRepresentation(publicAPI, model) {
   };
 
   publicAPI.requestData = function (inData, outData) {
-    var shape = publicAPI.getRepresentationStates(inData[0])[0].getShape();
+    var _publicAPI$getReprese;
+
+    var shape = (_publicAPI$getReprese = publicAPI.getRepresentationStates(inData[0])[0]) === null || _publicAPI$getReprese === void 0 ? void 0 : _publicAPI$getReprese.getShape();
     var shouldCreateGlyph = model.glyph == null;
 
     if (model.shape !== shape && Object.values(ShapeType).includes(shape)) {
@@ -329,7 +331,7 @@ function vtkArrowHandleRepresentation(publicAPI, model) {
       shouldCreateGlyph = true;
     }
 
-    if (shouldCreateGlyph) {
+    if (shouldCreateGlyph && model.shape) {
       model.glyph = createGlyph(model.shape);
       model.mapper.setInputConnection(model.glyph.getOutputPort(), 1);
     }
@@ -341,8 +343,8 @@ function vtkArrowHandleRepresentation(publicAPI, model) {
     var renderingType = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : RenderingTypes.FRONT_BUFFER;
     var ctxVisible = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : true;
     var handleVisible = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : true;
-    var state = publicAPI.getRepresentationStates()[0];
-    superClass.updateActorVisibility(renderingType, ctxVisible, handleVisible && state.isVisible());
+    var hasValidState = publicAPI.getRepresentationStates().length > 0;
+    superClass.updateActorVisibility(renderingType, ctxVisible, handleVisible && hasValidState);
   };
 } // ----------------------------------------------------------------------------
 // Object factory

package/index.d.ts

@@ -102,11 +102,16 @@
 /// <reference path="./Rendering/Core/AxesActor.d.ts" />
 /// <reference path="./Rendering/Core/Camera.d.ts" />
 /// <reference path="./Rendering/Core/CellPicker.d.ts" />
+/// <reference path="./Rendering/Core/ColorTransferFunction/Constants.d.ts" />
 /// <reference path="./Rendering/Core/ColorTransferFunction.d.ts" />
+/// <reference path="./Rendering/Core/Coordinate/Constants.d.ts" />
 /// <reference path="./Rendering/Core/Coordinate.d.ts" />
 /// <reference path="./Rendering/Core/Follower.d.ts" />
+/// <reference path="./Rendering/Core/Glyph3DMapper/Constants.d.ts" />
 /// <reference path="./Rendering/Core/Glyph3DMapper.d.ts" />
+/// <reference path="./Rendering/Core/ImageMapper/Constants.d.ts" />
 /// <reference path="./Rendering/Core/ImageMapper.d.ts" />
+/// <reference path="./Rendering/Core/ImageProperty/Constants.d.ts" />
 /// <reference path="./Rendering/Core/ImageProperty.d.ts" />
 /// <reference path="./Rendering/Core/ImageSlice.d.ts" />
 /// <reference path="./Rendering/Core/Light.d.ts" />
@@ -120,6 +125,7 @@
 /// <reference path="./Rendering/Core/Prop3D.d.ts" />
 /// <reference path="./Rendering/Core/Property/Constants.d.ts" />
 /// <reference path="./Rendering/Core/Property.d.ts" />
+/// <reference path="./Rendering/Core/Property2D/Constants.d.ts" />
 /// <reference path="./Rendering/Core/Property2D.d.ts" />
 /// <reference path="./Rendering/Core/RenderWindow.d.ts" />
 /// <reference path="./Rendering/Core/RenderWindowInteractor/Constants.d.ts" />
@@ -134,6 +140,7 @@
 /// <reference path="./Rendering/Core/Volume.d.ts" />
 /// <reference path="./Rendering/Core/VolumeMapper/Constants.d.ts" />
 /// <reference path="./Rendering/Core/VolumeMapper.d.ts" />
+/// <reference path="./Rendering/Core/VolumeProperty/Constants.d.ts" />
 /// <reference path="./Rendering/Core/VolumeProperty.d.ts" />
 /// <reference path="./Rendering/Misc/CanvasView.d.ts" />
 /// <reference path="./Rendering/Misc/FullScreenRenderWindow.d.ts" />

package/package.json

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