--- name: "SoRayPickAction" section: "3" platform: "linux" package: "coin" version: "1:4.0.10-1" release: "Arch Linux 2026-11-01" platforms: ["linux"] url: "https://new.carta.tech/SoRayPickAction" --- # SoRayPickAction(3) The SoRayPickAction class does ray intersection with scene graphs. ## NAME SoRayPickAction - The **SoRayPickAction** class does ray intersection with scene graphs. ## SYNOPSIS \#include \ Inherits **SoPickAction**. ### 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 **SoPickedPointList** & **getPickedPointList** (void) const\ **SoPickedPoint** \* **getPickedPoint** (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 **SbViewVolume** & **getViewVolume** (void)\ const **SbLine** & **getLine** (void)\ SbBool **isBetweenPlanes** (const **SbVec3f** &intersection) const\ **SoPickedPoint** \* **addIntersection** (const **SbVec3f** &objectspacepoint, SbBool frontpick=TRUE)\ void **reset** (void)\ Public Member Functions inherited from **SoPickAction** void **setViewportRegion** (const **SbViewportRegion** &newregion)\ const **SbViewportRegion** & **getViewportRegion** (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\ **SoNode** \* **getNodeAppliedTo** (void) const\ **SoPath** \* **getPathAppliedTo** (void) const\ const **SoPathList** \* **getPathListAppliedTo** (void) const\ const **SoPathList** \* **getOriginalPathListAppliedTo** (void) const\ SbBool **isLastPathListAppliedTo** (void) const\ **PathCode** **getPathCode** (int &numindices, const int \*&indices)\ void **traverse** (**SoNode** \*const node)\ SbBool **hasTerminated** (void) const\ const **SoPath** \* **getCurPath** (void)\ **SoState** \* **getState** (void) const\ **PathCode** **getCurPathCode** (void) const\ virtual **SoNode** \* **getCurPathTail** (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 **SoEnabledElementsList** & **getEnabledElements** (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 **SoEnabledElementsList** \* **getClassEnabledElements** (void)\ static **SoActionMethodList** \* **getClassActionMethods** (void)\ Static Protected Member Functions inherited from **SoPickAction** static **SoEnabledElementsList** \* **getClassEnabledElements** (void)\ static **SoActionMethodList** \* **getClassActionMethods** (void)\ Static Protected Member Functions inherited from **SoAction** static **SoEnabledElementsList** \* **getClassEnabledElements** (void)\ static **SoActionMethodList** \* **getClassActionMethods** (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** **SoState** \* **state**\ **SoActionMethodList** \* **traversalMethods**\ ## 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(); SoEventCallback * ecb = new SoEventCallback; 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. SoPerspectiveCamera * pcam = new SoPerspectiveCamera; root->addChild(pcam); SoEventCallback * ecb = new SoEventCallback; 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 (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 (void ) \[virtual\] Destructor, free temporary resources used by action. ## Member Function Documentation ### SoType SoRayPickAction::getTypeId (void ) const \[virtual\] Returns the type identification of an object derived from a class inheriting **SoAction**. This is used for runtime type checking and "downward" casting. Reimplemented from **SoPickAction**. ### SoType SoRayPickAction::getClassTypeId (void ) \[static\] This static method returns the **SoType** object associated with objects of this class. ### 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.*\ ### 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.*\ ### const SoEnabledElementsList & SoRayPickAction::getEnabledElements (void ) const \[protected\], \[virtual\] Returns list of enabled elements. Reimplemented from **SoPickAction**. ### SoEnabledElementsList \* SoRayPickAction::getClassEnabledElements (void ) \[static\], \[protected\] Returns list of enabled elements for this class. The enabledElements and methods variables are protected in the original OIV API. This is not such a good idea, since exposed static class member variables is a major grievance with regard to Win32 DLLs. This function is an extension for Coin, and it is not available in the original SGI Open Inventor v2.1 API.\ ### SoActionMethodList \* SoRayPickAction::getClassActionMethods (void ) \[static\], \[protected\] Returns list of action methods for this class. The enabledElements and methods variables are protected in the original OIV API. This is not such a good idea, since exposed static class member variables is a major grievance with regard to Win32 DLLs. This function is an extension for Coin, and it is not available in the original SGI Open Inventor v2.1 API.\ ### void SoRayPickAction::initClass (void ) \[static\] Initializes the runtime type system for this class, and sets up the enabled elements and action method list. ### 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. ### 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()** ### 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. ### float SoRayPickAction::getRadius (void ) const Gets the radius of the picking ray, in screen pixels. ### 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. ### 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. ### SbBool SoRayPickAction::isPickAll (void ) const Returns whether only the closest object or all the objects the ray intersects with is picked. **See also** **setPickAll()** ### const SoPickedPointList & SoRayPickAction::getPickedPointList (void ) const Returns a list of the picked points. ### 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. ### 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.*\ ### 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.*\ ### 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.*\ ### 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.*\ ### 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.*\ ### 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.*\ ### 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.*\ ### 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.*\ ### 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.*\ ### 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.*\ ### 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.*\ ### 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.*\ ### 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.*\ ### void SoRayPickAction::reset (void ) Truncates the internal picked points list. **Since** Coin 2.2 ### void SoRayPickAction::beginTraversal (SoNode \* node) \[protected\], \[virtual\] 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**. ## Author Generated automatically by Doxygen for Coin from the source code.