SoBaseKit(3)

📦
version 4.0.10 · 4 versions
, in fedora 43, fedora 44

hey bestie! 💖 welcome to the SoBaseKit(3) page from the Coin manual. this is part 1 of 5, so buckle up. 🎀

✨ NAME ✨

SoBaseKit — the top level superclass for nodekits. it's giving main character energy for all the nodekit classes. 👑

✨ SYNOPSIS ✨

#include <Inventor/nodekits/SoBaseKit.h>

Inherits SoNode.

Inherited by SoAppearanceKit, SoCameraKit, SoForeignFileKit, SoInteractionKit, SoLightKit, SoNodeVisualize, SoProfilerOverlayKit, SoProfilerVisualizeKit, SoSceneKit, SoScrollingGraphKit, and SoSeparatorKit. slay. 💅

Public Member Functions

  • virtual SoType getTypeId (void) const — get the type id, bestie. no cap.
  • SoBaseKit (void) — constructor, periodt.
  • virtual const SoNodekitCatalog * getNodekitCatalog (void) const — grab the nodekit catalog.
  • virtual SoNode * getPart (const SbName &partname, SbBool makeifneeded) — get a part by name.
  • SbString getPartString (const SoBase *part) — get the part as a string.
  • virtual SoNodeKitPath * createPathToPart (const SbName &partname, SbBool makeifneeded, const SoPath *pathtoextend=NULL) — make a path to a part.
  • virtual SbBool setPart (const SbName &partname, SoNode *from) — set a part.
  • SbBool set (const char *namevaluepairliststring) — set from a name-value pair list string.
  • SbBool set (const char *partnamestring, const char *parameterstring) — set with part name and parameter strings.
  • virtual void doAction (SoAction *action) — do the action.
  • virtual void callback (SoCallbackAction *action) — callback action.
  • virtual void GLRender (SoGLRenderAction *action) — GL render action.
  • virtual void getBoundingBox (SoGetBoundingBoxAction *action) — get bounding box action.
  • virtual void getMatrix (SoGetMatrixAction *action) — get matrix action.
  • virtual void handleEvent (SoHandleEventAction *action) — handle event action.
  • virtual void rayPick (SoRayPickAction *action) — ray pick action.
  • virtual void search (SoSearchAction *action) — search action.
  • virtual void write (SoWriteAction *action) — write action.
  • virtual void getPrimitiveCount (SoGetPrimitiveCountAction *action) — get primitive count action.
  • virtual SoChildList * getChildren (void) const — get the children list.
  • void printDiagram (void) — print a diagram.
  • void printSubDiagram (const SbName &rootname, int level) — print a sub-diagram.
  • void printTable (void) — print a table.
  • virtual void addWriteReference (SoOutput *out, SbBool isfromfield=FALSE) — add a write reference.
  • SbBool forceChildDrivenWriteRefs (SoOutput *out) — force child-driven write refs.

Public Member Functions inherited from SoNode

  • void setOverride (const SbBool state) — set override state.
  • SbBool isOverride (void) const — check if override.
  • void setNodeType (const NodeType type) — set node type.
  • NodeType getNodeType (void) const — get node type.
  • virtual SoNode * copy (SbBool copyconnections=FALSE) const — copy the node.
  • virtual SbBool affectsState (void) const — does it affect state?
  • virtual void GLRenderBelowPath (SoGLRenderAction *action) — GL render below path.
  • virtual void GLRenderInPath (SoGLRenderAction *action) — GL render in path.
  • virtual void GLRenderOffPath (SoGLRenderAction *action) — GL render off path.
  • virtual void pick (SoPickAction *action) — pick action.
  • virtual void audioRender (SoAudioRenderAction *action) — audio render action.
  • virtual void grabEventsSetup (void) — setup for grabbing events.
  • virtual void grabEventsCleanup (void) — cleanup after grabbing events.
  • virtual void startNotify (void) — start notification.
  • virtual void notify (SoNotList *l) — notify.
  • SbUniqueId getNodeId (void) const — get node ID.
  • virtual void writeInstance (SoOutput *out) — write instance.
  • virtual SoFieldContainer * copyThroughConnection (void) const — copy through connection.

