SoRayPickAction.h

/*=======================================================================
 * Copyright 1991-1996, Silicon Graphics, Inc.
 * ALL RIGHTS RESERVED
 *
 * UNPUBLISHED -- Rights reserved under the copyright laws of the United
 * States.   Use of a copyright notice is precautionary only and does not
 * imply publication or disclosure.
 *
 * U.S. GOVERNMENT RESTRICTED RIGHTS LEGEND:
 * Use, duplication or disclosure by the Government is subject to restrictions
 * as set forth in FAR 52.227.19(c)(2) or subparagraph (c)(1)(ii) of the Rights
 * in Technical Data and Computer Software clause at DFARS 252.227-7013 and/or
 * in similar or successor clauses in the FAR, or the DOD or NASA FAR
 * Supplement.  Contractor/manufacturer is Silicon Graphics, Inc.,
 * 2011 N. Shoreline Blvd. Mountain View, CA 94039-7311.
 *
 * THE CONTENT OF THIS WORK CONTAINS CONFIDENTIAL AND PROPRIETARY
 * INFORMATION OF SILICON GRAPHICS, INC. ANY DUPLICATION, MODIFICATION,
 * DISTRIBUTION, OR DISCLOSURE IN ANY FORM, IN WHOLE, OR IN PART, IS STRICTLY
 * PROHIBITED WITHOUT THE PRIOR EXPRESS WRITTEN PERMISSION OF SILICON
 * GRAPHICS, INC.
**=======================================================================*/
/*=======================================================================
** Author      : Paul S. Strauss (MMM yyyy)
** Modified by : Nick Thompson (MMM yyyy)
**=======================================================================*/
/*=======================================================================
 *** THE CONTENT OF THIS WORK IS PROPRIETARY TO FEI S.A.S, (FEI S.A.S.),            ***
 ***              AND IS DISTRIBUTED UNDER A LICENSE AGREEMENT.                     ***
 ***                                                                                ***
 ***  REPRODUCTION, DISCLOSURE,  OR USE,  IN WHOLE OR IN PART,  OTHER THAN AS       ***
 ***  SPECIFIED  IN THE LICENSE ARE  NOT TO BE  UNDERTAKEN  EXCEPT WITH PRIOR       ***
 ***  WRITTEN AUTHORIZATION OF FEI S.A.S.                                           ***
 ***                                                                                ***
 ***                        RESTRICTED RIGHTS LEGEND                                ***
 ***  USE, DUPLICATION, OR DISCLOSURE BY THE GOVERNMENT OF THE CONTENT OF THIS      ***
 ***  WORK OR RELATED DOCUMENTATION IS SUBJECT TO RESTRICTIONS AS SET FORTH IN      ***
 ***  SUBPARAGRAPH (C)(1) OF THE COMMERCIAL COMPUTER SOFTWARE RESTRICTED RIGHT      ***
 ***  CLAUSE  AT FAR 52.227-19  OR SUBPARAGRAPH  (C)(1)(II)  OF  THE RIGHTS IN      ***
 ***  TECHNICAL DATA AND COMPUTER SOFTWARE CLAUSE AT DFARS 52.227-7013.             ***
 ***                                                                                ***
 ***                   COPYRIGHT (C) 1996-2024 BY FEI S.A.S,                        ***
 ***                        BORDEAUX, FRANCE                                        ***
 ***                      ALL RIGHTS RESERVED                                       ***
**=======================================================================*/
/*=======================================================================
** Modified by : VSG (MMM YYYY)
**=======================================================================*/
 
 
#ifndef  _SO_RAY_PICK_ACTION_
#define  _SO_RAY_PICK_ACTION_
 
#include <Inventor/SoLists.h>
#include <Inventor/nodes/SoCamera.h>
#include <Inventor/actions/SoPickAction.h>
#include <Inventor/SbBox.h>
#include <Inventor/lists/SoPickedPointList.h>
 
class PickedPointListImpl;
class HomTransfData;
class SoDeviceContext;
 
//
//  Class: SoRayPickAction
//
//  Picking action that intersects a ray with objects in the scene
//  graph. The ray can be specified by calling setPoint() with a point
//  in a viewport in a rendering window or by calling setRay() with a
//  world-space ray. In the setPoint() case, a valid camera must be
//  encountered in the graph to set up the mapping to world space.
//
//  The "pickAll" flag indicates whether all intersections along the
//  ray should be returned (sorted by distance from the starting point
//  of the ray), or just the closest one. In either case, the
//  intersections are returned as an SoPickedPointList. Each
//  intersection can be examined by accessing the appropriate
//  SoPickedPoint in the list. The SoPickedPoint class provides
//  methods to get the intersection point, normal, and other info.
//
 
