SoGLRenderAction(3IV)

SoGLRenderAction (SoGLRenderAct) - renders a scene graph using OpenGL

Showing IRIX 6.5.30 (default release). Added in IRIX 6.5.22.

NAME
     SoGLRenderAction (SoGLRenderAct) - renders a scene graph using OpenGL

INHERITS FROM
     SoAction > SoGLRenderAction

SYNOPSIS
     #include <Inventor_c/actions/SoGLRenderAction.h>

     typedef AbortCode         SoGLRenderAbortCB(void *userData)
     typedef void              SoGLRenderPassCB(void *userData)
     typedef SoGLRenderAction  SoGLRenderAct

     enum SoGLRenderActionTransparencyType {
          SO_GL_RENDER_ACT_SCREEN_DOOR
                                  Uses stipple patterns for screen-door
                                       transparency
          SO_GL_RENDER_ACT_ADD    Uses additive alpha blending
          SO_GL_RENDER_ACT_DELAYED_ADD
                                  Uses additive blending, rendering all
                                       transparent objects after opaque ones
          SO_GL_RENDER_ACT_SORTED_OBJECT_ADD
                                  Same as DELAYED_ADD, but sorts transparent
                                       objects by distances of bounding boxes
                                       from camera
          SO_GL_RENDER_ACT_BLEND  Uses multiplicative alpha blending
          SO_GL_RENDER_ACT_DELAYED_BLEND
                                  Uses multiplicative alpha blending,
                                       rendering all transparent objects after
                                       opaque ones
          SO_GL_RENDER_ACT_SORTED_OBJECT_BLEND
                                  Same as DELAYED_BLEND, but sorts transparent
                                       objects by distances of bounding boxes
                                       from camera
     }

     enum SoGLRenderActionAbortCode {
          SO_GL_RENDER_ACT_CONTINUE  Continue traversal as usual
          SO_GL_RENDER_ACT_ABORT     Stop traversing the rest of the graph
          SO_GL_RENDER_ACT_PRUNE     Do not traverse this node or its
                                          children, but continue
          SO_GL_RENDER_ACT_DELAY     Delay rendering of this node until the
                                          second pass
     }

          Functions from class SoGLRenderAction:

     SoGLRenderAction *        SoGLRenderActCreate(const SbViewportRegion
                                    *viewportRegion)
     void                      SoGLRenderActSetVPReg(SoGLRenderAct *this,
                                    const SbViewportRegion *newRegion)

     const SbViewportRegion *  SoGLRenderActGetVPReg(const SoGLRenderAct
                                    *this)
     void                      SoGLRenderActSetUpdateArea(SoGLRenderAct *this,
                                    const SbVec2f *origin, const SbVec2f
                                    *size)
     void                      SoGLRenderActGetUpdateArea(const SoGLRenderAct
                                    *this, SbVec2f *origin, SbVec2f *size)
     void                      SoGLRenderActSetAbortCB(SoGLRenderAct *this,
                                    SoGLRenderAbortCB *func, void *userData)
     void                      SoGLRenderActSetTranspType(SoGLRenderAct *this,
                                    TransparencyType type)
     TransparencyType          SoGLRenderActGetTranspType(const SoGLRenderAct
                                    *this)
     void                      SoGLRenderActSetSmoothing(SoGLRenderAct *this,
                                    SbBool smooth)
     SbBool                    SoGLRenderActIsSmoothing(const SoGLRenderAct
                                    *this)
     void                      SoGLRenderActSetNumPasses(SoGLRenderAct *this,
                                    int num)
     int                       SoGLRenderActGetNumPasses(const SoGLRenderAct
                                    *this)
     void                      SoGLRenderActSetPassUpdate(SoGLRenderAct *this,
                                    SbBool flag)
     SbBool                    SoGLRenderActIsPassUpdate(const SoGLRenderAct
                                    *this)
     void                      SoGLRenderActSetPassCB(SoGLRenderAct *this,
                                    SoGLRenderPassCB *func, void *userData)
     void                      SoGLRenderActSetCacheContext(SoGLRenderAct
                                    *this, uint32_t context)
     uint32_t                  SoGLRenderActGetCacheContext(const
                                    SoGLRenderAct *this)

          Functions from class SoAction:

     void                SoGLRenderActApply(SoGLRenderAct *this, SoNode *node)
     void                SoGLRenderActApplyPath(SoGLRenderAct *this, SoPath
                              *path)
     void                SoGLRenderActApplyPathList(SoGLRenderAct *this, const
                              SoPathList *pathList, SbBool obeysRules = FALSE)
     SoType              SoGLRenderActGetClassTypeId()
     SoType              SoGLRenderActGetTypeId(SoGLRenderAct *this)
     SbBool              SoGLRenderActIsOfType(SoGLRenderAct *this, SoType
                              type)
     void                SoGLRenderActInvalidateState(SoGLRenderAct *this)