Public Member Functions inherited from SoFieldContainer

  • void setToDefaults (void) — set to defaults.
  • SbBool hasDefaultValues (void) const — check if it has default values.
  • SbBool fieldsAreEqual (const SoFieldContainer *container) const — check if fields are equal.
  • void copyFieldValues (const SoFieldContainer *container, SbBool copyconnections=FALSE) — copy field values.
  • SbBool set (const char *const fielddata) — set from field data.
  • void get (SbString &fielddata) — get field data.
  • virtual int getFields (SoFieldList &l) const — get fields.
  • virtual int getAllFields (SoFieldList &l) const — get all fields.
  • virtual SoField * getField (const SbName &name) const — get a field by name.
  • virtual SoField * getEventIn (const SbName &name) const — get event in.
  • virtual SoField * getEventOut (const SbName &name) const — get event out.
  • SbBool getFieldName (const SoField *const field, SbName &name) const — get field name.
  • SbBool enableNotify (const SbBool flag) — enable notify.
  • SbBool isNotifyEnabled (void) const — check if notify is enabled.
  • SbBool set (const char *fielddata, SoInput *input) — set with input.
  • void get (SbString &fielddata, SoOutput *out) — get with output.
  • virtual SbBool validateNewFieldValue (SoField *field, void *newval) — validate new field value.
  • SbBool getIsBuiltIn (void) const — check if built-in.
  • virtual void getFieldsMemorySize (size_t &managed, size_t &unmanaged) const — get fields memory size.
  • void setUserData (void *userdata) const — set user data.
  • void * getUserData (void) const — get user data.

Public Member Functions inherited from SoBase

  • void ref (void) const — increase ref count.
  • void unref (void) const — decrease ref count.
  • void unrefNoDelete (void) const — decrease ref count without delete.
  • int32_t getRefCount (void) const — get ref count.
  • void touch (void) — touch it.
  • SbBool isOfType (SoType type) const — returns TRUE if the type of this object is either of the same type or inherited from type. iykyk.
  • virtual SbName getName (void) const — get name.
  • virtual void setName (const SbName &newname) — set name.
  • void addAuditor (void *const auditor, const SoNotRec::Type type) — add auditor.
  • void removeAuditor (void *const auditor, const SoNotRec::Type type) — remove auditor.
  • const SoAuditorList & getAuditors (void) const — get auditors.
  • SbBool shouldWrite (void) — should write?
  • void assertAlive (void) const — assert alive.

Static Public Member Functions

  • static SoType getClassTypeId (void) — get class type ID.
  • static void initClass (void) — initialize the class.
  • static const SoNodekitCatalog * getClassNodekitCatalog (void) — get class nodekit catalog.
  • static SbBool isSearchingChildren (void) — is searching children?
  • static void setSearchingChildren (const SbBool newval) — set searching children.

Static Public Member Functions inherited from SoNode

  • static uint32_t getCompatibilityTypes (const SoType &nodetype) — get compatibility types.
  • static SoType getClassTypeId (void) — get class type ID.
  • static SoNode * getByName (const SbName &name) — get node by name.
  • static int getByName (const SbName &name, SoNodeList &l) — get node by name into list.
  • static void initClass (void) — sets up initialization for data common to all instances of this class, like submitting necessary info to the Coin type system. 💫
  • static void initClasses (void) — initialize classes.
  • static SbUniqueId getNextNodeId (void) — get next node ID.
  • static int getActionMethodIndex (const SoType type) — get action method index.
  • static void getBoundingBoxS (SoAction *action, SoNode *node) — static bounding box.
  • static void GLRenderS (SoAction *action, SoNode *node) — static GL render.
  • static void callbackS (SoAction *action, SoNode *node) — static callback.
  • static void getMatrixS (SoAction *action, SoNode *node) — static get matrix.
  • static void handleEventS (SoAction *action, SoNode *node) — static handle event.
  • static void pickS (SoAction *action, SoNode *node) — static pick.
  • static void rayPickS (SoAction *action, SoNode *node) — static ray pick.
  • static void searchS (SoAction *action, SoNode *node) — static search.
  • static void writeS (SoAction *action, SoNode *node) — static write.
  • static void audioRenderS (SoAction *action, SoNode *node) — static audio render.
  • static void getPrimitiveCountS (SoAction *action, SoNode *node) — static get primitive count.

