## table of contents

SoRayPickAction(3IV)() | SoRayPickAction(3IV)() |

# NAME¶

SoRayPickAction — intersects objects with a ray cast into scene

# INHERITS FROM¶

SoAction > SoPickAction > SoRayPickAction

# SYNOPSIS¶

**#include <Inventor/actions/SoRayPickAction.h>**

Methods from class SoRayPickAction:

** ****SoRayPickAction****(const SbViewportRegion
&viewportRegion)**

**void ****setPoint****(const SbVec2s &viewportPoint)**

**void ****setNormalizedPoint****(const SbVec2f
&normPoint)**

**void ****setRadius****(float radiusInPixels)**

**void ****setRay****(const SbVec3f &start, const SbVec3f
&direction, float nearDistance = -1.0, float farDistance = -1.0)**

**void ****setPickAll****(SbBool flag)**

**SbBool ****isPickAll****() const**

**const SoPickedPointList & ****getPickedPointList****()
const**

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

Methods from class SoPickAction:

**void ****setViewportRegion****(const SbViewportRegion
&newRegion)**

**const SbViewportRegion & ****getViewportRegion****()
const**

Methods from class SoAction:

**virtual void ****apply****(SoNode *node)**

**virtual void ****apply****(SoPath *path)**

**virtual void ****apply****(const SoPathList &pathList,
SbBool obeysRules = FALSE)**

**static SoType ****getClassTypeId****()**

**virtual SoType ****getTypeId****()**

**virtual SbBool ****isOfType****(SoType type)**

**virtual void ****invalidateState****()**

# DESCRIPTION¶

This class performs picking by casting a ray into a scene and
performing intersection tests with each object. The ray is extended to be a
cone or cylinder, depending on the camera type, for intersection with points
and lines. Each intersection is returned as an **SoPickedPoint**
instance.

The picking ray can be specified as either a ray from the camera location through a particular viewport pixel, or as a world-space ray. In the former case, a valid camera must be encountered during traversal of the graph to determine the location of the ray in world space.

Callers can cause the action to compute all intersections along
the ray (sorted closest to farthest) by setting the **pickAll** flag to
TRUE. By default, the action computes only the closest intersection. In
either case, the intersections are returned in 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.

# METHODS¶

** ****SoRayPickAction****(const SbViewportRegion
&viewportRegion)**

Constructor takes viewport region to use for picking. Even though the picking
operation may not involve a window per se, some nodes need this information
to determine their size and placement.

**void ****setPoint****(const SbVec2s &viewportPoint)**

Sets the viewport-space point through which the ray passes, starting at the
camera's viewpoint. Viewport coordinates range from (0,0) at the lower left
to (width-1,height-1) at the upper right.

**void ****setNormalizedPoint****(const SbVec2f
&normPoint)**

Sets the viewport point in normalized coordinates, which range from (0,0) at
the lower left to (1,1) at the upper right.

**void ****setRadius****(float radiusInPixels)**

Set the radius (in pixels) around the point. This is used when testing the ray
against lines and points. By default, the radius is 5 pixels. For
perspective cameras, the ray is extended to be a cone when testing against
lines and points. For orthographic cameras, the ray is extended to be a
cylinder. The radius has no effect for shapes of other types.

**void ****setRay****(const SbVec3f &start, const SbVec3f
&direction, float nearDistance = -1.0, float farDistance = -1.0)**

Sets a world-space ray along which to pick. The ray is defined as a world
space starting point and direction vector. The direction vector will be
normalized automatically. The last two arguments are the parametric
distances between which intersections along the ray must occur. The
distances are measured as if the direction vector is unit length; e.g., if
**nearDistance** is 2.0, the intersection must occur past (**start** +
2*(length of the direction vector)) units along the ray. These distances can
be used to achieve near and far plane clipping. A negative distance (such as
the default values) means disable clipping to that plane.

**void ****setPickAll****(SbBool flag)**

**SbBool ****isPickAll****() const**

Sets/returns whether the action will return all objects intersected or just
the closest one.

**const SoPickedPointList & ****getPickedPointList****()
const**

Returns list of picked points.

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

Returns the indexed picked point from the list.

# SEE ALSO¶

**SoPickedPoint, SoPickedPointList**