vtkHardwarePicker.h

Go to the documentation of this file.

// SPDX-FileCopyrightText: Copyright (c) Ken Martin, Will Schroeder, Bill Lorensen
// SPDX-License-Identifier: BSD-3-Clause
#ifndef vtkHardwarePicker_h
#define vtkHardwarePicker_h
 
#include "vtkAbstractPropPicker.h"
#include "vtkNew.h"                 // For vtkNew
#include "vtkRenderingCoreModule.h" // For export macro
#include "vtkSmartPointer.h"        // For vtkSmartPointer
#include "vtkStringToken.h"         // for vtkStringToken
 
VTK_ABI_NAMESPACE_BEGIN
class vtkAbstractMapper3D;
class vtkCell;
class vtkCompositeDataSet;
class vtkDataObject;
class vtkDataSet;
class vtkSelection;
 
class VTKRENDERINGCORE_EXPORT vtkHardwarePicker : public vtkAbstractPropPicker
{
public:
  static vtkHardwarePicker* New();
  vtkTypeMacro(vtkHardwarePicker, vtkAbstractPropPicker);
  void PrintSelf(ostream& os, vtkIndent indent) override;
 
 
  vtkSetMacro(SnapToMeshPoint, bool);
  vtkGetMacro(SnapToMeshPoint, bool);
  vtkBooleanMacro(SnapToMeshPoint, bool);
 
 
  vtkSetMacro(PixelTolerance, int);
  vtkGetMacro(PixelTolerance, int);
 
 
  vtkGetObjectMacro(Mapper, vtkAbstractMapper3D);
 
 
  vtkGetObjectMacro(DataSet, vtkDataSet);
 
 
  vtkGetObjectMacro(DataObject, vtkDataObject);
 
 
  vtkGetObjectMacro(CompositeDataSet, vtkCompositeDataSet);
 
 
  vtkGetMacro(FlatBlockIndex, vtkIdType);
 
 
  vtkGetMacro(PointId, vtkIdType);
 
 
  vtkGetMacro(CellId, vtkIdType);
 
 
  vtkGetMacro(SubId, int);
 
 
  vtkGetMacro(CellGridCellTypeId, vtkIdType);
 
 
  vtkGetMacro(CellGridSourceSpecId, vtkIdType);
 
 
  vtkGetMacro(CellGridTupleId, vtkIdType);
 
 
  vtkGetVector3Macro(PCoords, double);
 
 
  vtkGetVectorMacro(PickNormal, double, 3);
 
  vtkGetMacro(NormalFlipped, bool);
 
  int Pick(double selectionX, double selectionY, double selectionZ, vtkRenderer* renderer) override;
 
protected:
  vtkHardwarePicker();
  ~vtkHardwarePicker() override;
 
  void Initialize() override;
  // converts the propCandidate into a vtkAbstractMapper3D and returns its pickability
  int TypeDecipher(vtkProp*, vtkAbstractMapper3D**);
 
  void FixNormalSign();
 
  int ComputeSurfaceNormal(vtkDataSet* data, vtkCell* cell, double* weights);
 
  void ComputeIntersectionFromDataSet(vtkDataSet* ds);
 
  bool SnapToMeshPoint; // if true, the pick position is snapped to the closest point on the mesh
  int PixelTolerance;   // tolerance for picking when snapping the closest point on the mesh
 
  vtkNew<vtkPropCollection> PickableProps;         // list of pickable props
  vtkSmartPointer<vtkSelection> HardwareSelection; // result of the hardware selector
 
  double NearRayPoint[3]; // near ray point
  double FarRayPoint[3];  // far ray point
 
  vtkAbstractMapper3D* Mapper; // selected mapper (if the prop has a mapper)
  vtkDataSet* DataSet;         // selected dataset (if there is one)
  vtkDataObject* DataObject;   // selected dataobject (useful when the picked object is directly
                               // derived from vtkDataObject)
  vtkCompositeDataSet* CompositeDataSet; // selected dataset (if there is one)
  vtkIdType FlatBlockIndex;              // flat block index, for a composite data set
 
  vtkIdType PointId;              // id of the picked point
  vtkIdType CellId;               // id of the picked cell
  int SubId;                      // sub id of the picked cell
  vtkIdType CellGridCellTypeId;   // id of the picked cell type in a vtkCellGrid
  vtkIdType CellGridSourceSpecId; // id of the picked cell/side spec in a vtkCellGrid. 0 is for cell
                                  // spec, 1+ is for side specs
  vtkIdType
    CellGridTupleId;    // id of the picked tuple in the cell/side connectivity of a vtkCellGrid
  double PCoords[3];    // parametric coordinates of the picked point
  double PickNormal[3]; // normal of the picked surface
  bool NormalFlipped;   // Flag to indicate if the normal has been flipped
 
private:
  vtkHardwarePicker(const vtkHardwarePicker&) = delete;
  void operator=(const vtkHardwarePicker&) = delete;
};
 
VTK_ABI_NAMESPACE_END
#endif