Static Public Member Functions inherited from SoFieldContainer

  • static void initClass (void) — sets up initialization for data common to all instances of this class, like submitting necessary info to the Coin type system. 💫
  • static SoType getClassTypeId (void) — this static method returns the SoType object associated with objects of this class. periodt.
  • static void cleanupClass (void) — cleanup class.
  • static void initCopyDict (void) — init copy dictionary.
  • static void addCopy (const SoFieldContainer *orig, const SoFieldContainer *copy) — add copy.
  • static SoFieldContainer * checkCopy (const SoFieldContainer *orig) — check copy.
  • static SoFieldContainer * findCopy (const SoFieldContainer *orig, const SbBool copyconnections) — find copy.
  • static void copyDone (void) — copy done.

Static Public Member Functions inherited from SoBase

  • static void initClass (void) — sets up initialization for data common to all instances of this class, like submitting necessary info to the Coin type system. 💫
  • static SoType getClassTypeId (void) — this static method returns the SoType object associated with objects of this class. periodt.
  • static void addName (SoBase *const base, const char *const name) — add name.
  • static void removeName (SoBase *const base, const char *const name) — remove name.
  • static void incrementCurrentWriteCounter (void) — increment current write counter.
  • static void decrementCurrentWriteCounter (void) — decrement current write counter.
  • static SoBase * getNamedBase (const SbName &name, SoType type) — get named base.
  • static int getNamedBases (const SbName &name, SoBaseList &baselist, SoType type) — get named bases.
  • static SbBool read (SoInput *input, SoBase *&base, SoType expectedtype) — read.
  • static void setInstancePrefix (const SbString &c) — set instance prefix.
  • static void setTraceRefs (SbBool trace) — set trace refs.
  • static SbBool getTraceRefs (void) — get trace refs.
  • static SbBool connectRoute (SoInput *input, const SbName &fromnodename, const SbName &fromfieldname, const SbName &tonodename, const SbName &tofieldname) — connect route.
  • static SbBool readRoute (SoInput *input) — read route.

Protected Member Functions

  • virtual const SoFieldData * getFieldData (void) const — get field data.
  • virtual ~SoBaseKit () — destructor.
  • virtual SoNode * addToCopyDict (void) const — add to copy dictionary.
  • virtual void copyContents (const SoFieldContainer *fromfc, SbBool copyconnections) — copy contents.
  • SoGroup * getContainerNode (const SbName &listname, SbBool makeifneeded=TRUE) — get container node.
  • virtual SoNode * getAnyPart (const SbName &partname, SbBool makeifneeded, SbBool leafcheck=FALSE, SbBool publiccheck=FALSE) — get any part.
  • virtual SoNodeKitPath * createPathToAnyPart (const SbName &partname, SbBool makeifneeded, SbBool leafcheck=FALSE, SbBool publiccheck=FALSE, const SoPath *pathtoextend=NULL) — create path to any part.
  • virtual SbBool setAnyPart (const SbName &partname, SoNode *from, SbBool anypart=TRUE) — set any part.
  • void createNodekitPartsList (void) — create nodekit parts list.
  • void createFieldList (void) — create field list.
  • virtual void createDefaultParts (void) — create default parts.
  • const SoNodekitParts * getNodekitPartsList (void) const — get nodekit parts list.
  • const SbList< SoSFNode * > & getCatalogInstances (void) const — get catalog instances.
  • void catalogError (void) — catalog error.
  • virtual SbBool setUpConnections (SbBool onoff, SbBool doitalways=FALSE) — set up connections.
  • virtual SbBool readInstance (SoInput *in, unsigned short flags) — read instance.
  • virtual void setDefaultOnNonWritingFields (void) — set default on non-writing fields.
  • void countMyFields (SoOutput *out) — count my fields.
  • virtual SbBool setPart (const int partNum, SoNode *node) — set part by number.

Protected Member Functions inherited from SoNode

  • SoNode (void) — constructor.
  • virtual ~SoNode () — destructor.

