SoRayPickAction(3IV)

SoRayPickAction - intersects objects with a ray cast into scene

As shipped in IRIX 6.5.30. Added in IRIX 6.5.22.

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