DESCRIPTION
     This class traverses a scene graph and renders it using the OpenGL
     graphics library. It assumes that a valid window has been created and
     initialized for proper OpenGL rendering. The SoXtRenderArea class or any
     of its subclasses may be used to create such a window.

FUNCTIONS
     SoGLRenderAction *        SoGLRenderActCreate(const SbViewportRegion
                                    *viewportRegion)
          Constructor. The parameter defines the viewport region into which
          rendering will take place.

     void                      SoGLRenderActSetVPReg(SoGLRenderAct *this,
                                    const SbViewportRegion *newRegion)
     const SbViewportRegion *  SoGLRenderActGetVPReg(const SoGLRenderAct
                                    *this)
          Changes/returns viewport region to use for rendering.

     void                      SoGLRenderActSetUpdateArea(SoGLRenderAct *this,
                                    const SbVec2f *origin, const SbVec2f
                                    *size)
     void                      SoGLRenderActGetUpdateArea(const SoGLRenderAct
                                    *this, SbVec2f *origin, SbVec2f *size)
          Sets/returns the current update area, which is the rectangular area
          of the viewport region that will actually be rendered into. This can
          be used for partial updates in applications that can manage them.
          The update area is specified in normalized viewport coordinates,
          where (0,0) is the lower left corner of the viewport and (1,1) is
          the upper right corner. The area is specified or returned as an
          origin and a size.

     void                      SoGLRenderActSetAbortCB(SoGLRenderAct *this,
                                    SoGLRenderAbortCB *func, void *userData)
          Sets callback to call during rendering to test for an abort
          condition. It will be called for each node that is traversed. This
          allows applications to terminate rendering prematurely if some
          condition occurs.  The callback function should return one of the
          AbortCode codes to indicate whether traversal should continue. Use
          of the various codes in a callback can allow applications to modify
          Inventor's default order of rendering objects in a scene graph.

     void                      SoGLRenderActSetTranspType(SoGLRenderAct *this,
                                    TransparencyType type)
     TransparencyType          SoGLRenderActGetTranspType(const SoGLRenderAct
                                    *this)
          Sets/returns transparency quality level to use when rendering. The
          default is SCREEN_DOOR. (Note that SCREEN_DOOR transparency does not
          work in the case where transparency values are specified for each
          vertex of a shape. If this is the case, use one of the other
          transparency types.)

     void                      SoGLRenderActSetSmoothing(SoGLRenderAct *this,
                                    SbBool smooth)
     SbBool                    SoGLRenderActIsSmoothing(const SoGLRenderAct
                                    *this)
          Sets/returns smoothing flag. When on, smoothing uses OpenGL's line-
          and point-smoothing features to provide cheap antialiasing of lines
          and points. The default is FALSE.
     void                      SoGLRenderActSetNumPasses(SoGLRenderAct *this,
                                    int num)
     int                       SoGLRenderActGetNumPasses(const SoGLRenderAct
                                    *this)
          Sets/returns number of rendering passes for multipass rendering.
          Specifying more than one pass will result in antialiasing of the
          rendered scene, using OpenGL's accumulation buffer. (Camera nodes
          typically move their viewpoints a little bit for each pass to
          achieve the antialiasing.) Each additional pass provides better
          antialiasing, but requires more rendering time The default is 1
          pass.

     void                      SoGLRenderActSetPassUpdate(SoGLRenderAct *this,
                                    SbBool flag)
     SbBool                    SoGLRenderActIsPassUpdate(const SoGLRenderAct
                                    *this)
          Sets/returns a flag indicating whether intermediate results are
          displayed after each antialiasing pass for progressive improvement
          (default is FALSE).

     void                      SoGLRenderActSetPassCB(SoGLRenderAct *this,
                                    SoGLRenderPassCB *func, void *userData)
          Sets a callback function to invoke between passes when antialiasing.
          Passing NULL (which is the default state) will cause a clear of the
          color and depth buffers to be performed.

     void                      SoGLRenderActSetCacheContext(SoGLRenderAct
                                    *this, uint32_t context)
     uint32_t                  SoGLRenderActGetCacheContext(const
                                    SoGLRenderAct *this)
          Sets/returns the OpenGL cache context. A cache context is just an
          integer identifying when OpenGL display lists (which are used for
          render caching) can be shared between render actions; for example,
          see the documentation on GLX contexts for information on when OpenGL
          display lists can be shared between GLX windows.


SEE ALSO
     SoSeparator, SoXtRenderArea