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

name
inherits from
synopsis
description
methods
action behavior
file format/defaults
see also

noble (3) SoDirectionalLightManip.3iv.gz

Provided by: inventor-doc_2.1.5-10+dfsg-2.1build2_all

NAME

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

INHERITS FROM

       SoBase > SoFieldContainer > SoNode > SoLight > SoDirectionalLight > SoDirectionalLightManip

SYNOPSIS

       #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:

                         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 = FALSE)
     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

DESCRIPTION

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 identical.

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.

METHODS

SoDirectionalLightManip()
Constructor.

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.

ACTION BEHAVIOR

       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, SoDirectionalLight.

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

     SoWriteAction
          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.

FILE FORMAT/DEFAULTS

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