Provided by: inventor-doc_2.1.5-10-18_all bug


       SoSeparator — group node that saves and restores traversal state


       SoBase > SoFieldContainer > SoNode > SoGroup > SoSeparator


       #include <Inventor/nodes/SoSeparator.h>

     enum CacheEnabled {
          SoSeparator::OFF    Never build a cache
          SoSeparator::ON     Always try to build a cache
          SoSeparator::AUTO   Decide whether to cache based on some heuristic

          Fields from class SoSeparator:

     SoSFEnum            renderCaching
     SoSFEnum            boundingBoxCaching
     SoSFEnum            renderCulling
     SoSFEnum            pickCulling

          Methods from class SoSeparator:

                         SoSeparator(int nChildren)
     static void         setNumRenderCaches(int howMany)
     static int          getNumRenderCaches()
     static SoType       getClassTypeId()

          Methods from class SoGroup:

     void                addChild(SoNode *child)
     void                insertChild(SoNode *child, int newChildIndex)
     SoNode *            getChild(int index) const
     int                 findChild(const SoNode *child) const
     int                 getNumChildren() const
     void                removeChild(int index)
     void                removeChild(SoNode *child)
     void                removeAllChildren()
     void                replaceChild(int index, SoNode *newChild)
     void                replaceChild(SoNode *oldChild, SoNode *newChild)

          Methods from class SoNode:

     void                setOverride(SbBool state)
     SbBool              isOverride() const
     SoNode *            copy(SbBool copyConnections = FALSE) const
     virtual SbBool      affectsState() const
     static SoNode *     getByName(const SbName &name)
     static int          getByName(const SbName &name, SoNodeList &list)

          Methods from class SoFieldContainer:

     void                setToDefaults()
     SbBool              hasDefaultValues() const
     SbBool              fieldsAreEqual(const SoFieldContainer *fc) const
     void                copyFieldValues(const  SoFieldContainer  *fc,  SbBool  copyConnections =
     SbBool              set(const char *fieldDataString)
     void                get(SbString &fieldDataString)
     virtual int         getFields(SoFieldList &resultList) const
     virtual SoField *   getField(const SbName &fieldName) const
     SbBool              getFieldName(const SoField *field, SbName &fieldName) const
     SbBool              isNotifyEnabled() const
     SbBool              enableNotify(SbBool flag)

          Methods from class SoBase:

     void                ref()
     void                unref() const
     void                unrefNoDelete() const
     void                touch()
     virtual SoType      getTypeId() const
     SbBool              isOfType(SoType type) const
     virtual void        setName(const SbName &name)
     virtual SbName      getName() const


       This group node performs a push (save)  of  the  traversal  state  before  traversing  its
       children and a pop (restore) after traversing them. This isolates the separator's children
       from the rest of the scene graph. A separator can include  lights,  cameras,  coordinates,
       normals,  bindings,  and  all  other properties. Separators are relatively inexpensive, so
       they can be used freely within scenes.

       The SoSeparator  node  provides  caching  of  state  during  rendering  and  bounding  box
       computation.   This   feature   can   be   enabled   by   setting  the  renderCaching  and
       boundingBoxCaching fields. By default, these are set to AUTO, which  means  that  Inventor
       decides whether to build a cache based on internal heuristics.

       Separators  can  also  perform  culling  during  rendering and picking. Culling skips over
       traversal of the separator's children if they are not going  to  be  rendered  or  picked,
       based  on  the  comparison  of  the separator's bounding box with the current view volume.
       Culling is controlled by the renderCulling and pickCulling fields. These are also  set  to
       AUTO  by  default; however, render culling can be expensive (and can interfere with render
       caching), so the AUTO heuristics leave it disabled unless specified otherwise.


     SoSFEnum            renderCaching
          Whether to cache during rendering traversal.

     SoSFEnum            boundingBoxCaching
          Whether to cache during bounding box traversal.

     SoSFEnum            renderCulling
          Whether to cull during rendering traversal.

     SoSFEnum            pickCulling
          Whether to cull during picking traversal.


          Creates a separator node with default settings.

                         SoSeparator(int nChildren)
          Constructor that takes approximate number of children.

     static void         setNumRenderCaches(int howMany)
          By default, each separator node maintains 2  render  caches.  (This  is  to  allow  two
          different  representations,  such  as  filled  and  wire-frame, to both be cached.) The
          setNumRenderCaches() method  sets the number of render caches each separator will have.
          Each  render  cache  uses  memory,  so  increasing  this number may increase the memory
          requirements of the application. This method affects only separators that  are  created
          after  it  is  called,  not  separators that were created before. Setting the number of
          caches to 0 turns off render caching globally from then on.

     static int          getNumRenderCaches()
          Returns the current number of render caches.

     static SoType       getClassTypeId()
          Returns type identifier for this class.


       SoGLRenderAction,     SoCallbackAction,     SoGetBoundingBoxAction,     SoGetMatrixAction,
       SoHandleEventAction, SoRayPickAction, SoSearchAction
          Saves  the  current  traversal state, traverses all children, and restores the previous
          traversal state.


       Separator {
          renderCaching       AUTO
          boundingBoxCaching  AUTO
          renderCulling       AUTO
          pickCulling         AUTO


       SoSelection, SoTransformSeparator