Coin Logo Coin3D is Free Software,
published under the BSD 3-clause license.
https://coin3d.github.io
https://www.kongsberg.com/en/kogt/
SoRayPickAction Class Reference

The SoRayPickAction class does ray intersection with scene graphs. More...

#include <Inventor/actions/SoRayPickAction.h>

Inheritance diagram for SoRayPickAction:
SoPickAction SoAction

Public Member Functions

virtual SoType getTypeId (void) const
 
 SoRayPickAction (const SbViewportRegion &viewportregion)
 
virtual ~SoRayPickAction ()
 
void setPoint (const SbVec2s &viewportPoint)
 
void setNormalizedPoint (const SbVec2f &normpoint)
 
void setRadius (const float radiusinpixels)
 
float getRadius (void) const
 
void setRay (const SbVec3f &start, const SbVec3f &direction, float neardistance=-1.0, float fardistance=-1.0)
 
void setPickAll (const SbBool flag)
 
SbBool isPickAll (void) const
 
const SoPickedPointListgetPickedPointList (void) const
 
SoPickedPointgetPickedPoint (const int index=0) const
 
void computeWorldSpaceRay (void)
 
SbBool hasWorldSpaceRay (void) const
 
void setObjectSpace (void)
 
void setObjectSpace (const SbMatrix &matrix)
 
SbBool intersect (const SbVec3f &v0, const SbVec3f &v1, const SbVec3f &v2, SbVec3f &intersection, SbVec3f &barycentric, SbBool &front) const
 
SbBool intersect (const SbVec3f &v0, const SbVec3f &v1, SbVec3f &intersection) const
 
SbBool intersect (const SbVec3f &point) const
 
SbBool intersect (const SbBox3f &box, const SbBool usefullviewvolume=TRUE)
 
SbBool intersect (const SbBox3f &box, SbVec3f &intersection, const SbBool usefullviewvolume=TRUE)
 
const SbViewVolumegetViewVolume (void)
 
const SbLinegetLine (void)
 
SbBool isBetweenPlanes (const SbVec3f &intersection) const
 
SoPickedPointaddIntersection (const SbVec3f &objectspacepoint, SbBool frontpick=TRUE)
 
void reset (void)
 
- Public Member Functions inherited from SoPickAction
void setViewportRegion (const SbViewportRegion &newregion)
 
const SbViewportRegiongetViewportRegion (void) const
 
void enableCulling (const SbBool flag)
 
SbBool isCullingEnabled (void) const
 
- Public Member Functions inherited from SoAction
virtual ~SoAction (void)
 
virtual SbBool isOfType (SoType type) const
 
virtual void apply (SoNode *root)
 
virtual void apply (SoPath *path)
 
virtual void apply (const SoPathList &pathlist, SbBool obeysrules=FALSE)
 
void apply (SoAction *beingApplied)
 
virtual void invalidateState (void)
 
AppliedCode getWhatAppliedTo (void) const
 
SoNodegetNodeAppliedTo (void) const
 
SoPathgetPathAppliedTo (void) const
 
const SoPathListgetPathListAppliedTo (void) const
 
const SoPathListgetOriginalPathListAppliedTo (void) const
 
SbBool isLastPathListAppliedTo (void) const
 
PathCode getPathCode (int &numindices, const int *&indices)
 
void traverse (SoNode *const node)
 
SbBool hasTerminated (void) const
 
const SoPathgetCurPath (void)
 
SoStategetState (void) const
 
PathCode getCurPathCode (void) const
 
virtual SoNodegetCurPathTail (void)
 
void usePathCode (int &numindices, const int *&indices)
 
void pushCurPath (const int childindex, SoNode *node=NULL)
 
void popCurPath (const PathCode prevpathcode)
 
void pushCurPath (void)
 
void popPushCurPath (const int childindex, SoNode *node=NULL)
 
void popCurPath (void)
 
void switchToPathTraversal (SoPath *path)
 
void switchToNodeTraversal (SoNode *node)
 

Static Public Member Functions

static SoType getClassTypeId (void)
 
static void addMethod (const SoType type, SoActionMethod method)
 
static void enableElement (const SoType type, const int stackindex)
 
static void initClass (void)
 