class  SoRayPickAction : public SoPickAction {
 
  SO_ACTION_HEADER(SoRayPickAction);
 
 public:
 
  static void setStereoMode(SoCamera::StereoMode stereoMode);
 
  static SoCamera::StereoMode getStereoMode();
 
  SoRayPickAction(const SbViewportRegion &viewportRegion);
 
  virtual void clearApplyResult();
 
  // Destructor
#ifndef HIDDEN_FROM_DOC
  virtual ~SoRayPickAction();
#endif // HIDDEN_FROM_DOC
 
  //
  //  Setting up the action before it is applied:
  //
 
  enum PickingMode {
    DEFAULT,
 
    POINT_PICKING
 
    // EDGE_PICKING,
    // FACE_PICKING
  };
 
  void setPickingMode(PickingMode pickingMode);
 
  PickingMode getPickingMode() const;
 
  virtual void setPoint(const SbVec2s &viewportPoint);
 
  virtual void setPoint(const SbVec2f &viewportPoint);
 
  const SbVec2s&  getPoint() const       { return VPPoint; }
 
  const SbVec2f&  getPointFloat() const   { return VPPointFloat; }
 
  virtual void setNormalizedPoint(const SbVec2f &normPoint);
 
  const SbVec2f       getNormalizedPoint() const
    { return normVPPoint; }
 
  void                setRadius(float radius);
 
  float               getRadius() const
    { return VPRadius; }
 
  virtual void setRay(const SbVec3f &start, const SbVec3f &direction,
                      float nearDistance = -1.0,
                      float farDistance = -1.0);
 
  virtual void setRay(float fovy, const SbVec3f &start, const SbVec3f &direction,
                      float nearDistance = -1.0,
                      float farDistance = -1.0);
 
  void setPickAll(SbBool flag)                
    { pickAll = flag; }
 
  SbBool isPickAll() const            
    { return pickAll; }
 
  //
  //  Examining results after the action is applied:
  //
 
  const SoPickedPointList &getPickedPointList() const;
  
  SoPickedPoint *getPickedPoint(int index = 0) const;
SoDEPRECATED
  void clearPickedPointList();
 
  void enableRadiusForTriangles(SbBool flag);
 
  SbBool isRadiusEnableForTriangles();
 
  static void enableTriangleCulling(SbBool flag) ;
 
 
  static SbBool isTriangleCulling()
    { return s_triangleCullingEnabled; }
  
  void enableTexCoordsGeneration(const SbBool enable);
 
  void enableNormalsGeneration(const SbBool enable);
 
  SbBool isTexCoordsGenerationEnabled() const;
 
  SbBool isNormalsGenerationEnabled() const;
 
  void enableConicPickVolume(SbBool flag);
 
  inline SbBool isConicPickVolume()
  { return m_conicPickVolume; }
 
  virtual void apply( SoNode* node );
 
  virtual void apply( SoPath* path );
 
  virtual void apply(const SoPathList &pathList, SbBool obeysRules = FALSE) { SoAction::apply(pathList, obeysRules); }
 
 
 private:
 
  // If a ray was not defined with setRay(), this causes the world
  // space pick ray to be computed from the screen space point and
  // radius, using the current view specification from the state.
  // This is typically done when a camera is encountered during
  // traversal.
  void computeWorldSpaceRay();
 
  // This returns TRUE if the action has had a world space ray set
  // or computed
  SbBool hasWorldSpaceRay() const;
 
  // This is called by shapes to set up object space picking. It
  // uses the current state matrices to determine how to map between
  // world and object spaces. It should be called before calling any
  // of the intersection methods.
  // The second form takes a matrix to concatenate with the current
  // objToWorld matrix. It can be used, for example, if a shape has
  // sizing or positioning info built into it.
  //
  // These methods are also in charge of resetting the cached picked point
  // shape path, so the application must call the appropriate one once for
  // any shape that redefines the rayPick method before calling addIntersection().
  void                setObjectSpace();
  void                setObjectSpace(const SbMatrix &matrix);
 
  // These intersect the current object-space ray with a variety of
  // primitives: triangle, line, point, bounding-box. Intersection
  // with a triangle uses only the ray, while intersection with a
  // line or point uses the cone or cylinder around the ray. The
  // intersection with a bounding-box uses the cone/cylinder also,
  // since the contents of the box may be lines or points. NOTE: you
  // must call setObjectSpace() before calling any of these.
 
