class ssgBranch - A basic branch node.

There are a rich set of functions for adding, deleting and replacing child nodes:

class ssgBranch : public ssgEntity
{
  int        getNumKids    (void) ;
  ssgEntity *getKid        ( int n ) ;
  ssgEntity *getNextKid    (void) ;
  int        searchForKid  ( ssgEntity *entity ) ;
  void       addKid        ( ssgEntity *entity ) ;
  void       removeKid     ( int n ) ;
  void       removeKid     ( ssgEntity *entity ) ;
  void       removeAllKids (void) ;
  void       replaceKid    ( ssgEntity *old_entity, ssgEntity *new_entity ) ;
} ;

class ssgInvisible - Invisible parts of a Scene Graph.

class ssgRoot - The Root of the Scene Graph,

class ssgRoot : public ssgBranch
{
} ;

class ssgTweenController - A morph controller,

An ssgTween is a leaf node that can hold multiple geometric representations that it smoothly interpolates between.

  ssgTweenController::selectBank ( float b ) ;
  float ssgTweenController::getCurrBank () ;

You can also set the behaviour when the selected bank number is larger than the number of banks in the model. This tends to happen when you simply add some amount of to the bank selector each frame in order to keep the animation running forever:

  ssgTweenController::setMode ( int mode ) ;

class ssgSelector - A switch point,

A selector contains up to 32 daughter objects and a 32 bit unsigned integer mask. Where there is a one bit in the mask, that child object will be drawn, where there is a zero, it will not.

ssgSelector::select(mask) sets the mask, ssgSelector::getSelect() returns the current state of the mask, ssgSelector::selectStep(n) sets the n'th mask bit and zeroes out all the others - effectively causing only the n'th child object to be displayed.

It is quite common to have an ssgSelector with just one child object that can be enabled with select(1) and disabled with select(0).

class ssgTimedSelector - An animation node,

SSG will draw each of the child objects in turn for some amount of time before going onto the next node in the sequence. You set the time for each child using:

   ssgTimedSelector::setDuration ( float time, int which_child ) ;

   ssgTimedSelector::setDuration ( float time ) ;

The animation doesn't have to start at the first child node and end at the last. It is sometimes useful to be able to replay just a subset of them.

   ssgTimedSelector::setLimits ( int start_child, int end_child ) ;

   ssgTimedSelector::setMode ( ssgAnimDirection mode ) ;

     Where mode is one of:

       SSG_ANIM_ONESHOT, SSG_ANIM_SHUTTLE, SSG_ANIM_SWING

• In SSG_ANIM_ONESHOT mode, the animation starts at the first child you specified with setLimits and ends at the last child you specified. Once the last child has been displayed, the animation will automatically go into STOP mode and continue to display that last object until the application intervenes.
• In SSG_ANIM_SHUTTLE mode, the animation goes from the start child to the end child - but unlike SSG_ANIM_ONESHOT, when the animation has finished displaying the last child object, it resets to the start child and does it all over again. SSG_ANIM_SHUTTLE animations don't stop running unless the application stops them.
• In SSG_ANIM_SWING mode, the animation goes from the start child to the end child - but when the end is reached, the animation reverses direction and heads back to the start again. The animation oscillates like a swing until the application stops it.

When all this preparation is done, the application must control the animation:

    ssgTimedSelector::control ( ssgAnimEnum cntrl ) ;

    Where 'cntrl' is one of:

       SSG_ANIM_START, SSG_ANIM_STOP,
       SSG_ANIM_PAUSE, SSG_ANIM_RESUME

When the animation is in SSG_ANIM_STOP mode, you can use this node just like a normal ssgSelector node using the ssgSelector API.

If you need to know which child object is currently being displayed, you cannot call ssgSelector::getSelect() because SSG computes the animation step only if the node is actually on-screen. Instead call ssgTimedSelector::getStep() which returns the currently selected child node.

class ssgRangeSelector - A level of detail node,

Since an ssgRangeSelector is a kind of ssgSelector, you can find out which version of the object was most recently drawn using getSelect(). However, if the object was not drawn recently, that may not be a very useful thing to know. Mostly, it's useful in the post-cull callback.

You set the ranges at which each daughter object will be drawn by passing an array of lengths to ssgRangeSelector::setRanges(float *ranges,int nranges). The first parameter is an array of ranges and the second is the number of elements in that array. Note that element N of the array is the range beyond which child object N will be drawn. The array should contain one more range than there are child objects - and beyond the last range, nothing will be drawn. setRanges takes a copy of your array so you can delete it after the call. If nranges is less than the number required, the remaining ranges will be set to infinity. You can query the current range array with float getRange(int n) which returns the n'th range in the array.

In some cases, you'd like to build several complete versions of an object such that just one of those versions will be drawn - and that is the default behaviour. In other cases, you'd like some basic object to be rendered at long range and for additional parts to be added to it at shorter ranges. This is called 'additive' mode and it is set using setAdditive(int additive) and queried with isAdditive().

class ssgBaseTransform - Nodes with transformations.

class ssgBaseTransform : ssgBranch
{
  void getTransform ( sgMat4 xform ) ;
  virtual void setTransform ( sgVec3 xyz ) ;
  virtual void setTransform ( sgCoord *xform ) ;
  virtual void setTransform ( sgCoord *xform, float sx, float sy, float sz ) ;
  virtual void setTransform ( sgMat4 xform ) ;
} ;

ssgBaseTransform::getTransform(matrix) copies the current transform into the matrix that you provide.

class ssgTransform - Nodes with spatial transformations.

class ssgTexTrans - Nodes with moving texture

class ssgCutout - turn-to-face-the-viewer nodes.

There are actually two distinct forms of ssgCutout - depending on what value is passed as a parameter to the constructor function. ssgCutout(TRUE) produces an object that rotates around it's origin such as to keep the X/Z plane parallel to the screen and ssgCutout(FALSE) produces one that tries to stay parallel to the screen - but which is only allowed to rotate about the Z axis. The latter form is useful for objects with cylindrical symmetry and the former for those with spherical symmetry.

Steve J. Baker. <sjbaker1@airmail.net>