- Static Public Member Functions inherited from SoPickAction
static SoType getClassTypeId (void)
 
static void addMethod (const SoType type, SoActionMethod method)
 
static void enableElement (const SoType type, const int stackindex)
 
static void initClass (void)
 
- Static Public Member Functions inherited from SoAction
static void initClass (void)
 
static void initClasses (void)
 
static SoType getClassTypeId (void)
 
static void nullAction (SoAction *action, SoNode *node)
 

Protected Member Functions

virtual const SoEnabledElementsListgetEnabledElements (void) const
 
virtual void beginTraversal (SoNode *node)
 
- Protected Member Functions inherited from SoPickAction
 SoPickAction (const SbViewportRegion &viewportregion)
 
virtual ~SoPickAction (void)
 
- Protected Member Functions inherited from SoAction
 SoAction (void)
 
virtual void endTraversal (SoNode *node)
 
void setTerminated (const SbBool flag)
 
virtual SbBool shouldCompactPathList (void) const
 

Static Protected Member Functions

static SoEnabledElementsListgetClassEnabledElements (void)
 
static SoActionMethodListgetClassActionMethods (void)
 
- Static Protected Member Functions inherited from SoPickAction
static SoEnabledElementsListgetClassEnabledElements (void)
 
static SoActionMethodListgetClassActionMethods (void)
 
- Static Protected Member Functions inherited from SoAction
static SoEnabledElementsListgetClassEnabledElements (void)
 
static SoActionMethodListgetClassActionMethods (void)
 

Additional Inherited Members

- Public Types inherited from SoAction
enum  AppliedCode { NODE = 0, PATH = 1, PATH_LIST = 2 }
 
enum  PathCode { NO_PATH = 0, IN_PATH = 1, BELOW_PATH = 2, OFF_PATH = 3 }
 
- Protected Attributes inherited from SoPickAction
SbViewportRegion vpRegion
 
- Protected Attributes inherited from SoAction
SoStatestate
 
SoActionMethodListtraversalMethods
 

Detailed Description

The SoRayPickAction class does ray intersection with scene graphs.

For interaction with the scene graph geometry, it is necessary to be able to do intersection testing for rays. This functionality is provided by the SoRayPickAction class.

SoRayPickAction can be used to pass arbitrary rays through the scene for intersection detections, by using the setRay() method.

Because a very common operation is to check for intersections along the ray from the mouse cursor upon mouse clicks, it also contains convenience methods for setting up a ray from the near plane to the far plane from the 2D mouse cursor coordinates. See the setPoint() and setNormalizedPoint() methods. A simple usage example for this case is presented below.

Note that one common mistake when using a ray pick action to intersect from a point under the mouse cursor after a mouse click is that one tries to apply it to a scene graph that does not contain a camera explicitly set up by the application programmer. Without a camera as part of the traversal, the ray pick action does not know which view volume to send the ray through.

In this regard, be aware that the getSceneGraph() call in the So*-libraries' viewer classes will return the root of the user-supplied scene graph, not the "real" internal scene graph root used by the viewer (which should always contain a camera node). So ray picks done from the application code will fail when doing this:

// initializing viewer scene graph
SoSeparator * root = new SoSeparator;
root->ref();
ecb->addEventCallback(SoMouseButtonEvent::getClassTypeId(), event_cb, viewer);
root->addChild(ecb);
root->addChild(new SoCone);
viewer->setSceneGraph( root );
// -- [snip] -------------------------
// attempting ray pick in the event_cb() callback method
SoRayPickAction rp( viewer->getViewportRegion() );
rp.setPoint(mouseevent->getPosition());
rp.apply(viewer->getSceneGraph());
// BUG: results will not be what you expected, as no camera was
// part of the "user's scene graph"

While this is the correct way to do it:

// initializing viewer scene graph
SoSeparator * root = new SoSeparator;
root->ref();
// Need to set up our own camera in the "user scene graph", or else
// the ray pick action will fail because the camera is hidden in the
// viewer-specific root of the scene graph.
root->addChild(pcam);
ecb->addEventCallback(SoMouseButtonEvent::getClassTypeId(), event_cb, viewer);
root->addChild(ecb);
root->addChild(new SoCone);
viewer->setSceneGraph( root );
pcam->viewAll( root, viewer->getViewportRegion() );
// -- [snip] -------------------------
// attempting ray pick in the event_cb() callback method
SoRayPickAction rp( viewer->getViewportRegion() );
rp.setPoint(mouseevent->getPosition());
rp.apply(viewer->getSceneGraph());

