Skip site navigation (1)Skip section navigation (2)

FreeBSD Manual Pages

  
 
  

home | help
SoTransformManip(3IV)()				       SoTransformManip(3IV)()

NAME
       SoTransformManip	-- base	class for all transform	Nodes with built-in 3D
       user interfaces

INHERITS FROM
       SoBase >	SoFieldContainer > SoNode > SoTransformation >	SoTransform  >
       SoTransformManip

SYNOPSIS
       #include	<Inventor/manips/SoTransformManip.h>

	  Fields from class SoTransform:

     SoSFVec3f		 translation
     SoSFRotation	 rotation
     SoSFVec3f		 scaleFactor
     SoSFRotation	 scaleOrientation
     SoSFVec3f		 center

	  Methods from class SoTransformManip:

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

	  Methods from class SoTransform:

     void		 pointAt(const	SbVec3f	&fromPoint, const SbVec3f &to-
			      Point)
     void		 getScaleSpaceMatrix(SbMatrix  &mat,  SbMatrix	 &inv)
			      const
     void		 getRotationSpaceMatrix(SbMatrix  &mat,	SbMatrix &inv)
			      const
     void		 getTranslationSpaceMatrix(SbMatrix   &mat,   SbMatrix
			      &inv) const
     void		 multLeft(const	SbMatrix &mat)
     void		 multRight(const SbMatrix &mat)
     void		 combineLeft(SoTransformation *nodeOnRight)
     void		 combineRight(SoTransformation *nodeOnLeft)
     void		 setMatrix(const SbMatrix &mat)
     void		 recenter(const	SbVec3f	&newCenter)

	  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
       SoTransformManip	 is the	base class for all SoTransform nodes that have
       a built-in 3D user interface. Since it is derived from SoTransform, any
       changes	to its fields result in	the rotation, scaling, and/or transla-
       tion of nodes that follow it in the scene graph.

       Typically, you will want	to replace a regular SoTransform with  an  So-
       TransformManip  (as  when  the  user selects an object to be moved), or
       vice versa (as when the object is deselected, and the motion  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.

       Every  subclass	of SoTransformManip utilizes a dragger of some sort to
       provide a 3D interface. (This class does	not have dragger; but all  the
       subclasses do.) However a manipulator differs from a dragger; it	influ-
       ences other objects in the scene	because, as an SoTransform, it	alters
       the  state.  The	 fields	values and movement of a dragger, on the other
       hand, affect only the dragger itself.

       Each SoTransformManip subclass 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 drag-
       ger,  and  then	the  manipulator adds its transformation matrix	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 insure	that the rotation field	of the manipulator will	change
       by  the same amount, resulting in the rotation of nodes which follow in
       the scene graph.	Similarly, if you  set	any  of	 the  SoTransformManip
       fields  the  manipulator	will move the dragger accordingly. You can use
       this feature to impose contraints on a manipulator: If the  user	 moves
       the  manipulator	 so  that a field value	becomes	too large, you can set
       the field back to your desired maximum, and the whole thing  will  move
       back to where you specified.

       Since  each  SoTransformManip  uses a dragger to	provide	its interface,
       you will	generally be told to look at the dragger's reference page  for
       details	of  how	it moves and what the different	parts are for. The in-
       terface for the dragger and the manipulator will	always be exactly  the
       same. Usually, a	SoTransformManip will surround the objects that	it in-
       fluences	(i.e., those that move along with it). This is because the ma-
       nipulator  turns	on the surroundScale part of its dragger; so the drag-
       ger geometry expands to envelope	the other objects (see	the  reference
       page for	SoSurroundScale).

       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 manipu-
       lator. (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 ma-
       nipulator 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
			 SoTransformManip()
	  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 SoTransform node (or	subclass thereof). If the path
	  has a	nodekit, this will try to use setPart()	to insert the  manipu-
	  lator.  Otherwise,  the  manipulator	requires that the next to last
	  node in the path chain be a group.

	  The field values from	the transform node will	be copied to this  ma-
	  nipulator, and the transform 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 replac-
	  ing 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  con-
	  nections.

     SbBool		 replaceManip(SoPath *p, SoTransform *newOne ) const
	  Replaces  the	tail of	the path, which	must be	this manipulator, with
	  the given SoTransform	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	trans-
	  form 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,  SoGetMa-
       trixAction, SoHandleEventAction,	SoRayPickAction
	  First,  traverses the	dragger	the way	an SoGroup would. All draggers
	  place	themselves in space, but leave the current transformation  un-
	  changed  when	 finished.  Then  the  SoTransformManip	 accumulates a
	  transformation into the current transformation just  like  its  base
	  class, SoTransform.

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

     SoWriteAction
	  Writes out just like an SoTransform. Does  not  write	 the  dragger,
	  which	is a hidden child. If you really need to write valuable	infor-
	  mation about the dragger, such as customized geometry, you  can  re-
	  trieve  the  dragger	with the getDragger() method and then write it
	  out separately.

FILE FORMAT/DEFAULTS
       TransformManip {
	  translation	    0 0	0
	  rotation	    0 0	1  0
	  scaleFactor	    1 1	1
	  scaleOrientation  0 0	1  0
	  center	    0 0	0
     }

SEE ALSO
       SoDragger, SoTransform, SoCenterballManip, SoHandleBoxManip,  SoJackMa-
       nip,  SoSurroundScale, SoTabBoxManip, SoTrackballManip, SoTransformBox-
       Manip, SoTransformerManip

						       SoTransformManip(3IV)()

NAME | INHERITS FROM | SYNOPSIS | DESCRIPTION | METHODS | ACTION BEHAVIOR | FILE FORMAT/DEFAULTS | SEE ALSO

Want to link to this manual page? Use this URL:
<https://www.freebsd.org/cgi/man.cgi?query=SoTransformManip&sektion=3iv&manpath=FreeBSD+12.1-RELEASE+and+Ports>

home | help