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
#include "vtkWrappingHints.h"       // For VTK_MARSHALAUTO

VTK_ABI_NAMESPACE_BEGIN
class vtkAbstractMapper3D;
class vtkCell;
class vtkCompositeDataSet;
class vtkDataObject;
class vtkDataSet;
class vtkSelection;

class VTKRENDERINGCORE_EXPORT VTK_MARSHALAUTO 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