Or if you do want the convenience of having the viewer set up a camera for you implicitly, you can get hold of the root-node of the "complete" scene graph by simply calling:

SoNode * realroot = viewer->getSceneManager()->getSceneGraph();

Constructor & Destructor Documentation

◆ SoRayPickAction()

SoRayPickAction::SoRayPickAction ( const SbViewportRegion viewportregion)

Constructor.

Some node types need a viewportregion to know exactly how they are positioned within the scene. For an in-depth explanation of why the viewportregion argument is needed, see the documentation of SoGetBoundingBox::SoGetBoundingBox(const SbViewportRegion &).

◆ ~SoRayPickAction()

SoRayPickAction::~SoRayPickAction ( void  )
virtual

Destructor, free temporary resources used by action.

Member Function Documentation

◆ getTypeId()

SoType SoRayPickAction::getTypeId ( void  ) const
virtual

Returns the type identification of an action derived from a class inheriting SoAction. This is used for runtime type checking and "downward" casting.

Usage example:

void bar(SoAction * action)
{
if (action->getTypeId() == SoGLRenderAction::getClassTypeId()) {
// safe downward cast, know the type
SoGLRenderAction * glrender = (SoGLRenderAction *)action;
}
return; // ignore if not render action
}

For application programmers wanting to extend the library with new actions: this method needs to be overridden in all subclasses. This is typically done as part of setting up the full type system for extension classes, which is usually accomplished by using the predefined macros available through Inventor/nodes/SoSubAction.h: SO_ACTION_SOURCE, SO_ACTION_INIT_CLASS and SO_ACTION_CONSTRUCTOR.

For more information on writing Coin extensions, see the SoAction class documentation.

Returns the actual type id of an object derived from a class inheriting SoAction. Needs to be overridden in all subclasses.

Reimplemented from SoPickAction.

◆ addMethod()

void SoRayPickAction::addMethod ( const SoType  type,
SoActionMethod  method 
)
static

This API member is considered internal to the library, as it is not likely to be of interest to the application programmer.

◆ enableElement()

void SoRayPickAction::enableElement ( const SoType  type,
const int  stackindex 
)
static

This API member is considered internal to the library, as it is not likely to be of interest to the application programmer.

◆ getEnabledElements()

const SoEnabledElementsList & SoRayPickAction::getEnabledElements ( void  ) const
protectedvirtual

Returns a list of the elements used by action instances of this class upon traversal operations.

Reimplemented from SoPickAction.

◆ setPoint()

void SoRayPickAction::setPoint ( const SbVec2s viewportpoint)

Sets the viewport-space point. This point is calculated into a line from the near clipping plane to the far clipping plane, and the intersection ray follows the line.

This is a convenient way to detect object intersection below the cursor.

◆ setNormalizedPoint()

void SoRayPickAction::setNormalizedPoint ( const SbVec2f normpoint)

Sets the viewport-space point which the ray is sent through. The coordinate is normalized, ranging from (0, 0) to (1, 1).

See also
setPoint()

◆ setRadius()

void SoRayPickAction::setRadius ( const float  radiusinpixels)

Sets the radius of the picking ray, in screen pixels. Default value is 5.0.

The radius of the intersection ray will only influence the pick operation's behavior versus lines and points, and has no effect on picking of shapes / polygons.

◆ getRadius()

float SoRayPickAction::getRadius ( void  ) const

Gets the radius of the picking ray, in screen pixels.

◆ setRay()

void SoRayPickAction::setRay ( const SbVec3f start,
const SbVec3f direction,
float  neardistance = -1.0,
float  fardistance = -1.0 
)

Sets the intersection ray in world space coordinates.

Use this method if you want to send any ray through the scene to detect intersections, independently of mouse cursor position upon clicks and scene graph camera settings.

◆ setPickAll()

void SoRayPickAction::setPickAll ( const SbBool  flag)

