NAME
SoBaseKit -
The SoBaseKit class is the toplevel superclass for nodekits.
Node kits are collections of nodes and other node kits (from here on
node kits which are part of some other node kit, will only be referred
to as nodes or parts, see catalogs and parts), organized in a way that
is convenient for its use. A node kit inherits SoNode and can thus be
inserted into a scenegraph as any other node.
SYNOPSIS
#include <Inventor/nodekits/SoBaseKit.h>
Inherits SoNode.
Inherited by SoAppearanceKit, SoCameraKit, SoForeignFileKit,
SoInteractionKit, SoLightKit, SoNodeVisualize, SoProfilerOverlayKit,
SoProfilerVisualizeKit, SoSceneKit, SoScrollingGraphKit, and
SoSeparatorKit.
Public Member Functions
SoBaseKit (void)
virtual const SoNodekitCatalog * getNodekitCatalog (void) const
virtual SoNode * getPart (const SbName &partname, SbBool makeifneeded)
SbString getPartString (const SoBase *part)
virtual SoNodeKitPath * createPathToPart (const SbName &partname,
SbBool makeifneeded, const SoPath *pathtoextend=NULL)
virtual SbBool setPart (const SbName &partname, SoNode *from)
SbBool set (const char *namevaluepairliststring)
SbBool set (const char *partnamestring, const char *parameterstring)
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 rayPick (SoRayPickAction *action)
virtual void search (SoSearchAction *action)
virtual void write (SoWriteAction *action)
virtual void getPrimitiveCount (SoGetPrimitiveCountAction *action)
virtual SoChildList * getChildren (void) const
void printDiagram (void)
void printSubDiagram (const SbName &rootname, int level)
void printTable (void)
virtual void addWriteReference (SoOutput *out, SbBool isfromfield=0)
SbBool forceChildDrivenWriteRefs (SoOutput *out)
Static Public Member Functions
static void initClass (void)
static const SoNodekitCatalog * getClassNodekitCatalog (void)
static SbBool isSearchingChildren (void)
static void setSearchingChildren (const SbBool newval)
Protected Member Functions
virtual ~SoBaseKit ()
virtual SoNode * addToCopyDict (void) const
virtual void copyContents (const SoFieldContainer *fromfc, SbBool
copyconnections)
SoGroup * getContainerNode (const SbName &listname, SbBool
makeifneeded=1)
virtual SoNode * getAnyPart (const SbName &partname, SbBool
makeifneeded, SbBool leafcheck=0, SbBool publiccheck=0)
virtual SoNodeKitPath * createPathToAnyPart (const SbName &partname,
SbBool makeifneeded, SbBool leafcheck=0, SbBool publiccheck=0,
const SoPath *pathtoextend=NULL)
virtual SbBool setAnyPart (const SbName &partname, SoNode *from, SbBool
anypart=1)
void createNodekitPartsList (void)
void createFieldList (void)
virtual void createDefaultParts (void)
const SoNodekitParts * getNodekitPartsList (void) const
const SbList< SoSFNode * > & getCatalogInstances (void) const
void catalogError (void)
virtual SbBool setUpConnections (SbBool onoff, SbBool doitalways=0)
virtual SbBool readInstance (SoInput *in, unsigned short flags)
virtual void setDefaultOnNonWritingFields (void)
void countMyFields (SoOutput *out)
virtual SbBool setPart (const int partNum, SoNode *node)
Static Protected Member Functions
static const SoNodekitCatalog ** getClassNodekitCatalogPtr (void)
Protected Attributes
SoChildList * children
SbBool connectionsSetUp
Detailed Description
The SoBaseKit class is the toplevel superclass for nodekits.
Node kits are collections of nodes and other node kits (from here on
node kits which are part of some other node kit, will only be referred
to as nodes or parts, see catalogs and parts), organized in a way that
is convenient for its use. A node kit inherits SoNode and can thus be
inserted into a scenegraph as any other node.
The organizing of the nodes and node kits of some node kit, is done
through catalogs. A node kit’s catalog describes the nodes that can be
members of the node kit. These members are called parts. Thus a node
kit has a catalog describing the parts that it offers to the user.
Each part in the catalog has some values saying something about the
part itself and about the role the part plays in the scenegraph. Those
values are:
Name
The name of the part.
Type
The part’s node type.
Default Type
If the part’s type is an abstract superclass, this value will hold
the default subclass used by this part.
Created by Default?
Holds TRUE if the part should be instantiated when the node kit is
instantiated, otherwise the part is kept empty until it is set by
some of the means applicable.
Parent Name
The name of the part that is this part’s parent.
Right Sibling
The name of the part that is the part immediately to the right of
this part in the node kit scenegraph.
Is it a List?
Holds TRUE if the part is a list, otherwise it is FALSE. See
SoNodeKitListPart for more info on node kit lists.
List Cointainer Type
The type of group node used to hold the items if the part is a
list.
List Element Type
The types of nodes that is allowed to be held by this part if the
part is a list.
Is It Public?
Holds TRUE if the part should be publically available, otherwise it
holds FALSE.
Node kits use lazy instantiation when it creates it’s parts. This means
that the nodes making up the parts of the nodekit only are created when
they are needed. If the ’Created by Default?’ holds TRUE, then the part
is created when the node kit itself is instantiated. If not, parts are
created when they are requested through SoBaseKit::getPart() or the
SO_GET_PART() macro, or created with SoBaseKit::set(). Also, if a part
is set with SoBaseKit::setPart() or the SO_SET_PART() macro, any
previously uncreated parts above the set part in the hierarchy, is
created automatically.
The advantages of using node kits to represent a scenegraph are many.
· Since a node kit collects nodes into a single unit, it becomes an
extra abstraction layer for the application programmer. Such a layer
can represent a model of a human being as one unit where subunits as
arms, legs, textures, etc are contained within. Thus we can
instantiate a model of a human by creating an instance of the node
kit, instead of having to create a possibly large amount of nodes
needed for such a model.
· A part of the node kit doesn’t have one specific setup. A shape part
can e.g. be swapped with any other shape, since they are of the same
type. If the node kit of a human has a part called ’head’ which is of
type SoShape, it might default to a sphere. But if the programmer
thinks that a cube might fit better, one can set the ’head’ part to a
cube instead, or maybe a face set representing a complex model of a
head.
· Node kits can have as simple or as complex catalogs as needed. The
nodes included in the node kit can, if needed, represent the whole
range of Inventor features. One part can as easily be of a node kit
type, making it possible to create hierarchies of node kits. Having a
node kit of a human, it might be feasible to have sub node kits
describing the different body parts.
· Node kits are an efficient way of creating scenegraphs. If some part
of it isn’t needed at the moment of node kit instantiation, they
aren’t created. Thus parts are only created when needed, either by
the application or some other part.
· The application code becomes smaller and easier to read, as the node
kits provides simple routines for creating and setting parts.
· New node kits can be created through subclassing to obtain simple
setups of scenegraphs best fitted to the application.
The usage of a node kit is straightforward. Below follows a code
example showing some simple SoShapeKit usage.
#include <Inventor/Qt/SoQt.h>
#include <Inventor/Qt/viewers/SoQtExaminerViewer.h>
#include <Inventor/nodekits/SoShapeKit.h>
#include <Inventor/nodes/SoSeparator.h>
#include <Inventor/nodes/SoCube.h>
int
main(int argc, char ** argv)
{
QWidget * window = SoQt::init(argv[0]);
SoQtExaminerViewer * viewer = new SoQtExaminerViewer(window);
// Instantiating a shape kit, by default creating a simple sphere.
SoShapeKit * shapekit = new SoShapeKit;
// Swapping the sphere with a cube.
shapekit->setPart(’shape’, new SoCube);
// Setting the cube to be rendered in the color red. The shape kit
// has a SoAppearanceKit as one of it’s parts. The ’material’ part
// used to set the color of the shape, really belongs the
// appearance kit. If the SoShapeKit::set() is used, it will
// check if some of its sub kits has a part with the name given,
// and delegate the setting to the correct kit.
shapekit->set(’material’, ’diffuseColor 1 0 0’);
SoSeparator * newroot = new SoSeparator;
newroot->ref();
newroot->addChild(shapekit);
viewer->setSceneGraph(newroot);
viewer->show();
SoQt::show(window);
SoQt::mainLoop();
delete viewer;
newroot->unref();
return 0;
}
The above code snippet will produce a viewer with a side view to the
scene shown below:
Notice that the code needed for creating this simple shape using a
shape kit, amounts to this:
SoShapeKit * shapekit = new SoShapeKit;
shapekit->setPart(’shape’, new SoCube);
shapekit->set(’material’, ’diffuseColor 1 0 0’);
SoSeparator * root = new SoSeparator;
SoMaterial * material = new SoMaterial;
material->diffuseColor.setValue(1,0,0);
root->addChild(material);
root->addChild(new SoCube);
For extending the Coin library with your own classes, we strongly
recommend that you make yourself acquainted with the excellent «The
Inventor Toolmaker» book (ISBN 0-201-62493-1), which describes the
tasks involved in detail. This book was written by the original SGI
Inventor designers and explains many of the underlying design ideas,
aswell as having lots of hands-on examples on how to extend the Coin
toolkit in ways that are true to the fundamental design ideas. («The
Inventor Toolmaker» is also available at SGI’s online library, at no
cost. See Download The Inventor Toolmaker.) Reading the sourcecode of
the built-in classes in Coin should also provide very helpful.
Following is a complete example of a node kit extension. The node kit
is a kit which automatically scales a shape so it will be the same size
in screen-pixels, no matter which distance it is from the camera. This
is useful for marker graphics. The shape defaults to a cube, but can be
set by the programmer to any shape or scene sub-graph.
The header file:
// Copyright (C) 1998-2010 by Kongsberg Oil & Gas Technologies. All rights reserved.
#ifndef COIN_SHAPESCALE_H
#define COIN_SHAPESCALE_H
#include <Inventor/nodekits/SoSubKit.h>
#include <Inventor/nodekits/SoBaseKit.h>
#include <Inventor/fields/SoSFFloat.h>
class SbViewport;
class SoState;
class SbColor;
class SbVec2s;
class ShapeScale : public SoBaseKit {
typedef SoBaseKit inherited;
SO_KIT_HEADER(ShapeScale);
SO_KIT_CATALOG_ENTRY_HEADER(topSeparator);
SO_KIT_CATALOG_ENTRY_HEADER(scale);
SO_KIT_CATALOG_ENTRY_HEADER(shape);
public:
ShapeScale(void);
static void initClass(void);
SoSFFloat active;
SoSFFloat projectedSize;
protected:
virtual void GLRender(SoGLRenderAction * action);
virtual ~ShapeScale();
};
#endif // ! SHAPESCALE_H
The source code for the example:
// Copyright (C) 1998-2010 by Kongsberg Oil & Gas Technologies. All rights reserved.
// The ShapeScale class is used for scaling a shape based on
// projected size.
//
// This nodekit can be inserted in your scene graph to add for
// instance 3D markers that will be of a constant projected size.
//
// The marker shape is stored in the ’shape’ part. Any kind of node
// can be used, even group nodes with several shapes, but the
// marker shape should be approximately of unit size, and with a
// center position in (0, 0, 0).
// SoSFFloat ShapeScale::active
// Turns the scaling on/off. Default value is TRUE.
// SoSFFloat ShapeScale::projectedSize
// The requested projected size of the shape. Default value is 5.0.
#include ’ShapeScale.h’
#include <Inventor/actions/SoGLRenderAction.h>
#include <Inventor/nodes/SoShape.h>
#include <Inventor/nodes/SoScale.h>
#include <Inventor/nodes/SoCube.h>
#include <Inventor/nodes/SoSeparator.h>
#include <Inventor/elements/SoViewVolumeElement.h>
#include <Inventor/elements/SoViewportRegionElement.h>
#include <Inventor/elements/SoModelMatrixElement.h>
SO_KIT_SOURCE(ShapeScale);
// Constructor.
ShapeScale::ShapeScale(void)
{
SO_KIT_CONSTRUCTOR(ShapeScale);
SO_KIT_ADD_FIELD(active, (TRUE));
SO_KIT_ADD_FIELD(projectedSize, (5.0f));
SO_KIT_ADD_CATALOG_ENTRY(topSeparator, SoSeparator, FALSE, this, , FALSE);
SO_KIT_ADD_CATALOG_ABSTRACT_ENTRY(shape, SoNode, SoCube, TRUE, topSeparator, , TRUE);
SO_KIT_ADD_CATALOG_ENTRY(scale, SoScale, FALSE, topSeparator, shape, FALSE);
SO_KIT_INIT_INSTANCE();
}
// Destructor.
ShapeScale::~ShapeScale()
{
}
// Initializes this class. Call before using it.
void
ShapeScale::initClass(void)
{
SO_KIT_INIT_CLASS(ShapeScale, SoBaseKit, ’BaseKit’);
}
static void
update_scale(SoScale * scale, const SbVec3f & v)
{
// only write to field when scaling has changed.
if (scale->scaleFactor.getValue() != v) {
scale->scaleFactor = v;
}
}
// Overridden to (re)initialize scaling before rendering marker.
void
ShapeScale::GLRender(SoGLRenderAction * action)
{
SoState * state = action->getState();
SoScale * scale = (SoScale*) this->getAnyPart(SbName(’scale’), TRUE);
if (!this->active.getValue()) {
update_scale(scale, SbVec3f(1.0f, 1.0f, 1.0f));
}
else {
const SbViewportRegion & vp = SoViewportRegionElement::get(state);
const SbViewVolume & vv = SoViewVolumeElement::get(state);
SbVec3f center(0.0f, 0.0f, 0.0f);
float nsize = this->projectedSize.getValue() / float(vp.getViewportSizePixels()[1]);
SoModelMatrixElement::get(state).multVecMatrix(center, center); // transform to WCS
float scalefactor = vv.getWorldToScreenScale(center, nsize);
update_scale(scale, SbVec3f(scalefactor, scalefactor, scalefactor));
}
inherited::GLRender(action);
}
And a complete example showing how one can use this node kit:
// Copyright (C) 1998-2010 by Kongsberg Oil & Gas Technologies. All rights reserved.
#include <Inventor/Qt/SoQt.h>
#include <Inventor/Qt/viewers/SoQtExaminerViewer.h>
#include <Inventor/SoInput.h>
#include <Inventor/SoOutput.h>
#include <Inventor/SoPickedPoint.h>
#include <Inventor/actions/SoRayPickAction.h>
#include <Inventor/events/SoMouseButtonEvent.h>
#include <Inventor/nodes/SoBaseColor.h>
#include <Inventor/nodes/SoCube.h>
#include <Inventor/nodes/SoEventCallback.h>
#include <Inventor/nodes/SoSeparator.h>
#include <Inventor/nodes/SoSwitch.h>
#include <Inventor/nodes/SoTranslation.h>
#include <assert.h>
#include <stdlib.h>
#include <time.h>
#include ’ShapeScale.h’
// Returns random value between 0.0f and 1.0f.
static float
normalized_rand(void)
{
return float(rand())/float(RAND_MAX);
}
static SoSeparator *
construct_new_marker(const SbVec3f & v)
{
SoSeparator * markerroot = new SoSeparator;
SoTranslation * t = new SoTranslation;
t->translation = v;
markerroot->addChild(t);
ShapeScale * kit = new ShapeScale;
kit->active = TRUE;
kit->projectedSize = 5.0f;
// create the marker
SoSeparator * markersep = new SoSeparator;
SoBaseColor * mat = new SoBaseColor;
mat->rgb.setValue(normalized_rand(), normalized_rand(), normalized_rand());
markersep->addChild(mat);
// marker shape should be unit size, with center in (0.0f, 0.0f, 0.0f)
SoCube * cube = new SoCube;
cube->width = 1.0f;
cube->height = 1.0f;
cube->depth = 1.0f;
markersep->addChild(cube);
kit->setPart(’shape’, markersep);
markerroot->addChild(kit);
return markerroot;
}
static void
event_cb(void * ud, SoEventCallback * n)
{
const SoMouseButtonEvent * mbe = (SoMouseButtonEvent *)n->getEvent();
if (mbe->getButton() == SoMouseButtonEvent::BUTTON1 &&
mbe->getState() == SoButtonEvent::DOWN) {
SoQtExaminerViewer * viewer = (SoQtExaminerViewer *)ud;
SoRayPickAction rp(viewer->getViewportRegion());
rp.setPoint(mbe->getPosition());
rp.apply(viewer->getSceneManager()->getSceneGraph());
SoPickedPoint * point = rp.getPickedPoint();
if (point == NULL) {
(void)fprintf(stderr, ’0* miss! **0);
return;
}
n->setHandled();
const SoPath * p = rp.getCurPath();
for (int i = 0; i < p->getLength(); i++) {
SoNode * n = p->getNodeFromTail(i);
if (n->isOfType(SoGroup::getClassTypeId())) {
SoGroup * g = (SoGroup *)n;
g->addChild(construct_new_marker(point->getPoint()));
break;
}
}
}
}
void
show_instructions(void)
{
(void)fprintf(stdout,
’0his example program demonstrates the use of the ShapeScale nodekit.0
’0uick instructions:0
’ * place the marker by clicking on a shape with the left mouse button0
’ * hit ESC to toggle back and forth to view mode0
’ * zoom back and forth to see how the markers stay the same size0);
}
int
main(int argc, char ** argv)
{
if (argc != 2) {
(void) fprintf(stderr,’10pecify an Inventor file as argument.0);
return -1;
}
QWidget * window = SoQt::init(argv[0]);
ShapeScale::initClass(); // init our extension nodekit
SoQtExaminerViewer * ex1 = new SoQtExaminerViewer(window);
SoInput input;
SbBool ok = input.openFile(argv[1]);
if (!ok) {
(void) fprintf(stderr, ’Unable to open file: %s0, argv[1]);
return -1;
}
SoSeparator * root = SoDB::readAll(&input);
if (root == NULL) {
(void) fprintf(stderr, ’Unable to read file: %s0, argv[1]);
return -1;
}
show_instructions();
SoSeparator * newroot = new SoSeparator;
newroot->ref();
newroot->addChild(root);
// create event callback and marker nodes
SoSeparator * sep = new SoSeparator;
newroot->addChild(sep);
SoEventCallback * ecb = new SoEventCallback;
ecb->addEventCallback(SoMouseButtonEvent::getClassTypeId(), event_cb, ex1);
sep->addChild(ecb);
ex1->setSceneGraph(newroot);
ex1->setTransparencyType(SoGLRenderAction::SORTED_OBJECT_BLEND);
ex1->setViewing(FALSE);
ex1->show();
SoQt::show(window);
SoQt::mainLoop();
delete ex1;
newroot->unref();
return 0;
}
Constructor & Destructor Documentation
SoBaseKit::SoBaseKit (void) Constructor.
This is the top-level superclass of all node kit and dragger classes.
The catalog structure of SoBaseKit is as follows:
CLASS SoBaseKit
-->"this"
--> "callbackList"
.fi
(See SoBaseKit::printDiagram() for information about the output formatting.)
Detailed information on catalog parts:
CLASS SoBaseKit
PVT "this", SoBaseKit ---
"callbackList", SoNodeKitListPart [ SoCallback, SoEventCallback ]
.fi
(See SoBaseKit::printTable() for information about the output formatting.)
As can be seen from the catalog, all node kits can have a callback node in front of all other nodes in the kit. This is handy for catching events that should go to application processing.
SoBaseKit::~SoBaseKit () [protected, virtual] Destructor.
Member Function Documentation
void SoBaseKit::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 SoNode.
Reimplemented in SoForeignFileKit, SoSTLFileKit, SoCenterballDragger,
SoDirectionalLightDragger, SoDragPointDragger, SoDragger,
SoHandleBoxDragger, SoJackDragger, SoPointLightDragger,
SoRotateCylindricalDragger, SoRotateDiscDragger,
SoRotateSphericalDragger, SoScale1Dragger, SoScale2Dragger,
SoScale2UniformDragger, SoScaleUniformDragger, SoSpotLightDragger,
SoTabBoxDragger, SoTabPlaneDragger, SoTrackballDragger,
SoTransformBoxDragger, SoTransformerDragger, SoTranslate1Dragger,
SoTranslate2Dragger, SoAppearanceKit, SoCameraKit, SoInteractionKit,
SoLightKit, SoSceneKit, SoSeparatorKit, SoShapeKit, and SoWrapperKit.
const SoNodekitCatalog * SoBaseKit::getClassNodekitCatalog (void) [static]
Returns the nodekit catalog which defines the layout of this class’
kit.
Reimplemented in SoForeignFileKit.
const SoNodekitCatalog * SoBaseKit::getNodekitCatalog (void) const
[virtual] Returns the nodekit catalog which defines the layout of this
class’ kit.
Reimplemented in SoForeignFileKit.
SoNode * SoBaseKit::getPart (const SbName & partname, SbBool makeifneeded)
[virtual] Returns a pointer to the node part with partname.
This method calls SoBaseKit::getAnyPart() with leafcheck and
publiccheck both set to TRUE.
See the documentation of SoBaseKit::getAnyPart() for information on how
to use partname and makeifneeded, and what you can expect to get
returned from this method.
SbString SoBaseKit::getPartString (const SoBase * part) Returns the full
path name to a catalog part, given the part’s current item pointer.
SoNodeKitPath * SoBaseKit::createPathToPart (const SbName & partname,
SbBool makeifneeded, const SoPath * pathtoextend = NULL) [virtual]
Calls SoBaseKit::createPathToAnyPart() with leafcheck TRUE, and
publiccheck TRUE (and other arguments as given to this function).
See SoBaseKit::createPathToAnyPart() for documentation.
SbBool SoBaseKit::setPart (const SbName & partname, SoNode * from)
[virtual] Sets the catalog part given by partname to the from node
pointer.
Reimplemented in SoInteractionKit.
SbBool SoBaseKit::set (const char * namevaluepairliststring) Sets nodekit
part field values. The input argument string is of the format:
partname {
fieldname fieldval
fieldname fieldval
[...]
}
partname {
fieldname fieldval
fieldname fieldval
[...]
}
[...]
(Whitespace layout is ignored, as always for Inventor format input
strings.)
Here’s an example, changing several values of the camera part of an
SoCameraKit instance:
kit->set(’camera { heightAngle 0.3927 nearDistance 1.1 farDistance 999.9 }’);
Reimplemented from SoFieldContainer.
SbBool SoBaseKit::set (const char * partnamestring, const char *
parameterstring) This just overloads the other SoBaseKit::set() method,
and provides a way to set a part value by using a separate input
argument for the name of the part and the name of the field (i.e.
parameter) settings.
void SoBaseKit::doAction (SoAction * action) [virtual] This function
performs the typical operation of a node for any action.
Reimplemented from SoNode.
void SoBaseKit::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 SoNode.
Reimplemented in SoDragger.
void SoBaseKit::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 SoNode.
Reimplemented in SoDragger, and SoTabPlaneDragger.
void SoBaseKit::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.
Reimplemented in SoCenterballDragger, and SoDragger.
void SoBaseKit::getMatrix (SoGetMatrixAction * action) [virtual] Action
method for SoGetMatrixAction.
Updates action by accumulating with the transformation matrix of this
node (if any).
Reimplemented from SoNode.
Reimplemented in SoCenterballDragger, and SoDragger.
void SoBaseKit::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.
Reimplemented in SoDragger.
void SoBaseKit::rayPick (SoRayPickAction * action) [virtual] Action method
for SoRayPickAction.
Checks the ray specification of the action and tests for intersection
with the data of the node.
Nodes influencing relevant state variables for how picking is done also
overrides this method.
Reimplemented from SoNode.
Reimplemented in SoDragger.
void SoBaseKit::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.
Reimplemented in SoDragger.
void SoBaseKit::write (SoWriteAction * action) [virtual] Action method for
SoWriteAction.
Writes out a node object, and any connected nodes, engines etc, if
necessary.
Reimplemented from SoNode.
Reimplemented in SoDragger.
void SoBaseKit::getPrimitiveCount (SoGetPrimitiveCountAction * action)
[virtual] Action method for the SoGetPrimitiveCountAction.
Calculates the number of triangle, line segment and point primitives
for the node and adds these to the counters of the action.
Nodes influencing how geometry nodes calculates their primitive count
also overrides this method to change the relevant state variables.
Reimplemented from SoNode.
Reimplemented in SoDragger.
SoChildList * SoBaseKit::getChildren (void) const [virtual] Returns list of
children for this node.
Reimplemented from SoNode.
void SoBaseKit::printDiagram (void) Print out the full nodekit catalog
structure. Just invokes SoBaseKit::printSubDiagram() on the catalog
root. Useful for debugging.
Example output:
CLASS SoWrapperKit
-->"this"
"callbackList"
"topSeparator"
"pickStyle"
"appearance"
"units"
"transform"
"texture2Transform"
"childList"
--> "localTransform"
--> "contents"
.fi
The arrows denote new entries in the catalog for the particular class versus it’s superclass. (Apart from the root entry, of course.)
For a more detailed catalog dump, see SoBaseKit::printTable().
void SoBaseKit::printSubDiagram (const SbName & rootname, int level) Print
out the nodekit catalog structure from rootname and downwards in the
catalog tree, with indentation starting at level.
See also:
printDiagram()
void SoBaseKit::printTable (void) Write the complete nodekit catalog in
table form.
Example output:
CLASS SoWrapperKit
PVT "this", SoWrapperKit ---
"callbackList", SoNodeKitListPart [ SoCallback, SoEventCallback ]
PVT "topSeparator", SoSeparator ---
"pickStyle", SoPickStyle ---
"appearance", SoAppearanceKit ---
"units", SoUnits ---
"transform", SoTransform ---
"texture2Transform", SoTexture2Transform ---
"childList", SoNodeKitListPart [ SoShapeKit, SoSeparatorKit ]
"localTransform", SoTransform ---
"contents", SoSeparator ---
.fi
PVT denotes that it’s a private entry in the catalog, then follows the part name and the part type. If the part is a list, the allowed node types for the list is given in square brackets, and if not there’s a triple hyphen. If the part type is abstract, the default part type will be listed last (not shown in the example output above).
void SoBaseKit::addWriteReference (SoOutput * out, SbBool isfromfield = 0)
[virtual] This method is used during the first write pass of a write
action to count the number of references to this object in the scene
graph.
Reimplemented from SoFieldContainer.
SbBool SoBaseKit::forceChildDrivenWriteRefs (SoOutput * out) Returns TRUE
if kit should write. This happens if shouldWrite() returns TRUE, or if
any of the children (recursively) should write.
SbBool SoBaseKit::isSearchingChildren (void) [static] Returns the value of
the flag indicating whether or not the kit parts are searched during
SoSearchAction traversal.
See also:
SoBaseKit::setSearchingChildren()
void SoBaseKit::setSearchingChildren (const SbBool newval) [static] Set
whether or not the kit parts should be searched during SoSearchAction
traversal. The default value is FALSE.
const SoNodekitCatalog ** SoBaseKit::getClassNodekitCatalogPtr (void)
[static, protected] Returns the pointer to the pointer of the nodekit
catalog for this class.
Reimplemented in SoForeignFileKit.
SoNode * SoBaseKit::addToCopyDict (void) const [protected, virtual] Add a
copy of this node and (recursively) all children to the copy dictionary
of SoFieldContainer if this has not already been done.
Used internally during copy operations.
Reimplemented from SoNode.
void SoBaseKit::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.
Reimplemented in SoRotateCylindricalDragger, SoRotateSphericalDragger,
and SoInteractionKit.
SoGroup * SoBaseKit::getContainerNode (const SbName & listname, SbBool
makeifneeded = 1) [protected] Returns a pointer to the group node above
an SoNodeKitListPart in the catalog given by listname.
If the list part (and its container) was not yet constructed, they will
be so if makeifneeded is TRUE (otherwise, NULL will be returned).
SoNode * SoBaseKit::getAnyPart (const SbName & partname, SbBool
makeifneeded, SbBool leafcheck = 0, SbBool publiccheck = 0) [protected,
virtual] Returns catalog part of the given partname.
If the partname part is not in the nodekit’s catalog, return NULL.
If the part is specified in the catalog, but has not yet been made, the
function will either construct the part (if makeifneeded is TRUE) or
just return NULL (if makeifneeded is FALSE).
If leafcheck is TRUE, a pointer to the part will only be returned if
it’s a leaf in the catalog (otherwise NULL is returned).
If publiccheck is TRUE, a pointer to the part will only be returned if
it’s a public catalog part (otherwise NULL is returned).
The partname input argument should be given as a path of catalog part
names down to the wanted leaf part. The syntax for specifiying partname
’paths’ is as follows (given in Backus-Naur Form (BNF)):
BNF:
partname = singlename | compoundname
compoundname = singlename | compoundname.singlename
singlename = singlepartname | singlelistelementname
singlelistelementname = singlelistname[idx]
singlepartname is name of a part ("ordinary", nodekit or list)
singlelistname is name of a part which is a list
idx is an integer value
.fi
SoNodeKitPath * SoBaseKit::createPathToAnyPart (const SbName & partname,
SbBool makeifneeded, SbBool leafcheck = 0, SbBool publiccheck = 0,
const SoPath * pathtoextend = NULL) [protected, virtual] Return path
with nested SoNodeKit instances down in the catalog hierarchy given by
partname.
If the trailing part has not been made and makeifneeded is TRUE, make
an instance of the part type and insert into the catalog, as done in
setAnyPart().
If leafcheck is TRUE, ignore non-leaf catalog node entries. If
publiccheck is TRUE, ignore private catalog entries.
pathtoextend is a path through the nodekit instance catalog hierarchy,
where we should pick up and continue to create the path from where
pathtoextend terminates. If pathtoextend is NULL, we simply start at
the ’this’ toplevel node.
Returns NULL on failure, for any of the possible reasons described
above (part ends in non-leaf or private catalog entry, part is not
syntactically valid or refers to non-existing catalog entries).
SbBool SoBaseKit::setAnyPart (const SbName & partname, SoNode * from,
SbBool anypart = 1) [protected, virtual] This API member is considered
internal to the library, as it is not likely to be of interest to the
application programmer.
void SoBaseKit::createNodekitPartsList (void) [protected] Not part of the
Coin API.
It is supposed to create the SoNodekitParts class instance. Since this
class can only be used by SoBaseKit (all members are private, with
SoBaseKit as friend), we decided to not support this class, and solve
the problem of recording which parts are created in an alternative way.
void SoBaseKit::createFieldList (void) [protected] Replaces the
createNodekitPartsList() method.
Sets up the list of SoSFNode fields with node pointers to the instances
in our catalog.
void SoBaseKit::createDefaultParts (void) [protected, virtual] This API
member is considered internal to the library, as it is not likely to be
of interest to the application programmer.
const SoNodekitParts * SoBaseKit::getNodekitPartsList (void) const
[protected] In Open Inventor, this method returns a pointer to a
private class. It will always return NULL in Coin.
See also:
createNodekitPartsList()
const SbList< SoSFNode * > & SoBaseKit::getCatalogInstances (void) const
[protected] This API member is considered internal to the library, as
it is not likely to be of interest to the application programmer.
void SoBaseKit::catalogError (void) [protected] Obsoleted from the API in
Coin.
SbBool SoBaseKit::setUpConnections (SbBool onoff, SbBool doitalways = 0)
[protected, virtual] Sets up all internal connections for instances of
this class.
(This method will usually not be of interest to the application
programmer, unless you want to extend the library with new custom
nodekits or dragger classes. If so, see the SoBaseKit class
documentation.)
Reimplemented in SoCenterballDragger, SoDirectionalLightDragger,
SoDragPointDragger, SoHandleBoxDragger, SoJackDragger,
SoPointLightDragger, SoRotateCylindricalDragger, SoRotateDiscDragger,
SoRotateSphericalDragger, SoScale1Dragger, SoScale2Dragger,
SoScale2UniformDragger, SoScaleUniformDragger, SoSpotLightDragger,
SoTabBoxDragger, SoTabPlaneDragger, SoTrackballDragger,
SoTransformBoxDragger, SoTransformerDragger, SoTranslate1Dragger,
SoTranslate2Dragger, SoInteractionKit, and SoSeparatorKit.
SbBool SoBaseKit::readInstance (SoInput * in, unsigned short flags)
[protected, virtual] This method is mainly intended for internal use
during file import operations.
It reads a definition of an instance from the input stream in. The
input stream state points to the start of a serialized / persistant
representation of an instance of this class type.
TRUE or FALSE is returned, depending on if the instantiation and
configuration of the new object of this class type went ok or not. The
import process should be robust and handle corrupted input streams by
returning FALSE.
flags is used internally during binary import when reading user
extension nodes, group nodes or engines.
Reimplemented from SoNode.
Reimplemented in SoInteractionKit.
void SoBaseKit::setDefaultOnNonWritingFields (void) [protected, virtual]
(Be aware that this method is unlikely to be of interest to the
application programmer who does not want to extend the library with new
custom nodekits or draggers. If you indeed are writing extensions, see
the information in the SoBaseKit class documentation.)
This is a virtual method, and the code in it should call
SoField::setDefault() with argument TRUE on part fields that should not
be written upon scenegraph export operations.
This is typically done when:
1. field value is NULL and part is NULL by default
2. it is a leaf SoGroup or SoSeparator node with no children
3. it is a leaf listpart with no children and an SoGroup or
SoSeparator container
4. it is a non-leaf part and it’s of SoGroup type and all fields are
at their default values
Subclasses should usually override this to do additional settings for
new member fields. From the subclass, do remember to call ’upwards’ to
your superclass’ setDefaultOnNonWritingFields() method.
Reimplemented in SoCenterballDragger, SoDirectionalLightDragger,
SoDragPointDragger, SoDragger, SoHandleBoxDragger, SoJackDragger,
SoPointLightDragger, SoSpotLightDragger, SoTabBoxDragger,
SoTabPlaneDragger, SoTrackballDragger, SoTransformBoxDragger,
SoTransformerDragger, SoInteractionKit, SoSeparatorKit, and SoShapeKit.
void SoBaseKit::countMyFields (SoOutput * out) [protected] Reference count
the write connections to nodes in the catalog.
SbBool SoBaseKit::setPart (const int partnum, SoNode * node) [protected,
virtual] Sets parts, updates nodekit scene graph, and makes sure graph
is valid with respect to right siblings and parent. This method is
virtual to enable subclasses to detect when a part changes value.
This method is not part of the original SGI Open Inventor API, but is
an extension specific to Coin.
Reimplemented in SoInteractionKit.
Member Data Documentation
SoChildList * SoBaseKit::children [protected] This API member is considered
internal to the library, as it is not likely to be of interest to the
application programmer.
SbBool SoBaseKit::connectionsSetUp [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.