Provided by: libcoin60-doc_3.1.3-2_all bug

NAME

       SoGLRenderAction -

       The SoGLRenderAction class renders the scene graph with OpenGL calls.

       Applying this method at a root node for a scene graph, path or pathlist will render all
       geometry contained within that instance to the current OpenGL context.

SYNOPSIS

       #include <Inventor/actions/SoGLRenderAction.h>

       Inherits SoAction.

       Inherited by SoBoxHighlightRenderAction, and SoLineHighlightRenderAction.

   Public Types
       enum TransparencyType { SCREEN_DOOR, ADD, DELAYED_ADD, SORTED_OBJECT_ADD, BLEND,
           DELAYED_BLEND, SORTED_OBJECT_BLEND, SORTED_OBJECT_SORTED_TRIANGLE_ADD,
           SORTED_OBJECT_SORTED_TRIANGLE_BLEND, NONE, SORTED_LAYERS_BLEND }
       enum TransparentDelayedObjectRenderType { ONE_PASS, NONSOLID_SEPARATE_BACKFACE_PASS }
       enum AbortCode { CONTINUE, ABORT, PRUNE, DELAY }
       enum SortedObjectOrderStrategy { BBOX_CENTER, BBOX_CLOSEST_CORNER, BBOX_FARTHEST_CORNER,
           CUSTOM_CALLBACK }
       typedef AbortCode SoGLRenderAbortCB (void *userdata)

   Public Member Functions
       virtual SoType getTypeId (void) const
       SoGLRenderAction (const SbViewportRegion &viewportregion)
       virtual ~SoGLRenderAction (void)
       void setViewportRegion (const SbViewportRegion &newregion)
       const SbViewportRegion & getViewportRegion (void) const
       void setUpdateArea (const SbVec2f &origin, const SbVec2f &size)
       void getUpdateArea (SbVec2f &origin, SbVec2f &size) const
       void setAbortCallback (SoGLRenderAbortCB *const func, void *const userdata)
       void getAbortCallback (SoGLRenderAbortCB *&func_out, void *&userdata_out) const
       void setTransparencyType (const TransparencyType type)
       TransparencyType getTransparencyType (void) const
       void setTransparentDelayedObjectRenderType (TransparentDelayedObjectRenderType type)
       TransparentDelayedObjectRenderType getTransparentDelayedObjectRenderType (void) const
       void setSmoothing (const SbBool smooth)
       SbBool isSmoothing (void) const
       void setNumPasses (const int num)
       int getNumPasses (void) const
       void setPassUpdate (const SbBool flag)
       SbBool isPassUpdate (void) const
       void setPassCallback (SoGLRenderPassCB *const func, void *const userdata)
       void setCacheContext (const uint32_t context)
       uint32_t getCacheContext (void) const
       void addDelayedPath (SoPath *path)
       SbBool isRenderingDelayedPaths (void) const
       SbBool handleTransparency (SbBool istransparent=FALSE)
       void setCurPass (const int passnum, const int numpasses)
       int getCurPass (void) const
       SbBool abortNow (void)
       void setRenderingIsRemote (SbBool isremote)
       SbBool getRenderingIsRemote (void) const
       virtual void invalidateState (void)
       void addPreRenderCallback (SoGLPreRenderCB *func, void *userdata)
       void removePreRenderCallback (SoGLPreRenderCB *func, void *userdata)
       void setSortedLayersNumPasses (int num)
       int getSortedLayersNumPasses (void) const
       void setSortedObjectOrderStrategy (const SortedObjectOrderStrategy strategy,
           SoGLSortedObjectOrderCB *cb=NULL, void *closure=NULL)
       void setDelayedObjDepthWrite (SbBool write)
       SbBool getDelayedObjDepthWrite (void) const
       SbBool isRenderingTranspPaths (void) const
       SbBool isRenderingTranspBackfaces (void) const

   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)

   Protected Member Functions
       virtual const SoEnabledElementsList & getEnabledElements (void) const
       virtual void beginTraversal (SoNode *node)
       virtual void endTraversal (SoNode *node)

   Static Protected Member Functions
       static SoEnabledElementsList * getClassEnabledElements (void)
       static SoActionMethodList * getClassActionMethods (void)