  // Triangle: returns intersection point, barycentric coordinates,
  // and whether the front side (defined by right-hand-rule) was hit.
  SbBool intersect(const SbVec3f &v0,
                   const SbVec3f &v1,
                   const SbVec3f &v2,
                   SbVec3f &intersection, SbVec3f &barycentric,
                   SbBool &front) ;
 
  // Line:
  SbBool intersect(const SbVec3f &v0, const SbVec3f &v1,
                   SbVec3f &intersection) const;
 
  // Point:
  SbBool intersect(const SbVec3f &point) const;
 
  inline SbBool intersect(const SbBox3f &box, SbBool useFullViewVolume = TRUE)
  {
    SbXfBox3f xbox(box);
    return intersect(xbox, useFullViewVolume);
  }
 
  SbBool intersect(const SbXfBox3f &box, SbBool useFullViewVolume = TRUE);
 
 
  // Returns an SbViewVolume that represents the object-space ray to
  // pick along. The projection point of the view volume is the
  // starting point of the ray. The projection direction is the
  // direction of the ray. The distance to the near plane is the
  // same as the distance to the near plane for the ray. The
  // distance to the far plane is the sum of the near distance and
  // the depth of the view volume.
  const SbViewVolume &getViewVolume() const
    { return objVol; }
 
  // Returns SbLine that can be used for other intersection tests.
  // The line's position is the starting point and the direction is
  // the direction of the ray. Given an intersection with this ray,
  // you can call isBetweenPlanes() to see if the intersection is
  // between the near and far clipping planes.
  const SbLine &getLine() const
    { return objLine; }
 
  // Returns TRUE if the given object-space intersection point is
  // between the near and far planes of the object-space view
  // volume, as well as any clipping planes that have been defined.
  // This test can be used to determine whether the point of
  // intersection of the ray with an object is valid with respect to
  // the clipping planes.
  SbBool isBetweenPlanes(const SbVec3f &intersection) const;
 
  SoPickedPoint *addIntersection(const SbVec3f &objectSpacePoint);
 
  // Adds an SoPickedPoint instance representing the given object
  // space point to the current list and returns a pointer to it. If
  // pickAll is TRUE, this inserts the instance in correct sorted
  // order. If it is FALSE, it replaces the one instance in the list
  // only if the new one is closer; if the new one is farther away,
  // no instance is created and NULL is returned, meaning that no
  // more work has to be done to set up the SoPickedPoint.
  SoPickedPoint *addIntersection_ ( const SbVec3f &objectSpacePoint, PickedPointListImpl* ppimplptr );
  SoPickedPoint *addIntersection_( SoPickedPoint *pp, PickedPointListImpl* ppimplptr );
  SoPickedPoint *addIntersection_( SoPickedPoint *pp );
 
 
  // Get PickedPoints during a traversal without sorting them by distance
  // this method must be used instead of the getPickedPointList
  // that should be used instead only AFTER the rayPick traversal is completed
  SoPickedPoint *getUnsortedPickedPoint( int i ) const;
 
  // Use preferably this method to get just the number of picked points
  // instead of getPickedPointList()->getLenght(), for performance reason
  int getPickedPointsListLength() const;
 
 private:
  // Initiates action on graph
  virtual void beginTraversal(SoNode *node);
 
 private:
  static void initClass();
  static void exitClass();
 
  // return whether OIV_PICK_OPTIM is set to TRUE
  static SbBool isPickOptimSet()
  { return s_useAlternateIntersection; }
 
  // utility method to test if culling occurs because of clipping planes
  // worldCoord is used to use world coordinates instead of object space coordinates
  static bool isPtCulledByClippingPlanes( const SbVec3f &worldPt, SoState *state, bool worldCoord = true );
 
  // utility method to test if culling occurs because of clipping planes
  // worldCoord is used to use world coordinates instead of object space coordinates
  static bool isBboxCompletelyCulledByClippingPlanes( const SbBox3d& worldBBox, SoState* state, bool worldCoord = true );
  // worldCoord is used to use world coordinates instead of object space coordinates
  static bool isBboxCompletelyCulledByClippingPlanes( const SbBox3f& worldBBox, SoState* state, bool worldCoord = true );
  // worldCoord is used to use world coordinates instead of object space coordinates
  static bool arePointsCulledByAClippingPlane( const std::vector< SbVec3f>& pointVector, SoState* state, bool worldCoord = true );
 