Protected Member Functions inherited from SoFieldContainer

  • SoFieldContainer (void) — constructor.
  • virtual ~SoFieldContainer () — destructor.

Protected Member Functions inherited from SoBase

  • SoBase (void) — constructor.
  • virtual ~SoBase () — destructor.
  • virtual void destroy (void) — destroy.
  • SbBool hasMultipleWriteRefs (void) const — has multiple write refs?
  • SbBool writeHeader (SoOutput *out, SbBool isgroup, SbBool isengine) const — write header.
  • void writeFooter (SoOutput *out) const — write footer.
  • virtual const char * getFileFormatName (void) const — get file format name.
  • virtual SoNotRec createNotRec (void) — create notification record.

Static Protected Member Functions

  • static const SoFieldData ** getFieldDataPtr (void) — get field data pointer.
  • static const SoNodekitCatalog ** getClassNodekitCatalogPtr (void) — get class nodekit catalog pointer.

Static Protected Member Functions inherited from SoNode

  • static const SoFieldData ** getFieldDataPtr (void) — get field data pointer.
  • static void setNextActionMethodIndex (int index) — set next action method index.
  • static int getNextActionMethodIndex (void) — get next action method index.
  • static void incNextActionMethodIndex (void) — increment next action method index.
  • static void setCompatibilityTypes (const SoType &nodetype, const uint32_t bitmask) — set compatibility types.

Static Protected Member Functions inherited from SoBase

  • static uint32_t getCurrentWriteCounter (void) — get current write counter.
  • static void staticDataLock (void) — lock static data.
  • static void staticDataUnlock (void) — unlock static data.

Protected Attributes

  • SoSFNode callbackList — callback list.
  • SoChildList * children — children.
  • SbBool connectionsSetUp — connections set up.

Protected Attributes inherited from SoNode

  • SbUniqueId uniqueId — unique ID.

Protected Attributes inherited from SoFieldContainer

  • SbBool isBuiltIn — is built-in.

Additional Inherited Members

Okay bestie, before we dive into the main character energy of SoBaseKit, here's the inherited lore you're also getting for free. 👑

  • Public Types inherited from SoNode
enum NodeType { INVENTOR = 0x0000, VRML1 = 0x0001, VRML2 = 0x0002,
    INVENTOR_1 = 0x0004, INVENTOR_2_0 = 0x0008, INVENTOR_2_1 = 0x0010,
    INVENTOR_2_5 = 0x0020, INVENTOR_2_6 = 0x0040, COIN_1_0 = 0x0080,
    COIN_2_0 = 0x0100, EXTENSION = 0x0200, COIN_2_2 = 0x0400, COIN_2_3 =
    0x0800, COIN_2_4 = 0x1000, INVENTOR_5_0 = 0x2000, COIN_2_5 = 0x4000,
    COIN_3_0 = 0x8000, INVENTOR_6_0 = 0x10000, COIN_4_0 = 0x20000 }
  • Protected Types inherited from SoBase
enum BaseFlags { IS_ENGINE = 0x01, IS_GROUP = 0x02 }
  • Static Protected Attributes inherited from SoNode
    • static SbUniqueId nextUniqueId = 1
    • static int nextActionMethodIndex = 0

Detailed Description

So like, SoBaseKit is the top level superclass for nodekits. 💅 It's literally the blueprint for every nodekit that comes after it. Periodt.

Node kits are collections of nodes and other node kits — and real talk, from here on, node kits that are part of some other node kit? We're just gonna call them nodes or parts (peep catalogs and parts for the full tea ☕). They're organized in a way that's convenient for their use. A node kit inherits SoNode, so you can insert it into a scene graph like any other node. Slay. ✨

The organizing of the nodes and node kits of some node kit? That's all done through catalogs. A node kit's catalog describes the nodes that can be members of the node kit. These members are called parts. So basically, a node kit has a catalog describing the parts that it offers to the user. It's giving menu. 📋

Every part in the catalog has some values saying stuff about the part itself and about the role it plays in the scene graph. 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 scene graph.
  • 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 Container 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 publicly available, otherwise it holds FALSE.

