NAME
SoClipPlaneManip -
The SoClipPlaneManip class is used to manipulate clip planes.
SYNOPSIS
#include <Inventor/manips/SoClipPlaneManip.h>
Inherits SoClipPlane.
Public Member Functions
SoClipPlaneManip (void)
SoDragger * getDragger (void)
void setValue (const SbBox3f &box, const SbVec3f &planenormal, float
draggerscalefactor)
SbBool replaceNode (SoPath *p)
SbBool replaceManip (SoPath *p, SoClipPlane *newone) const
virtual void doAction (SoAction *action)
virtual void callback (SoCallbackAction *action)
virtual void GLRender (SoGLRenderAction *action)
virtual void getBoundingBox (SoGetBoundingBoxAction *action)
virtual void getMatrix (SoGetMatrixAction *action)
virtual void handleEvent (SoHandleEventAction *action)
virtual void pick (SoPickAction *action)
virtual void search (SoSearchAction *action)
virtual SoChildList * getChildren (void) const
Static Public Member Functions
static void initClass (void)
Public Attributes
SoSFVec3f draggerPosition
Protected Member Functions
virtual ~SoClipPlaneManip (void)
void setDragger (SoDragger *newdragger)
virtual void copyContents (const SoFieldContainer *fromfc, SbBool
copyconnections)
Static Protected Member Functions
static void valueChangedCB (void *f, SoDragger *d)
static void fieldSensorCB (void *f, SoSensor *d)
static void transferFieldValues (const SoClipPlane *from, SoClipPlane
*to)
Protected Attributes
SoFieldSensor * planeFieldSensor
SoFieldSensor * onFieldSensor
SoFieldSensor * draggerPosFieldSensor
SoChildList * children
Detailed Description
The SoClipPlaneManip class is used to manipulate clip planes.
A manipulator is used by replacing the node you want to edit in the
graph with the manipulator. Draggers are used to manipulate the node.
When manipulation is finished, the node is put back into the graph,
replacing the manipulator.
An SoJackDragger is used by instances of this manipulator class as the
default dragger when manipulating SoClipPlane nodes. See the
documentation of SoJackDragger for details about how to control the
manipulator.
An ’action shot’ of the SoClipPlaneManip:
This manipulator is an extension versus the original SGI Inventor v2.1
API. In addition to being a Coin extension, it is also present in TGS’
Inventor implementation (with the same API).
Please not that this manipulator is a bit different than the other
manipulators, since it will not automatically scale and translate the
dragger to surround the geometry. The setValue() function must be used
to initialize the manipulator/dragger. Below you’ll find some example
code that loads an Inventor file and adds a clip plane manipulator.
#include <Inventor/Qt/SoQt.h>
#include <Inventor/Qt/viewers/SoQtExaminerViewer.h>
#include <Inventor/SoDB.h>
#include <Inventor/nodes/SoSeparator.h>
#include <Inventor/actions/SoGetBoundingBoxAction.h>
#include <Inventor/SoInput.h>
#include <Inventor/manips/SoClipPlaneManip.h>
#include <assert.h>
// *************************************************************************
int
main(int argc, char ** argv)
{
assert(argc >= 2);
QWidget * window = SoQt::init(argv[0]);
SoQtExaminerViewer * ex = new SoQtExaminerViewer( window );
ex->setBackgroundColor(SbColor(0.1f, 0.3f, 0.5f));
SoInput input;
SbBool ok = input.openFile(argv[1]);
if (!ok) {
fprintf(stderr,’Unable to open file.0);
return -1;
}
SoSeparator * root = SoDB::readAll(&input);
if (!root) {
fprintf(stderr,’Unable to read file.0);
return -1;
}
root->ref();
SoGetBoundingBoxAction ba(ex->getViewportRegion());
ba.apply(root);
SbBox3f box = ba.getBoundingBox();
SoClipPlaneManip * manip = new SoClipPlaneManip;
manip->setValue(box, SbVec3f(1.0f, 0.0f, 0.0f), 1.02f);
root->insertChild(manip, 0);
ex->setSceneGraph(root);
ex->show();
SoQt::show( window );
SoQt::mainLoop();
delete ex;
root->unref();
return 0;
}
Since:
TGS Inventor 2.5
Coin 1.0
Constructor & Destructor Documentation
SoClipPlaneManip::SoClipPlaneManip (void) An SoJackDragger is set up here
as the internal dragger used for manipulation of an SoClipPlane node.
SoClipPlaneManip::~SoClipPlaneManip (void) [protected, virtual] Destructor.
Member Function Documentation
void SoClipPlaneManip::initClass (void) [static] Sets up initialization for
data common to all instances of this class, like submitting necessary
information to the Coin type system.
Reimplemented from SoClipPlane.
SoDragger * SoClipPlaneManip::getDragger (void) Returns pointer to dragger
used for interaction.
void SoClipPlaneManip::setValue (const SbBox3f & box, const SbVec3f &
planenormal, float draggerscalefactor) Sets the clip plane based on the
center of box and normal. The size of box is used as a scale factor to
the dragger, multiplied with draggerscalefactor.
SbBool SoClipPlaneManip::replaceNode (SoPath * path) Replaces the node
specified by path with this manipulator. The manipulator will copy the
field data from the node, to make it affect the state in the same way
as the node.
SbBool SoClipPlaneManip::replaceManip (SoPath * path, SoClipPlane * newone)
const Replaces this manipulator from the position specified by path
with newnode. If newnode is NULL, an SoClipPlane will be created for
you.
void SoClipPlaneManip::doAction (SoAction * action) [virtual] This function
performs the typical operation of a node for any action.
Reimplemented from SoClipPlane.
void SoClipPlaneManip::callback (SoCallbackAction * action) [virtual]
Action method for SoCallbackAction.
Simply updates the state according to how the node behaves for the
render action, so the application programmer can use the
SoCallbackAction for extracting information about the scene graph.
Reimplemented from SoClipPlane.
void SoClipPlaneManip::GLRender (SoGLRenderAction * action) [virtual]
Action method for the SoGLRenderAction.
This is called during rendering traversals. Nodes influencing the
rendering state in any way or who wants to throw geometry primitives at
OpenGL overrides this method.
Reimplemented from SoClipPlane.
void SoClipPlaneManip::getBoundingBox (SoGetBoundingBoxAction * action)
[virtual] Action method for the SoGetBoundingBoxAction.
Calculates bounding box and center coordinates for node and modifies
the values of the action to encompass the bounding box for this node
and to shift the center point for the scene more towards the one for
this node.
Nodes influencing how geometry nodes calculates their bounding box also
overrides this method to change the relevant state variables.
Reimplemented from SoNode.
void SoClipPlaneManip::getMatrix (SoGetMatrixAction * action) [virtual]
Action method for SoGetMatrixAction.
Updates action by accumulating with the transformation matrix of this
node (if any).
Reimplemented from SoNode.
void SoClipPlaneManip::handleEvent (SoHandleEventAction * action) [virtual]
Action method for SoHandleEventAction.
Inspects the event data from action, and processes it if it is
something which this node should react to.
Nodes influencing relevant state variables for how event handling is
done also overrides this method.
Reimplemented from SoNode.
void SoClipPlaneManip::pick (SoPickAction * action) [virtual] Action method
for SoPickAction.
Does common processing for SoPickAction action instances.
Reimplemented from SoClipPlane.
void SoClipPlaneManip::search (SoSearchAction * action) [virtual] Action
method for SoSearchAction.
Compares the search criteria from the action to see if this node is a
match. Searching is done by matching up all criteria set up in the
SoSearchAction -- if any of the requested criteria is a miss, the
search is not deemed successful for the node.
See also:
SoSearchAction
Reimplemented from SoNode.
SoChildList * SoClipPlaneManip::getChildren (void) const [virtual] Returns
the children of this node.
Reimplemented from SoNode.
void SoClipPlaneManip::setDragger (SoDragger * newdragger) [protected] Sets
a dragger to use for this manipulator. The default dragger is an
SoJackDragger.
void SoClipPlaneManip::copyContents (const SoFieldContainer * from, SbBool
copyconnections) [protected, virtual] Makes a deep copy of all data of
from into this instance, except external scenegraph references if
copyconnections is FALSE.
This is the protected method that should be overridden by extension
node / engine / dragger / whatever subclasses which needs to account
for internal data that are not handled automatically.
For copying nodes from application code, you should not invoke this
function directly, but rather call the SoNode::copy() function:
SoNode * mynewnode = templatenode->copy();
The same also goes for engines.
Make sure that when you override the copyContents() method in your
extension class that you also make it call upwards to it’s parent
superclass in the inheritance hierarchy, as copyContents() in for
instance SoNode and SoFieldContainer does important work. It should go
something like this:
void
MyCoinExtensionNode::copyContents(const SoFieldContainer * from,
SbBool copyconnections)
{
// let parent superclasses do their thing (copy fields, copy
// instance name, etc etc)
SoNode::copyContents(from, copyconnections);
// [..then copy internal data..]
}
Reimplemented from SoNode.
void SoClipPlaneManip::valueChangedCB (void * m, SoDragger * dragger)
[static, protected] This API member is considered internal to the
library, as it is not likely to be of interest to the application
programmer.
Called whenever dragger is touched.
void SoClipPlaneManip::fieldSensorCB (void * m, SoSensor * s) [static,
protected] This API member is considered internal to the library, as it
is not likely to be of interest to the application programmer.
Called whenever one of the fields changes value.
void SoClipPlaneManip::transferFieldValues (const SoClipPlane * from,
SoClipPlane * to) [static, protected] Copies field values from one clip
plane node to another.
Member Data Documentation
SoSFVec3f * SoClipPlaneManip::draggerPosition This API member is considered
internal to the library, as it is not likely to be of interest to the
application programmer.
SoFieldSensor * SoClipPlaneManip::planeFieldSensor [protected] This API
member is considered internal to the library, as it is not likely to be
of interest to the application programmer.
SoFieldSensor * SoClipPlaneManip::onFieldSensor [protected] This API member
is considered internal to the library, as it is not likely to be of
interest to the application programmer.
SoFieldSensor * SoClipPlaneManip::draggerPosFieldSensor [protected] This
API member is considered internal to the library, as it is not likely
to be of interest to the application programmer.
SoChildList * SoClipPlaneManip::children [protected] This API member is
considered internal to the library, as it is not likely to be of
interest to the application programmer.
Author
Generated automatically by Doxygen for Coin from the source code.