  enum PickedProperties
  {
    NORMALS = 1 << 0,
    TEXCOORDS = 1 << 1,
    
    ALL = ~0
  };
 
  void enablePickedProperties(const enum PickedProperties pickedProperty, const SbBool enable);
 
  SbBool isPickedPropertiesEnabled(const enum PickedProperties pickedProperty) const;
 
  // Returns TRUE if the two SoPickedPoint are the same.
  SbBool isEqual(const SoPickedPoint *pp0, const SoPickedPoint *pp1) const;
 
  // Returns TRUE if the first intersection point is closer to the
  // starting point of the ray than the second.
  SbBool isCloser(const SoPickedPoint *pp0, const SoPickedPoint *pp1) const;
  SbBool isCloser(const SbVec3f& p0, const SbVec3f& p1) const;
 
  // get depth for ray picking sorting
  double getDepth(const SbVec3f& p0) const;
 
  //interface exposed to share SoPath among SoPickedPoints
  void resetCurrPathCache();
 
  enum PointPositionClassification
  {
    INSIDE = 0,
    BEHIND_FAR = 1,
    BEFORE_NEAR = 2,
    BESIDE_LEFT = 3,
    BESIDE_RIGHT = 4,
    UNDER_BOTTOM = 5,
    ABOVE_TOP = 6
  };
 
  PointPositionClassification homogeneSpaceIntersection( const SbVec3f &point, SbVec4f &pPoint ) const;
  SoPath *getClonedCurrPath();
 
  static bool isMTPickingActive();
 
  // get VPradius in pixels (even if it was provided in world coords)
  float getVPRadiusPixel() const ;
 
  /* Because picking points should take care of pointSize without modifying
   * the internal projection matrix,
   * a distosion depending of the size of viewPortRegion is introduced
   * This distorsion can be computed from pointSize
   * By default pointSize is (0, 0)
   * Normal usage should be setPointSizeForPicking( WidthInPixels, HeightInPixels)
   * WARNING: Don't forget to restore previous pointSize after your traversal to avoid side effect
   */
  void setPointSizeForPicking( float pointWidth, float pointHeight);
 
  // Same as previous with an SbVec2f
  void setPointSizeForPicking( const SbVec2f & pointSize)
  { setPointSizeForPicking(pointSize[0], pointSize[1]); }
 
  // Return current pointSize for picking points
  SbVec2f getPointSizeForPicking()
  { return SbVec2f( m_pointWidthForPicking, m_pointHeightForPicking ); }
 
  struct GPUPickInfo
  {
    bool isValid = false;
    SbVec3f modelPosition;
    uint32_t shapeId = 0;
    uint32_t faceId = 0;
    float distToPickCenter = 0.f;
  };
 
  bool canGPUPick() const;
 
  void collectGPUPickingPath();
 
  // Return the picking informations (faceId, shapeId, Position)
  // for the selected point.
  const std::vector<GPUPickInfo>& getGPUPickInfo() const;
      
 private:
  SbBool lineWasSet;  // TRUE if a world-space line was set
  SbBool rayWasComputed;      // TRUE if ray computed by camera
  SbBool pickAll;     // Pick all objects or just closest
  SbVec2s VPPoint;    // Point in viewport coordinates
  SbVec2f VPPointFloat; // Point in viewport coordinates
  SbVec2f normVPPoint;        // Point in normalized vp coordinates
  SbBool normPointSet;        // TRUE if setNormalizedPoint called
  float VPRadius;     // Radius in viewport space pixels
  SbMatrix objToWorld;        // Object-to-world space matrix
  SbMatrix worldToObj;        // World-to-object space matrix
 
  // The ray is defined as an SbViewVolume as in the
  // SoPickRayElement, and is usually stored in an instance of the
  // element. This stores the ray if it is set using setRay().
  SbViewVolume worldVol;
 
  // Users can specify negative near and far distances to indicate
  // that picks should not be clipped to those planes. These flags
  // store that info, since the distances in the view volume can't
  // be negative.
  SbBool clipToNear, clipToFar;
 
  // These store the object-space ray info as a view volume and a
  // line. See the comments on getViewVolume() and getLine().
  SbLine  objLine;     // Line representing ray
  SbLined objLineD;
  SbViewVolume objVol;                // View volume representing ray
 
  // If the caller passes a matrix to setObjectSpace(), the inverse
  // of it is stored here so the object-space angle can be computed
  // correctly later. The extraMatrixSet flag is set to TRUE in this
  // case.
  SbBool extraMatrixSet;
  SbMatrix extraMatrix;
 
