SoCallback Class Reference
[Nodes]

Provides custom behavior during actions. More...

#include <Inventor/nodes/SoCallback.h>

Inheritance diagram for SoCallback:
SoNode SoFieldContainer SoBase SoRefCounter SoTypedObject

List of all members.

Public Member Functions

virtual SoType getTypeId () const
 SoCallback ()
void setCallback (SoCallbackCB *func, void *localUserData=NULL)

Static Public Member Functions

static SoType getClassTypeId ()

Detailed Description

Provides custom behavior during actions.

This node provides a general mechanism for executing application code during a scene graph traversal, i.e. when an action is applied to the scene graph.

In some cases, implementing a new node class (a so-called custom node) derived from one of the existing classes is the best and cleanest solution. But for simple cases, and for prototyping, an SoCallback node may solve the problem.

You can use this node to get values from the traversal state list using the SoElement classes and, conversely, to modify values in the traversal state list. For example, SoLineWidthElement contains the current line width and is normally set by an SoDrawStyle node.

You can also use this node to make OpenGL calls while rendering, i.e. when an SoGLRenderAction is applied to the scene graph. If you do, be careful not to interfere with Open Inventor's use of OpenGL and be careful to follow render caching rules. This is discussed further below.

In general you should not use an SoCallback node to count the number of "frames" rendered. You're really counting the number of render traversals and the scene graph may be traversed multiple times to render a single frame. During a render traversal you can get the actual frame count by calling the SoGLRenderAction method getFrameCounter(). See below how to determine if the current action is a render action.

Create the node:

   SoCallback* callbackNode = new SoCallback();
   callbackNode->setCallback( myCallback );
   root->addChild( callbackNode );

Callback:

The callback function registered with the node will be executed during traversal of the scene graph by various Open Inventor actions (not only the render action). Actions commonly applied to the scene graph include SoGLRenderAction, SoHandleEventAction, SoRayPickAction, SoGetBoundingBoxAction, SoSearchAction and SoCallbackAction. You should consider which actions the function should, or should not, be executed for. For example, calling OpenGL functions requires a current OpenGL context and is generally only possible during an SoGLRenderAction traversal. In the callback you can check the action type, for example:

   void myCallback( void* data, SoAction* action )
   {
     // Only handle specific actions
     if (action->isOfType(SoGLRenderAction::getClassTypeId())) {
       // Safe to call OpenGL functions
     }
   }

Callbacks that modify the Open Inventor traversal state, e.g. setting SoLineWidthElement, generally should do that for all actions.

Getting a value from the traversal state list requires access to the SoState object for the current traversal. This information (and more) is available from the SoAction object passed to the callback. Modifying a value in the traversal state list requires the SoState object and, in most cases, a pointer to the node setting the element. This information is also available from the SoAction object as the "tail" node of the action's current path, which is updated for each node visited as the action traverses the scene graph. Getting and modifying the traversal state is shown in the next example. The goal is to highlight some line geometry by making the lines 3X wider than whatever the current line width is. We get the current line width from the traversal state, multiply by three, then set the new line width in the state.

     void myCallback( void* data, SoAction* action )
     {
       // Traversal state
       SoState* state = action->getState();

       // Get current line width from traversal state
       float lineWidth = SoLineWidthElement::get( state );

       // Scale up line width (may be zero)
       lineWidth = (lineWidth > 0) ? (3 * lineWidth) : 3;
     
       // Set new value in state
       SoLineWidthElement::set( state, action->getCurPath()->getTail(), lineWidth );
     }

Cautions:

Most actions do a straightforward “depth first” traversal of the scene graph. In other words, nodes are visited exactly as organized in the scene graph. But SoGLRenderAction’s traversal of the scene graph for rendering is much more complex. The “behavior” implied by the structure of the scene graph is always respected. For example nodes inherit traversal state from above/left and SoSeparator nodes save and restore traversal state. However you cannot assume that there is a single traversal that exactly follows the structure of the scene graph. For example, some parts of the scene graph may be traversed “out of order” to simulate transparency correctly and the scene graph may be traversed multiple times to implement rendering effects like shadows. Because of this, there are some limitations on what can be done in the callback function.