Node kits use lazy instantiation when it creates its parts. That means the nodes making up the parts of the nodekit only get created when they're needed. No cap. 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're 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 are created automatically. It's giving auto-fill. 🪄

The advantages of using node kits to represent a scene graph are many. Let's get into it:

  • 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. Swap era. 🔄
  • 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. Nested kits? We love to see it. 🪆
  • Node kits are an efficient way of creating scene graphs. 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. Efficiency queen. 👑
  • The application code becomes smaller and easier to read, as the node kits provides simple routines for creating and setting parts. Clean code vibes. 🧼
  • New node kits can be created through subclassing to obtain simple setups of scene graphs best fitted to the application. Subclass and thrive. 🌱

The usage of a node kit is straightforward. Below follows a code example showing some simple SoShapeKit usage. Get ready to eat. 🍽️

#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 its 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 have 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: (the original page had a picture here, bestie — just imagine a cute lil cube looking iconic) 📸

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");

..while doing it without shape kits amounts to this:

SoSeparator * root = new SoSeparator;
SoMaterial * material = new SoMaterial;
material->diffuseColor.setValue(1,0,0);
root->addChild(material);
root->addChild(new SoCube);

..so even for this minuscule mock-up example, you save on code verbosity and complexity. Less typing, more slaying. 💅

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, as well 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 source code of the built-in classes in Coin should also prove 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 subgraph. Main character marker energy. 🎯

The header file:

// Copyright (C) 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) 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, \x0, FALSE);
  SO_KIT_ADD_CATALOG_ABSTRACT_ENTRY(shape, SoNode, SoCube, TRUE, topSeparator, \x0, TRUE);
  SO_KIT_ADD_CATALOG_ENTRY(scale, SoScale, FALSE, topSeparator, shape, FALSE);

  SO_KIT_INIT_INSTANCE();
}

// Destructor.
ShapeScale::~ShapeScale()
{
}

okay so here's the code that makes that custom ShapeScale nodekit actually work, bestie:

// 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 here's a whole complete example showing how you can use this node kit, bestie:

// Copyright (C) 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 <cassert>
#include <cstdlib>
#include <ctime>

#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, "\n** miss! **\n\n");
      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,
    "\nThis example program demonstrates the use of the ShapeScale nodekit.\n"
    "\nQuick instructions:\n\n"
    "  * place the marker by clicking on a shape with the left mouse button\n"
    "  * hit ESC to toggle back and forth to view mode\n"
    "  * zoom back and forth to see how the markers stay the same size\n\n");
}