Lets you decide whether or not all the objects the ray intersects with should be picked. If not, only the intersection point of the object closest to the camera will be picked.

Default value of the "pick all" flag is FALSE.

◆ isPickAll()

SbBool SoRayPickAction::isPickAll ( void  ) const

Returns whether only the closest object or all the objects the ray intersects with is picked.

See also
setPickAll()

◆ getPickedPointList()

const SoPickedPointList & SoRayPickAction::getPickedPointList ( void  ) const

Returns a list of the picked points.

◆ getPickedPoint()

SoPickedPoint * SoRayPickAction::getPickedPoint ( const int  index = 0) const

Returns the picked point with index in the list of picked points.

Returns NULL if less than index + 1 points where picked during the last ray pick action.

◆ computeWorldSpaceRay()

void SoRayPickAction::computeWorldSpaceRay ( void  )

This API member is considered internal to the library, as it is not likely to be of interest to the application programmer.

◆ hasWorldSpaceRay()

SbBool SoRayPickAction::hasWorldSpaceRay ( void  ) const

This API member is considered internal to the library, as it is not likely to be of interest to the application programmer.

◆ setObjectSpace() [1/2]

void SoRayPickAction::setObjectSpace ( void  )

This API member is considered internal to the library, as it is not likely to be of interest to the application programmer.

◆ setObjectSpace() [2/2]

void SoRayPickAction::setObjectSpace ( const SbMatrix matrix)

This API member is considered internal to the library, as it is not likely to be of interest to the application programmer.

◆ intersect() [1/5]

SbBool SoRayPickAction::intersect ( const SbVec3f v0_in,
const SbVec3f v1_in,
const SbVec3f v2_in,
SbVec3f intersection,
SbVec3f barycentric,
SbBool &  front 
) const

This API member is considered internal to the library, as it is not likely to be of interest to the application programmer.

◆ intersect() [2/5]

SbBool SoRayPickAction::intersect ( const SbVec3f v0_in,
const SbVec3f v1_in,
SbVec3f intersection 
) const

This API member is considered internal to the library, as it is not likely to be of interest to the application programmer.

◆ intersect() [3/5]

SbBool SoRayPickAction::intersect ( const SbVec3f point_in) const

This API member is considered internal to the library, as it is not likely to be of interest to the application programmer.

◆ intersect() [4/5]

SbBool SoRayPickAction::intersect ( const SbBox3f box,
const SbBool  usefullviewvolume = TRUE 
)

This API member is considered internal to the library, as it is not likely to be of interest to the application programmer.

◆ intersect() [5/5]

SbBool SoRayPickAction::intersect ( const SbBox3f box,
SbVec3f intersection,
const SbBool  usefullviewvolume = TRUE 
)

This API member is considered internal to the library, as it is not likely to be of interest to the application programmer.

◆ getViewVolume()

const SbViewVolume & SoRayPickAction::getViewVolume ( void  )

This API member is considered internal to the library, as it is not likely to be of interest to the application programmer.

◆ getLine()

const SbLine & SoRayPickAction::getLine ( void  )

This API member is considered internal to the library, as it is not likely to be of interest to the application programmer.

◆ isBetweenPlanes()

SbBool SoRayPickAction::isBetweenPlanes ( const SbVec3f intersection_in) const

This API member is considered internal to the library, as it is not likely to be of interest to the application programmer.

◆ addIntersection()

SoPickedPoint * SoRayPickAction::addIntersection ( const SbVec3f objectspacepoint_in,
SbBool  frontpick = TRUE 
)

This API member is considered internal to the library, as it is not likely to be of interest to the application programmer.

◆ reset()

void SoRayPickAction::reset ( void  )

Truncates the internal picked points list.

Since
Coin 2.2

◆ beginTraversal()

void SoRayPickAction::beginTraversal ( SoNode node)
protectedvirtual

This virtual method is called from SoAction::apply(), and is the entry point for the actual scene graph traversal.

It can be overridden to initialize the action at traversal start, for specific initializations in the action subclasses inheriting SoAction.

Default method just calls traverse(), which any overridden implementation of the method must do too (or call SoAction::beginTraversal()) to trigger the scene graph traversal.

Reimplemented from SoPickAction.


The documentation for this class was generated from the following files: