other versions
- wheezy-backports 3.1.4~abc9f50-3~bpo70+1
- jessie 3.1.4~abc9f50-7
SoGLRenderAction(3) | Coin | SoGLRenderAction(3) |
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 }
Public Member Functions¶
virtual SoType getTypeId (void) const
Static Public Member Functions¶
static SoType getClassTypeId (void)
Protected Member Functions¶
virtual const
Static Protected Member Functions¶
static SoEnabledElementsList * getClassEnabledElements (void)
Additional Inherited Members¶
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. (One important note about this mode: we've had reports from users that some OpenGL drivers -- possibly particular for some Mac OS X systems -- significantly degrades rendering performance. So be careful and test your application on a wide variety of run-time systems when using SoGLRenderAction::SORTED_LAYERS_BLEND.) See Also:SoTransparencyType
- 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.
- 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.
- DELAYED_BLEND
- Transparent objects are rendered using multiplicative alpha blending, in a second rendering pass with depth buffer updates disabled.
- 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.
- SORTED_OBJECT_SORTED_TRIANGLE_ADD
- This transparency type is a Coin extension versus the original SGI Open Inventor API.
- SORTED_OBJECT_SORTED_TRIANGLE_BLEND
- This transparency type is a Coin extension versus the original SGI Open Inventor API.
- NONE
- This transparency type is a Coin extension versus the Open Inventor API.
Coin 1.0
- SORTED_LAYERS_BLEND
- This transparency type is a Coin extension versus the original SGI Open Inventor API.
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()
- 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.
setSortedObjectOrderStrategy().
Since:
Coin 2.5
- BBOX_FARTHEST_CORNER
- Do the sorting based on the bounding box corner farthest from the camera.
setSortedObjectOrderStrategy().
Since:
Coin 2.5
- CUSTOM_CALLBACK
- Use a custom callback to determine the sorting order.
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¶
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. Reimplemented in SoBoxHighlightRenderAction, and SoLineHighlightRenderAction.
SoType SoGLRenderAction::getClassTypeId (void) [static]¶
Returns the run-time type object associated with instances of this class. Reimplemented from SoAction. Reimplemented in SoBoxHighlightRenderAction, and SoLineHighlightRenderAction.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. Reimplemented in SoBoxHighlightRenderAction, and SoLineHighlightRenderAction.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. Reimplemented in SoBoxHighlightRenderAction, and SoLineHighlightRenderAction.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. Reimplemented in SoBoxHighlightRenderAction, and SoLineHighlightRenderAction.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. Reimplemented in SoBoxHighlightRenderAction, and SoLineHighlightRenderAction.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. Reimplemented in SoBoxHighlightRenderAction, and SoLineHighlightRenderAction.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, callingglEnable(GL_POINT_SMOOTH); glEnable(GL_LINE_SMOOTH);...before rendering the scene. 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.Sat Oct 12 2013 | Version 4.0.0a |