int
main(int argc, char ** argv)
{
  if (argc != 2) {
    (void) fprintf(stderr,"\nSpecify an Inventor file as argument.\n");
    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: %s\n", argv[1]);
    return -1;
  }

  SoSeparator * root = SoDB::readAll(&input);

  if (root == NULL) {
    (void) fprintf(stderr, "Unable to read file: %s\n", 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 )

okay so this is the constructor, bestie. SoBaseKit is literally the top-level superclass of every single node kit and dragger class. Its catalog structure is giving:

CLASS SoBaseKit
-->"this"
-->   "callbackList"

(peep SoBaseKit::printDiagram() if you wanna know about the output formatting, iykyk.)

Now the detailed tea on the catalog parts:

CLASS SoBaseKit
PVT   "this",  SoBaseKit  ---
      "callbackList",  SoNodeKitListPart [ SoCallback, SoEventCallback ]

(and SoBaseKit::printTable() has the info about the output formatting.)

So as you can see from the catalog, all node kits can have a callback node right in front of all the other nodes in the kit. That's lowkey handy for catching events that should go to application processing. periodt. 💅

SoBaseKit::~SoBaseKit () [protected], [virtual]

Destructor. That's it. It literally destroys. 💀

💖 Member Function Documentation 💖

SoType SoBaseKit::getClassTypeId (void ) [static]

This static method returns the SoType object that's associated with objects of this class. slay. ✨

SoType SoBaseKit::getTypeId (void ) const [virtual]

Returns the type identification of an object derived from a class that inherits SoBase. This is used for runtime type checking and "downward" casting, no cap.

Implements SoBase.

Reimplemented in SoAppearanceKit, SoCameraKit, SoCenterballDragger, SoDirectionalLightDragger, SoDragger, SoDragPointDragger, SoForeignFileKit, SoHandleBoxDragger, SoInteractionKit, SoJackDragger, SoLightKit, SoNodeVisualize, SoPointLightDragger, SoProfilerOverlayKit, SoProfilerTopKit, SoProfilerVisualizeKit, SoRotateCylindricalDragger, SoRotateDiscDragger, SoRotateSphericalDragger, SoScale1Dragger, SoScale2Dragger, SoScale2UniformDragger, SoScaleUniformDragger, SoSceneKit, SoScrollingGraphKit, SoSeparatorKit, SoShapeKit, SoSpotLightDragger, SoSTLFileKit, SoTabBoxDragger, SoTabPlaneDragger, SoTrackballDragger, SoTransformBoxDragger, SoTransformerDragger, SoTranslate1Dragger, SoTranslate2Dragger, and SoWrapperKit.

const SoFieldData ** SoBaseKit::getFieldDataPtr (void ) [static], [protected]

ngl this API member is considered internal to the library, so it's not likely to be of interest to the application programmer.

Returns the SoFieldData class which holds information about fields in this node. iykyk. 🫶

const SoFieldData * SoBaseKit::getFieldData (void ) const [protected], [virtual]

Returns a pointer to the class-wide field data storage object for this instance. If no fields are present, returns NULL.

Reimplemented from SoFieldContainer.

Reimplemented in SoAppearanceKit, SoCameraKit, SoCenterballDragger, SoDirectionalLightDragger, SoDragger, SoDragPointDragger, SoForeignFileKit, SoHandleBoxDragger, SoInteractionKit, SoJackDragger, SoLightKit, SoNodeVisualize, SoPointLightDragger, SoProfilerOverlayKit, SoProfilerTopKit, SoProfilerVisualizeKit, SoRotateCylindricalDragger, SoRotateDiscDragger, SoRotateSphericalDragger, SoScale1Dragger, SoScale2Dragger, SoScale2UniformDragger, SoScaleUniformDragger, SoSceneKit, SoScrollingGraphKit, SoSeparatorKit, SoShapeKit, SoSpotLightDragger, SoSTLFileKit, SoTabBoxDragger, SoTabPlaneDragger, SoTrackballDragger, SoTransformBoxDragger, SoTransformerDragger, SoTranslate1Dragger, SoTranslate2Dragger, and SoWrapperKit.

void SoBaseKit::initClass (void ) [static]

(no description in the original, bestie — just the signature. iconic.) 💅

const SoNodekitCatalog * SoBaseKit::getClassNodekitCatalog (void ) [static]

Returns the nodekit catalog which defines the layout of this class' kit. slay. 🌸

const SoNodekitCatalog * SoBaseKit::getNodekitCatalog (void ) const [virtual]

Returns the nodekit catalog which defines the layout of this class' kit.

Reimplemented in SoAppearanceKit, SoCameraKit, SoCenterballDragger, SoDirectionalLightDragger, SoDragger, SoDragPointDragger, SoForeignFileKit, SoHandleBoxDragger, SoInteractionKit, SoJackDragger, SoLightKit, SoNodeVisualize, SoPointLightDragger, SoProfilerOverlayKit, SoProfilerTopKit, SoProfilerVisualizeKit, SoRotateCylindricalDragger, SoRotateDiscDragger, SoRotateSphericalDragger, SoScale1Dragger, SoScale2Dragger, SoScale2UniformDragger, SoScaleUniformDragger, SoSceneKit, SoScrollingGraphKit, SoSeparatorKit, SoShapeKit, SoSpotLightDragger, SoSTLFileKit, SoTabBoxDragger, SoTabPlaneDragger, SoTrackballDragger, SoTransformBoxDragger, SoTransformerDragger, SoTranslate1Dragger, SoTranslate2Dragger, and SoWrapperKit.

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. periodt. 👑

See the documentation of SoBaseKit::getAnyPart() for the tea on how to use partname and makeifneeded, and what you can expect to get back from this method. 💖

SbString SoBaseKit::getPartString (const SoBase * part)

Gives you the full path name to a catalog part, based on the part's current item pointer. Slay. ✨

SoNodeKitPath * SoBaseKit::createPathToPart (const SbName & partname, SbBool makeifneeded, const SoPath * pathtoextend = NULL) [virtual]

Calls SoBaseKit::createPathToAnyPart() with leafcheck set to TRUE and publiccheck set to TRUE (plus all the other args you gave to this function). No cap.

For the full scoop, check out SoBaseKit::createPathToAnyPart(). 📚

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 string you pass in looks like this:

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 that changes several values of the camera part of an SoCameraKit instance:

kit->set("camera { heightAngle 0.3927  nearDistance 1.1  farDistance 999.9 }");

SbBool SoBaseKit::set (const char * partnamestring, const char * parameterstring)

This just overloads the other SoBaseKit::set() method, and gives you 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 want to throw geometry primitives at OpenGL override 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 calculate their bounding box also override 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 override this method.

Reimplemented from SoNode.

Reimplemented in SoDragger, and SoNodeVisualize.

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 override 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 calculate their primitive count also override 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"

The arrows denote new entries in the catalog for the particular class versus its 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  ---

PVT denotes that it is 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 = FALSE) [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. 🎯

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 scene graph references if copyconnections is FALSE. 🧬

This is the method that should be overridden by extension node / engine / dragger / whatever subclasses which need 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 its 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.)
  SoNode::copyContents(from, copyconnections);

  // [..then copy internal data..]
}

