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


       SoDirectionalLightManip — directional light node with 3D interface for editing direction


       SoBase    >    SoFieldContainer    >    SoNode    >   SoLight   >   SoDirectionalLight   >


       #include <Inventor/manips/SoDirectionalLightManip.h>

          Fields from class SoDirectionalLight:

     SoSFVec3f           direction

          Fields from class SoLight:

     SoSFBool            on
     SoSFFloat           intensity
     SoSFColor           color

          Methods from class SoDirectionalLightManip:

     SoDragger *         getDragger()
     SbBool              replaceNode(SoPath *p )
     SbBool              replaceManip(SoPath *p, SoDirectionalLight *newOne ) const
     static SoType       getClassTypeId()

          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


       SoDirectionalLightManip  is  the  base  class for all SoDirectionalLight nodes that have a
       built-in 3D user interface (this is  the  only  such  class  provided  with  the  Inventor
       toolkit). Since it is derived from SoDirectionalLight, any changes to its fields result in
       a change of lighting for nodes that follow it in  the  scene  graph.  In  this  case,  the
       interface  edits  the  direction field. Also, the color of the manipulator's geometry will
       reflect the color of the light (but you cannot edit the color using this manipulator).

       Typically,  you  will   want   to   replace   a   regular   SoDirectionalLight   with   an
       SoDirectionalLightManip (as when the user selects a light to be edited), or vice versa (as
       when the user is done moving the  light  and  the  interface  should  go  away).  Use  the
       replaceNode()  method   to insert a manipulator into a scene graph, and the replaceManip()
       method  to remove it when done.

       The  SoDirectionalLightManip  utilizes  an  SoDirectionalLightDragger  to  provide  a   3D
       interface.  However,  the manipulator differs from the dragger; it lights other objects in
       the scene because, as an SoDirectionalLight, it alters the state.  The  field  values  and
       movement  of  the  dragger, on the other hand, affect only the dragger itself. To find out
       more about how the interface works and what each part will do, see the reference page  for
       SoDirectionalLightDragger.   The  interfaces  of  the  dragger  and  the  manipulator  are

       The SoDirectionalLightManip utilizes its dragger by adding it as a hidden child.  When  an
       action  is  applied  to  the  manipulator,  such  as  rendering  or  handling  events, the
       manipulator first traverses the dragger,  and  then  the  manipulator  adds  its  lighting
       parameters to the state. When you click-drag-release over the manipulator, it passes these
       events down to the dragger, which moves as a result ("I can't help it, I'm a dragger!").

       The manipulator maintains consistency between the  fields  of  the  dragger  and  its  own
       fields.  Let's  say  you  use  the  mouse to rotate the dragger. Callbacks ensure that the
       direction field of the manipulator will change by  the  same  amount,  thus  changing  the
       lighting  of  nodes  which  follow in the scene graph. Similarly, if you set the direction
       field of the SoDirectionalLightManip, the manipulator will orient the dragger accordingly.

       Because the dragger is a hidden child, you can see the dragger on screen and interact with
       it,  but  the  dragger  does not show up when you write the manipulator to file. Also, any
       SoPath will end at the manipulator. (See the Actions section of this reference page for  a
       complete description of when the dragger is traversed).

       If  you want to get a pointer to the dragger you can get it from the manipulator using the
       getDragger() method. You will need to do this if you want to  change  the  geometry  of  a
       manipulator, since the geometry actually belongs to the dragger.



     SoDragger *         getDragger()
          Returns  a  pointer  to the dragger being used by this manipulator. Given this pointer,
          you can customize the dragger just like you would any other  dragger.  You  can  change
          geometry  using  the  setPart() method, or add callbacks using the methods found in the
          SoDragger reference page.

     SbBool              replaceNode(SoPath *p )
          Replaces the tail of the path with this manipulator. The tail of the path  must  be  an
          SoDirectionalLight node (or subclass thereof). If the path has a nodekit, this will try
          to use setPart() to insert the manipulator. Otherwise, the  manipulator  requires  that
          the next to last node in the path chain be a group.

          The  field  values  from the directional light node will be copied to this manipulator,
          and the light node will be replaced.

          The manipulator will not call ref() on the node it is  replacing.  The  old  node  will
          disappear  if  it  has  no  references other than from the input path p and its parent,
          since this manipulator will be replacing it in both  of  those  places.  Nor  will  the
          manipulator  make any changes to field connections of the old node. The calling process
          is thus responsible for keeping track of its own nodes and field connections.

     SbBool              replaceManip(SoPath *p, SoDirectionalLight *newOne ) const
          Replaces the tail of  the  path,  which  must  be  this  manipulator,  with  the  given
          SoDirectionalLight  node.  If the path has a nodekit, this will try to use setPart() to
          insert the new node. Otherwise, the manipulator requires that the next to last node  in
          the path chain be a group.

          The field values from the manipulator will be copied to the directional light node, and
          the manipulator will be replaced.

          The manipulator will not call ref() or unref() on the node which is replacing  it,  nor
          will  it make any changes to field connections. The calling process is thus responsible
          for keeping track of its own nodes and field connections.

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


       SoGLRenderAction,     SoCallbackAction,     SoGetBoundingBoxAction,     SoGetMatrixAction,
       SoHandleEventAction, SoRayPickAction
          First, traverses the dragger the way an SoGroup would. All draggers place themselves in
          space,  but  leave  the  current  transformation  unchanged  when  finished.  Then  the
          SoDirectionalLightManip adds a directional light to the state just like its base class,

          Searches just like an SoDirectionalLight. Does not  search  the  dragger,  which  is  a
          hidden child.

          Writes  out  just  like  an  SoDirectionalLight. Does not write the dragger, which is a
          hidden child. If you really need to write valuable information about the dragger,  such
          as  customized  geometry, you can retrieve the dragger with the getDragger() method and
          then write it out separately.


       DirectionalLightManip {
          on         TRUE
          intensity  1
          color      1 1 1
          direction  0 0 -1


       SoDragger,     SoDirectionalLight,      SoDirectionalLightDragger,      SoPointLightManip,