Detailed Description

       The SoGLRenderAction class renders the scene graph with OpenGL calls.

       Applying this method at a root node for a scene graph, path or pathlist will render all
       geometry contained within that instance to the current OpenGL context.

Member Typedef Documentation

   typedef SoGLRenderAction::SoGLRenderAbortCB Abort callbacks should be of this type.
       See also:
           setAbortCallback()

Member Enumeration Documentation

   enum SoGLRenderAction::TransparencyType Various settings for how to do rendering of
       transparent objects in the scene. Some of the settings will provide faster rendering,
       while others give you better quality rendering.
       Note that doing correct rendering of multiple transparent objects often fails, because to
       be 100% correct, all polygons needs to be rendered in sorted order, and polygons can't
       intersect each other. In a dynamic scene graph it is often impossible to guarantee that no
       polygons intersect, and finding an algorithm that does correct sorting of polygons for all
       possible cases is very hard and time-consuming.

       The highest quality transparency mode in the original SGI / TGS Open Inventor is
       SoGLRenderAction::SORTED_OBJECT_BLEND, where all transparent objects are rendered in
       sorted order in a rendering pass after all opaque objects. However, this mode does not
       sort the polygons, and if you have an object where some polygon A is behind some other
       polygon B, the transparency will only be correct if A happens to be rendered before B. For
       other camera angles, where B is behind A, the transparency will not be correct.

       In Coin we have a new transparency mode that solves some of these problems:
       SoGLRenderAction::SORTED_OBJECT_SORTED_TRIANGLE_BLEND. In addition to sorting the objects,
       all polygons inside each object is also sorted back-to-front when rendering. But, if you
       have intersecting objects and/or intersecting polygons, even this transparency mode will
       fail. Also, because of the polygon sorting, this transparency mode is quite slow. It is
       possible to speed things up using the SoTransparencyType node, though, which enables you
       to set different transparency modes for different parts of the scene graph. If you have
       only have a few objects where you need to sort the polygons, you can use
       SoGLRenderAction::SORTED_OBJECT_SORTED_TRIANGLE_BLEND for those, and for instance
       SoGLRenderAction::SORTED_OBJECT_BLEND for all other transparent objects.

       The highest quality transparency mode in Coin is SoGLRenderAction::SORTED_LAYERS_BLEND. It
       is also the only mode that overrides all other modes in the scenegraph.

       See also:
           SoTransparencyType

       Enumerator:

       SCREEN_DOOR
              Transparent triangles are rendered with a dither pattern. This is a fast (on most
              GFX cards) but not-so-high-quality transparency mode.

       One particular feature of this mode is that you are guaranteed that it always renders the
       transparent parts of the scene correct with regard to internal depth ordering of objects /
       polygons, something which is not the case for any other transparency mode.

       Polygons rendered with only transparent textures are not shown as being transparent when
       using this mode. The reason being that the SCREEN_DOOR mode is working on polygons, not
       pixels. To render polygons with dither pattern, a material node has to be inserted into
       the scenegraph with it's transparency field set.

       ADD    Transparent objects are rendered using additive alpha blending. Additive blending
              is probably mostly used to create special transparency effects. The new pixel color
              is calculated as the current pixel color plus the source pixel color multiplied
              with the source pixel alpha value.

       DELAYED_ADD
              SoGLRenderAction::DELAYED_ADD Transparent objects are rendered using additive alpha
              blending, in a second rendering pass with depth buffer updates disabled.

       SORTED_OBJECT_ADD
              Transparent objects are rendered using additive alpha blending. Opaque objects are
              rendered first, and transparent objects are rendered back to front with z-buffer
              updates disabled.

       BLEND  Transparent objects are rendered using multiplicative alpha blending.

       Multiplicative alpha blending is the blending type that is most often used to render
       transparent objects. The new pixel value is calculated as the old pixel color multiplied
       with one minus the source alpha value, plus the source pixel color multiplied with the
       source alpha value.

       We recommend that you use this transparency mode if you have only one transparent object
       in your scene, and you know that it will be rendered after the opaque objects.

       DELAYED_BLEND
              Transparent objects are rendered using multiplicative alpha blending, in a second
              rendering pass with depth buffer updates disabled.

       Use this transparency type when you have one transparent object, or several transparent
       object that you know will never overlap (when projected to screen). Since the transparent
       objects are rendered after opaque ones, you'll not have to worry about putting the
       transparent objects at the end of your scene graph. It will not be as fast as the BLEND
       transparency type, of course, since the scene graph is traversed twice.

       SORTED_OBJECT_BLEND
              Transparent objects are rendered using multiplicative alpha blending, Opaque
              objects are rendered first, and transparent objects are rendered back to front with
              z-buffer updates disabled.

       Use this transparency mode when you have several transparent object that you know might
       overlap (when projected to screen). This method will require 1 + num_transparent_objects
       rendering passes. Path traversal is used when rendering transparent objects, of course,
       but it might still be slow if you have lots of state changes before your transparent
       object. When using this mode, we recommend placing the transparent objects as early as
       possible in the scene graph to minimize traversal overhead.

       SORTED_OBJECT_SORTED_TRIANGLE_ADD
              This transparency type is a Coin extension versus the original SGI Open Inventor
              API.

       Transparent objects are rendered back to front, and triangles in each object are sorted
       back to front before rendering.

       See description for SORTED_OBJECT_SORTED_TRIANGLE_BLEND for more information about this
       transparency type.

       SORTED_OBJECT_SORTED_TRIANGLE_BLEND
              This transparency type is a Coin extension versus the original SGI Open Inventor
              API.

       Transparent objects are rendered back to front, and triangles in each object are sorted
       back to front before rendering.

       Use this transparency type when you have one (or more) transparent object(s) where you
       know triangles might overlap inside the object. This transparency type might be very slow
       if you have an object with lots of triangles, since all triangles have to be sorted before
       rendering, and an unoptimized rendering loop is used when rendering. Lines and points are
       not sorted before rendering. They are rendered as in the normal SORTED_OBJECT_BLEND
       transparency type.

       Please note that this transparency mode does not guarantee 'correct' transparency
       rendering. It is almost impossible to find an algorithm that will sort triangles correctly
       in all cases, and intersecting triangles are not handled. Also, since each object is
       handled separately, two intersecting object will lead to incorrect transparency.

       NONE   This transparency type is a Coin extension versus the Open Inventor API.

       Turns off transparency for objects, even if transparency is set using an SoMaterial node.

       Since:
           Coin 1.0

       SORTED_LAYERS_BLEND
              This transparency type is a Coin extension versus the original SGI Open Inventor
              API.

       By using this transparency type, the SoGLRenderAction will render normal and intersecting
       transparent objects correctly independent of rendering order. It is the only transparency
       type rendering mode which is guaranteed to do so.

       This mode is different from all other modes in that it overrides the SoTransparencyType
       nodes in the scenegraph; all objects are drawn using SORTED_LAYERS_BLEND.

       There are currently two separate code paths for this mode. Both paths are heavily based on
       OpenGL extensions. The first method is based on extensions which are only available on
       NVIDIA chipsets (GeForce3 and above, except GeForce4 MX). These extensions are
       GL_NV_texture_shader, GL_NV_texture_rectangle or GL_EXT_texture_rectangle,
       GL_NV_register_combiners, GL_ARB_shadow and GL_ARB_depth_texture. Please note that this
       transparency type occupy all four texture units on the NVIDIA card for all the rendering
       passes, except the first. Textured surfaces will therefore only be textured if they are
       not occluded by another transparent surface.

       The second method utilise the GL_ARB_fragment_program extension. This extension is
       currently supported by the GeForceFX family and the Radeon 9500 and above. This technique
       is faster than the pure NVIDIA method. The fragment program method will automatically be
       chosen if possible. Please note that one should beware not to place the near-plane too
       close to the camera due to the lack of floating point precision control in fragment
       programs. Doing so may lead to loss of precision around the edges and 'jaggedness' of the
       transparent geometry.

       Setting the environment variable COIN_SORTED_LAYERS_USE_NVIDIA_RC to '1' will force the
       use of former code path instead of the latter, even if it is available.

       A rendering context with >= 24 bits depth buffer and 8 bits alpha channel must be the
       current rendering context for this blending mode to actually become activated. If the
       current rendering canvas does not have these properties, Coin will fall back on a simpler
       transparency handling mode. If you are using one of the window-system binding libraries
       provided by Kongsberg Oil & Gas Technologies, e.g. SoXt, SoQt or SoWin, you will need to
       explicitly enable this in your viewer. See the API documentation of the setAlphaChannel()
       method of either SoXtGLWidget, SoQtGLWidget or SoWinGLWidget.

       The detection of whether or not the SORTED_LAYERS_BLEND mode can be used will be done
       automatically by the Coin internals. If one or more of the necessary conditions listed
       above are unavailable, SoGLRenderAction::SORTED_OBJECT_BLEND will be used as the
       transparency type instead.

       To be able to render correct transparency independent of object order, one have to render
       in multiple passes. This technique is based on depth-peeling which strips away depth
       layers with each successive pass. The number of passes is therefore an indication of how
       deep into the scene transparent surfaces will be rendered with transparency. A higher
       number will lead to a lower framerate but higher quality for scenes with a lot of
       transparent surfaces. The default number of passes is '4'. This number can be specified
       using the SoGLRenderAction::setSortedLayersNumPasses() or by letting the environment
       variable COIN_NUM_SORTED_LAYERS_PASSES or OIV_NUM_SORTED_LAYERS_PASSES specify the number
       of passes.

       A more detailed presentation of the algorithm is written by Cass Everitt at NVIDIA;

       Since:
           Coin 2.2

           TGS Inventor 4.0

   enum SoGLRenderAction::TransparentDelayedObjectRenderType Enumerates the render types of
       transparent objects.
       Enumerator:

       ONE_PASS
              Normal one pass rendering. This might cause artifacts for non-solid objects.

       NONSOLID_SEPARATE_BACKFACE_PASS
              Non-solid objects are handled in an extra rendering pass. Backfacing polygons are
              rendered in the first pass, and the front facing in the second pass.

   enum SoGLRenderAction::AbortCode The return codes which an SoGLRenderAbortCB callback function
       should use.
       See also:
           setAbortCallback()

       Enumerator:

       CONTINUE
              Continue rendering as usual.

       ABORT  Abort the rendering action immediately.

       PRUNE  Do not render the current node or any of its children, but continue the rendering
              traversal.

       DELAY  Delay rendering of the current node (and its children) until the next rendering
              pass.

   enum SoGLRenderAction::SortedObjectOrderStrategy
       Enumerator:

       BBOX_CENTER
              Do the sorting based on the center of the object bounding box.

       See also:
           setSortedObjectOrderStrategy().

       Since:
           Coin 2.5

       BBOX_FARTHEST_CORNER
              Do the sorting based on the bounding box corner farthest from the camera.

       See also:
           setSortedObjectOrderStrategy().

       Since:
           Coin 2.5

       CUSTOM_CALLBACK
              Use a custom callback to determine the sorting order.

       See also:
           setSortedObjectOrderStrategy().

       Since:
           Coin 2.5