  // Computes matrices to go between object and world space
  void computeMatrices();
 
  // Computes object-space view volume and line
  void computeObjVolAndLine();
 
  // updates RayBBox and WMat
  void setUpRayBBoxAndWMat( const SbVec3f &centerPt );
 
  void evalCenterPts( SbVec3f &centerPt, SbVec3d &centerPtD, SbVec3d &projPtD );
 
  // get VPRadius in world coordinates (even if it was provided in pixels)
  float getVPRadiusWorld() const ; 
 
  // Computes distance t of a point along a ray: point = start + t * direction.
  // The point has to be on the ray for this to work
  static float        rayDistance(const SbVec3f &start,
                                  const SbVec3f &direction,
                                  const SbVec3f &point);
 
  // Set commons properties of the action (called by the setRay method)
  void setRayCommonProperties (const SbVec3f &start, const SbVec3f &direction, 
                               float fovy, float aspectRatio = 1.0f, float nearDistance=-1.0f, float farDistance=-1.0f);
 
  // Initialize some members variable when a new point in viewport has been set
  void initializeMembersAfterVPPointSet(bool normalizedPointSet);
 
 
 
  // check if the intersection is inside conic picking volume
  inline SbBool isInConicPickingVolume( const SbVec3f &intersection ) const;
 
  void initSetRayData ( const SbVec3f &start, const SbVec3f &direction,
                        float fovy, float aspectRatio = 1.0f, 
                        float nearDistance = -1.0f, float farDistance = -1.0f );
  
  // Store the current ray bounding box for triangle culling
  SbBool m_canUseTriangleCulling;
  SbBox3f  m_rayBBox ; 
  
 
  // store the current viewvolume matrix and near far in homogene space
  // to optimize intersection computation 
  SbMatrixd m_wmat;
  double m_wnear;
  double m_wfar;
  HomTransfData *m_htdta;
 
  // Indicate if triangle are culled by ray frustum.
  SbBool canUseTriangleCulling() const
  { return (s_triangleCullingEnabled && m_canUseTriangleCulling); }
 
  static SbBool  s_triangleCullingEnabled ;
 
  // generate all picked point properties? (OIV_PICK_GENERATE_ALL_PROPERTIES)
  static SbBool s_generateAllPickedProperties;
 
  //
  static SoCamera::StereoMode s_stereoMode;
 
  // Use faster intersection method (OIV_PICK_OPTIM)
  static SbBool s_useAlternateIntersection;
 
  // Force the raypick action to take ray radius in account
  SbBool m_bEnableRadiusForTriangles;
 
  // Store ray properties
  SbVec3f m_direction;
  SbVec3f m_start;
 
private:
  template<typename SO_NODE_OR_SO_PATH> void commonApply(SO_NODE_OR_SO_PATH* nodeOrPath);
 
  float getCorrectedVPRadius() const;
 
  int m_pickedPropertiesMask;
  PickingMode m_pickingMode;
 
  int m_VPRadiusState;      // how VPRadius has been initialized
 
  // data buffered for the lineWasSet case
  float m_fovy;             
  float m_nearDistance;
  float m_farDistance;
  float m_aspectRatio;
 
  // to force pick volume to be a cone (perspective pick) or a cylinder (orthogonal pick)
  SbBool m_conicPickVolume;
 
  PickedPointListImpl *m_pickedPointListlImpl;
 
  // Only computed by setPointSizeForPicking()
  // Only used in homogeneSpaceIntersection()
  // Store picking error depending of viewPort
  float m_pointPickingErrorX;
  float m_pointPickingErrorY;
  // Store extended pick trap depending of pointSize
  float m_projSpaceWidth;
  float m_projSpaceHeight;
  // Store pointSize for picking point
  float m_pointWidthForPicking;
  float m_pointHeightForPicking;
 
  SoPathList m_gpuPickingCollectionPaths;
  std::vector<SoRayPickAction::GPUPickInfo> m_gpuPickingInfos;
 
  // Render the scene with GPU Picking data attached and
  // retrieve the picking data from the GPU
  // The data can be accessed via getGPUPickingInfo()
  void renderGPUPickingScene();
 
  void fillGPUPickInfos();
};
 
inline 
void SoRayPickAction::enableRadiusForTriangles(SbBool flag)
{
  m_bEnableRadiusForTriangles = flag;  
}
 
inline
SbBool SoRayPickAction::isRadiusEnableForTriangles()
{
  return m_bEnableRadiusForTriangles;
}
#endif /* _SO_RAY_PICK_ACTION_ */