OpenGL calls:

A common use for an SoCallback node is to call specific OpenGL functions during the render traversal that Open Inventor does not provide a node for. In general this is quite possible, because Open Inventor itself uses OpenGL for rendering. However there are issues to consider and because of newer nodes that have been added to Open Inventor it is less necessary than with older versions. Here are some general guidelines:

Render caching:

One of the most important and most effective optimizations in Open Inventor is automatic building of “render caches” (mainly at SoSeparator nodes) for “static” parts of the scene graph. A render cache encapsulates geometry and state (attributes and properties) that can be rendered without scene graph traversal. One advantage is that geometry in a render cache can be optimized for best performance. Another important advantage is that when an SoSeparator has a valid render cache, Open Inventor does not need to traverse its children, avoiding the CPU time to traverse those nodes. In general you should try to ensure that your SoCallback node can be render cached. In most cases SoCallback nodes can be cached even if they access/set traversal state, set OpenGL state or even render geometry using direct OpenGL calls.

If the callback makes OpenGL calls and has no dependency on other data, then in most cases the SoCallback node can be part of a render cache because the OpenGL calls will be recorded as part of the render cache. For example, an SoCallback node that simply calls glEnable() to enable GL_POINT_SPRITE probably can be safely render cached.

If the callback modifies the Open Inventor traversal state based on information from other nodes in the scene graph, then you may be able to get that information from the SoElement object(s) set by those nodes. See the line width example above. In that case the SoCallback node can be part of a render cache, because Open Inventor remembers that the render cache has a dependency on the specific value of the element(s) whose “get” method was called. On subsequent traversals, if the element’s value matches the saved value, then the render cache is still valid and be used. If the element’s value has changed, then the render cache is automatically discarded and the SoSeparator’s children are traversed, so the SoCallback node’s callback will be called again. On later traversals, if the value of the element is no longer changing, Open Inventor will eventually rebuild the render cache. The line width example above can be safely render cached.

In a few cases, the callback node may not be cacheable, depending on what it does. If a callback node relies on any information outside of Inventor that may change (such as a global application variable), it should not be cached, because the callback function will not be executed when the render cache is valid (SoCallback will not be traversed). Also, if the callback node renders geometry that changes often, then it probably should not be cached. We can imagine other cases where the callback function must be executed on every traversal. For example a temporary callback that prints a debug message on every traversal. To prevent Inventor from automatically creating a cache, call the SoCacheElement's invalidate() method in the callback function. But keep in mind that when you do this, it prevents caching by the callback node's parent and that node's parent and every SoSeparator up to the top of the scene graph. To minimize the performance hit, try to only put non-cacheable nodes near the top of the scene graph. Here is a non-cacheable callback:

    void myCallback( void* data, SoAction* action )
    {
      // Only handle specific actions
      if (action->isOfType(SoGLRenderAction::getClassTypeId())) {

        // Traversal state
        SoState* state = action->getState();

        // This node must not be render cached (must be executed).
        SoCacheElement::invalidate( state );

        std::cout << "Render traversal: " << m_counter++ << std::endl;
      }
    }

FILE FORMAT/DEFAULT

ACTION BEHAVIOR

SEE ALSO

SoAction, SoCallbackAction, SoEventCallback

Constructor & Destructor Documentation

SoCallback::SoCallback (  ) 

Creates a callback node with default settings.

Member Function Documentation

static SoType SoCallback::getClassTypeId (  )  [static]

Returns the type identifier for this class.

Reimplemented from SoNode.

virtual SoType SoCallback::getTypeId (  )  const [virtual]

Returns the type identifier for this specific instance.

Reimplemented from SoNode.

void SoCallback::setCallback ( SoCallbackCB *  func,
void *  localUserData = NULL 
) [inline]

Sets pointer to callback function and user data.

By default, the function pointer in the node is NULL and does nothing.

The documentation for this class was generated from the following file:
Open Inventor Toolkit reference manual, generated on 12 Feb 2024
Copyright © Thermo Fisher Scientific All rights reserved. http://www.openinventor.com/