Constructor & Destructor Documentation

   SoGLRenderAction::SoGLRenderAction (const SbViewportRegion &viewportregion) Constructor. Sets
       up the render action for rendering within the given viewportregion.
   SoGLRenderAction::~SoGLRenderAction (void) [virtual] Destructor.

Member Function Documentation

   virtual SoType SoGLRenderAction::getTypeId (void) const [virtual] Returns the type
       identification of an action derived from a class inheriting SoAction. This is used for
       run-time 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 renderaction
         }

       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 pre-
       defined 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.

       Implements SoAction.

   static SoType SoGLRenderAction::getClassTypeId (void) [static] Returns the run-time type
       object associated with instances of this class.
       Reimplemented from SoAction.

   static void SoGLRenderAction::addMethod (const SoTypetype, SoActionMethodmethod) [static] This
       API member is considered internal to the library, as it is not likely to be of interest to
       the application programmer.
   static void SoGLRenderAction::enableElement (const SoTypetype, const intstackindex) [static]
       This API member is considered internal to the library, as it is not likely to be of
       interest to the application programmer.
   virtual const SoEnabledElementsList& SoGLRenderAction::getEnabledElements (void) const
       [protected, virtual] Returns a list of the elements used by action instances of this class
       upon traversal operations.
       Reimplemented from SoAction.

   static SoEnabledElementsList* SoGLRenderAction::getClassEnabledElements (void) [static,
       protected] This API member is considered internal to the library, as it is not likely to
       be of interest to the application programmer.
       This method not available in the original OIV API, see SoSubAction.h for explanation.

       Reimplemented from SoAction.

   static SoActionMethodList* SoGLRenderAction::getClassActionMethods (void) [static, protected]
       This API member is considered internal to the library, as it is not likely to be of
       interest to the application programmer.
       This method not available in the original OIV API, see SoSubAction.h for explanation.

       Reimplemented from SoAction.

   void SoGLRenderAction::initClass (void) [static] Initializes the run-time type system for this
       class, and sets up the enabled elements and action method list.
       Reimplemented from SoAction.

       Reimplemented in SoBoxHighlightRenderAction, and SoLineHighlightRenderAction.

   void SoGLRenderAction::setViewportRegion (const SbViewportRegion &newregion) Sets the viewport
       region for rendering. This will then override the region passed in with the constructor.
   const SbViewportRegion & SoGLRenderAction::getViewportRegion (void) const Returns the viewport
       region for the rendering action.
   void SoGLRenderAction::setUpdateArea (const SbVec2f &origin, const SbVec2f &size) Sets the
       area of the OpenGL context canvas we should render into.
       The coordinates for origin and size should be normalized to be within [0.0, 1.0]. The
       default settings are <0.0, 0.0> for the origin and <1.0, 1.0> for the size, using the full
       size of the rendering canvas.

   void SoGLRenderAction::getUpdateArea (SbVec2f &origin, SbVec2f &size) const Returns
       information about the area of the rendering context window to be updated.
   void SoGLRenderAction::setAbortCallback (SoGLRenderAbortCB *constfunc, void *constuserdata)
       Sets the abort callback. The abort callback is called by the action for each node during
       traversal to check for abort conditions.
       The callback method should return one of the SoGLRenderAction::AbortCode enum values to
       indicate how the action should proceed further.

       Since the client SoGLRenderAbortCB callback function only has a single void* argument for
       the userdata, one has to do some additional work to find out which node the callback was
       made for. One can do this by for instance passing along the action pointer as userdata,
       and then call the SoGLRenderAction::getCurPath() method. The tail of the path will then be
       the last traversed node. Like this:

         // set up so we can abort or otherwise intervene with the render
         // traversal:
         myRenderAction->setAbortCallback(MyRenderCallback, myRenderAction);

         // [...]

         SoGLRenderAction::AbortCode
         MyRenderCallback(void * userdata)
         {
           SoGLRenderAction * action = (SoGLRenderAction *)userdata;
           SoNode * lastnode = action->getCurPath()->getTail();

           // [...]
           return SoGLRenderAction::CONTINUE;
         }

       See also:
           SoGLRenderAction::AbortCode

   void SoGLRenderAction::getAbortCallback (SoGLRenderAbortCB *&func_out, void *&userdata_out)
       const Returns the abort callback settings.
       See also:
           setAbortCallback

       Since:
           Coin 3.0

   void SoGLRenderAction::setTransparencyType (const TransparencyTypetype) Sets the transparency
       rendering method for transparent objects in the scene graph.
       See also:
           SoGLRenderAction::TransparencyType

   SoGLRenderAction::TransparencyType SoGLRenderAction::getTransparencyType (void) const Returns
       the transparency rendering type.
   void SoGLRenderAction::setTransparentDelayedObjectRenderType
       (TransparentDelayedObjectRenderTypetype) Sets the render type of delayed or sorted
       transparent objects. Default is ONE_PASS.
       Since:
           Coin 3.0

   SoGLRenderAction::TransparentDelayedObjectRenderType
       SoGLRenderAction::getTransparentDelayedObjectRenderType (void) const Returns the render
       type of delayed or sorted transparent objects.
       Since:
           Coin 3.0

   void SoGLRenderAction::setSmoothing (const SbBoolsmooth) Sets (or unsets) smoothing. If the
       smoothing flag is on, Coin will try to use built-in features from the OpenGL
       implementation to smooth the appearance of otherwise jagged line and point primitives,
       calling
             glEnable(GL_POINT_SMOOTH);
             glEnable(GL_LINE_SMOOTH);
         .fi

       This is a simple (and computationally non-intensive) way of doing anti-aliasing.

       Default value for this flag is to be off.

   SbBool SoGLRenderAction::isSmoothing (void) const Returns whether smoothing is set or not.
   void SoGLRenderAction::setNumPasses (const intnum) Sets the number of rendering passes.
       Default is 1, anything greater will enable antialiasing through the use of an OpenGL
       accumulation buffer.
   int SoGLRenderAction::getNumPasses (void) const Returns the number of rendering passes done on
       updates.
   void SoGLRenderAction::setPassUpdate (const SbBoolflag) Sets whether each pass should render
       to screen or not.
   SbBool SoGLRenderAction::isPassUpdate (void) const Returns the value of the 'show intermediate
       updates' flag.
       See also:
           setPassUpdate()

   void SoGLRenderAction::setPassCallback (SoGLRenderPassCB *constfunc, void *constuserdata) Sets
       the pass callback. The callback is called between each rendering pass.
   void SoGLRenderAction::setCacheContext (const uint32_tcontext) Sets the OpenGL cache context
       key, which is used for deciding when to share OpenGL display lists.
       Each SoGLRenderAction has a cache context id. This can be set using
       SoGLRenderAction::setCacheContext(). The cache context id must be unique, so that
       different texture objects and display lists are created for uncompatible GL contexts. For
       instance, when SoGLRenderAction traverses an SoTexture2 node, the node checks if it has a
       texture object created for the cache context. If not, a new texture object will be created
       and used when rendering.

       See also:
           SoGLCacheContextElement::getUniqueCacheContext()

   uint32_t SoGLRenderAction::getCacheContext (void) const Returns the cache context key for this
       rendering action instance.
   void SoGLRenderAction::addDelayedPath (SoPath *path) Adds a path to the list of paths to
       render after the current pass.
   SbBool SoGLRenderAction::isRenderingDelayedPaths (void) const Returns a flag indicating
       whether or not we are currently rendering from the list of delayed paths of the scene
       graph.
   SbBool SoGLRenderAction::handleTransparency (SbBoolistransparent = FALSE) Used by shape nodes
       or others which need to know whether or not they should immediately render themselves or
       if they should wait until the next pass. It also enables/disabled blending based on the
       istransparent parameter.
       If you're using an SoCallback or a non-shape node to render your geometry, you can use
       this function to make sure your node is only rendered once. This function consider the
       istransparent parameter, and when TRUE it will return TRUE on the first pass, and FALSE on
       the second pass. For non-transparent objects it returns FALSE on the first pass, TRUE on
       the second.

       Please note that this function considers the current transparency type when deciding what
       to do. It will delay rendering only when the transparency type is DELAYED_* or
       SORTED_OBJECT_*. For other transparency types, transparent objects are rendered in the
       same pass as opaque objects.

   void SoGLRenderAction::setCurPass (const intpassnum, const intnumpasses) Sets the current
       rendering pass to passnum. This can be used when antialiasing is controlled from outside
       the SoGLRenderAction instance. numpasses is the total number of rendering passes to be
       used.
       Please note that this will disable any antialiasing set using the setNumPasses() method.
       You can reenable the internal antialiasing again by calling setNumPasses()

       Since:
           Coin 3.1

   int SoGLRenderAction::getCurPass (void) const Returns the number of the current rendering
       pass.
   SbBool SoGLRenderAction::abortNow (void) Returns TRUE if the render action should abort now
       based on user callback.
       See also:
           setAbortCallback()

   void SoGLRenderAction::setRenderingIsRemote (SbBoolisremote) Let SoGLRenderAction instance
       know if application is running on the local machine or if the rendering instructions are
       sent over the network.
       The flag is used to optimize rendering. For instance should the displaylist caching
       strategy be influenced by this flag to be more aggressive with the caching when rendering
       instructions are passed over the network.

       Default value is FALSE. The value of the flag will not be changed internally from the Coin
       library code, as it is meant to be controlled from client code -- typically from the SoQt
       / SoXt / SoWin / SoGtk libraries.

       See also:
           getRenderingIsRemote()

   SbBool SoGLRenderAction::getRenderingIsRemote (void) const Returns whether or not the
       application is running remotely.
       See also:
           setRenderingIsRemote()

   void SoGLRenderAction::invalidateState (void) [virtual] Invalidates the state, forcing it to
       be recreated at the next apply() invocation.
       Reimplemented from SoAction.

   void SoGLRenderAction::addPreRenderCallback (SoGLPreRenderCB *func, void *userdata) Adds a
       callback which is invoked right before the scene graph traversal starts. All necessary GL
       initialization is then done (e.g. the viewport is correctly set), and this callback can be
       useful to, for instance, clear the viewport before rendering, or draw a bitmap in the
       background before rendering etc.
       The callback is only invoked once (before the first rendering pass) when multi pass
       rendering is enabled.

       Please note that SoSceneManager usually adds a callback to clear the GL buffers in
       SoSceneManager::render(). So, if you plan to for instance draw an image in the color
       buffer using this callback, you should make sure that the scene manager doesn't clear the
       buffer. This can be done either by calling SoSceneManager::render() with both arguments
       FALSE, or, if you're using one of our GUI toolkits (SoXt/SoQt/SoGtk/SoWin), call
       setClearBeforeRender() on the viewer.

       This method is an extension versus the Open Inventor API.

       See also:
           removePreRenderCallback().

   void SoGLRenderAction::removePreRenderCallback (SoGLPreRenderCB *func, void *userdata) Removed
       a callback added with the addPreRenderCallback() method.
       This method is an extension versus the Open Inventor API.

       See also:
           addPreRenderCallback()

   void SoGLRenderAction::setSortedLayersNumPasses (intnum) Sets the number of passes to render
       in SoGLRenderAction::SORTED_LAYERS_BLEND mode. Default number of passes is 4. This number
       can also be adjusted by setting the COIN_NUM_SORTED_LAYERS_PASSES or
       OIV_NUM_SORTED_LAYERS_PASSES environment variable.
   int SoGLRenderAction::getSortedLayersNumPasses (void) const Returns the number of passes to
       render when in SoGLRenderAction::SORTED_LAYERS_BLEND mode.
   void SoGLRenderAction::setSortedObjectOrderStrategy (const SortedObjectOrderStrategystrategy,
       SoGLSortedObjectOrderCB *cb = NULL, void *closure = NULL) Sets the strategy used for
       sorting transparent objects.
       The CUSTOM_CALLBACK strategy enables the user to supply a callback which is called for
       each transparent shape. This strategy can be used if the built in sorting strategies
       aren't sufficient.

       The callback should return a floating point value to be used when sorting the objects in
       Coin. This floating point value is interpreted as a distance to the camera, and objects
       with higher values will be sorted behind objects with lower values.

       The callback will supply the SoGLRenderAction instance, and the path to the current object
       can be found using SoAction::getCurPath().

       Since:
           Coin 2.5

   void SoGLRenderAction::setDelayedObjDepthWrite (SbBoolwrite) Set whether depth buffer updates
       should be done when rendering delayed or sorted transparent objects.
       Since:
           Coin 3.0

   SbBool SoGLRenderAction::getDelayedObjDepthWrite (void) const Return whether depth buffer
       updates should be done when rendering delayed or sorted transparent objects. Default is
       FALSE.
       Since:
           Coin 3.0

   SbBool SoGLRenderAction::isRenderingTranspPaths (void) const Returns TRUE if the action is
       currently rendering delayed or sorted transparent objects.
       Since:
           Coin 3.0

   SbBool SoGLRenderAction::isRenderingTranspBackfaces (void) const Returns TRUE if the action is
       currently rendering backfacing polygons in NONSOLID_SEPARATE_BACKFACE_PASS mode.
       Since:
           Coin 3.0

   void SoGLRenderAction::beginTraversal (SoNode *node) [protected, virtual] This virtual method
       is called from SoAction::apply(), and is the entry point for the actual scenegraph
       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 scenegraph traversal.

       Reimplemented from SoAction.

   void SoGLRenderAction::endTraversal (SoNode *node) [protected, virtual] This virtual method
       can be overridden to execute code after the scene graph traversal. Default method does
       nothing.
       Reimplemented from SoAction.

Author

       Generated automatically by Doxygen for Coin from the source code.