Reimplemented from SoNode.

Reimplemented in SoInteractionKit, SoRotateCylindricalDragger, and SoRotateSphericalDragger.

SoGroup * SoBaseKit::getContainerNode (const SbName & listname, SbBool makeifneeded = TRUE) [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 = FALSE, SbBool publiccheck = FALSE) [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). 🛠️

okay so if leafcheck is TRUE, a pointer to the part will only be returned if it is a leaf in the catalog (otherwise NULL is returned). like, it's gotta be a leaf leaf, no in-betweens, bestie 💅

if publiccheck is TRUE, a pointer to the part will only be returned if it is a public catalog part (otherwise NULL is returned). so if it's private, you get nothing — ghosted fr fr 😭

the partname input argument should be given as a "path" of catalog part names down to the wanted leaf part. the syntax for specifying partname "paths" is as follows (given in Backus-Naur Form (BNF)):

partname = singlename | compoundname
compoundname = singlename | compoundname.singlename
singlename = singlepartname | singlelistelementname
singlelistelementname = singlelistname[idx]

and here's the tea on those little pieces:

  • 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

SoNodeKitPath * SoBaseKit::createPathToAnyPart (const SbName & partname, SbBool makeifneeded, SbBool leafcheck = FALSE, SbBool publiccheck = FALSE, 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" top level 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 = TRUE) [protected], [virtual]

this API member is considered internal to the library, as it is not likely to be of interest to the application programmer. like, it's giving "don't worry about it, bestie" energy 🙈

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. rip bozo 💀

SbBool SoBaseKit::setUpConnections (SbBool onoff, SbBool doitalways = FALSE) [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, SoInteractionKit, SoJackDragger, SoPointLightDragger, SoRotateCylindricalDragger, SoRotateDiscDragger, SoRotateSphericalDragger, SoScale1Dragger, SoScale2Dragger, SoScale2UniformDragger, SoScaleUniformDragger, SoSeparatorKit, SoSpotLightDragger, SoTabBoxDragger, SoTabPlaneDragger, SoTrackballDragger, SoTransformBoxDragger, SoTransformerDragger, SoTranslate1Dragger, and SoTranslate2Dragger.

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 / persistent 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 scene graph 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 is 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, SoDragger, SoDragPointDragger, SoHandleBoxDragger, SoInteractionKit, SoJackDragger, SoPointLightDragger, SoSeparatorKit, SoShapeKit, SoSpotLightDragger, SoTabBoxDragger, SoTabPlaneDragger, SoTrackballDragger, SoTransformBoxDragger, and SoTransformerDragger.

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.

and that's the whole entire vibe, bestie — this page is from Coin version 4.0.10, dated Thu Jun 25 2026 00:00:00. slay, periodt 💅✨🦋

📦 where this page comes from