SoToVRML2Action(3)

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

💖 SoToVRML2Action 💖 (Coin)

okay bestie, grab a snack 🍓 — this is the SoToVRML2Action(3) manpage from the Coin library, and it's a two-parter, so this is part one. stay with me, we got this 🫶

🌸 NAME 🌸

SoToVRML2Action — the class that builds a whole new scene graph, using only VRML97/VRML2 nodes. it's literally giving "glow-up but for your scene graph" 💅

✨ SYNOPSIS ✨

#include <Inventor/actions/SoToVRML2Action.h>

Inherits SoToVRMLAction.

🫶 Public Member Functions

  • virtual SoType getTypeId (void) const
  • SoToVRML2Action (void)
  • virtual ~SoToVRML2Action (void)
  • virtual void apply (SoNode *node)
  • virtual void apply (SoPath *path)
  • virtual void apply (const SoPathList &pathlist, SbBool obeysrules=FALSE)
  • class SoVRMLGroup * getVRML2SceneGraph (void) const
  • void reuseAppearanceNodes (SbBool appearance)
  • SbBool doReuseAppearanceNodes (void) const
  • void reusePropertyNodes (SbBool property)
  • SbBool doReusePropertyNodes (void) const
  • void reuseGeometryNodes (SbBool geometry)
  • SbBool doReuseGeometryNodes (void) const

🌈 Public Member Functions inherited from SoToVRMLAction

  • SoToVRMLAction (void)
  • virtual ~SoToVRMLAction (void)
  • SoNode * getVRMLSceneGraph (void) const
  • void expandSoFile (SbBool flag)
  • SbBool areSoFileExpanded (void) const
  • void setUrlName (const SbString name)
  • SbString getUrlName (void) const
  • void writeTexCoords (SbBool flag)
  • SbBool areTexCoordWritten (void) const
  • void expandTexture2Node (SbBool flag)
  • SbBool areTexture2NodeExpanded (void) const
  • void keepUnknownNodes (SbBool flag)
  • SbBool areUnknownNodeKept (void) const
  • void convertInlineNodes (SbBool flag)
  • SbBool doConvertInlineNodes (void) const
  • void conditionalConversion (SbBool flag)
  • SbBool doConditionalConversion (void) const
  • void setVerbosity (SbBool flag)
  • SbBool isVerbose (void) const

💜 Public Member Functions inherited from SoAction

  • virtual ~SoAction (void)
  • virtual SbBool isOfType (SoType type) const
  • void apply (SoAction *beingApplied)
  • virtual void invalidateState (void)
  • AppliedCode getWhatAppliedTo (void) const
  • SoNode * getNodeAppliedTo (void) const
  • SoPath * getPathAppliedTo (void) const
  • const SoPathList * getPathListAppliedTo (void) const
  • const SoPathList * getOriginalPathListAppliedTo (void) const
  • SbBool isLastPathListAppliedTo (void) const
  • PathCode getPathCode (int &numindices, const int *&indices)
  • void traverse (SoNode *const node)
  • SbBool hasTerminated (void) const
  • const SoPath * getCurPath (void)
  • SoState * getState (void) const
  • PathCode getCurPathCode (void) const
  • virtual SoNode * getCurPathTail (void)
  • void usePathCode (int &numindices, const int *&indices)
  • void pushCurPath (const int childindex, SoNode *node=NULL)
  • void popCurPath (const PathCode prevpathcode)
  • void pushCurPath (void)
  • void popPushCurPath (const int childindex, SoNode *node=NULL)
  • void popCurPath (void)
  • void switchToPathTraversal (SoPath *path)
  • void switchToNodeTraversal (SoNode *node)

⭐ Static Public Member Functions

  • static SoType getClassTypeId (void)
  • static void addMethod (const SoType type, SoActionMethod method)
  • static void enableElement (const SoType type, const int stackindex)
  • static void initClass (void)

🦋 Static Public Member Functions inherited from SoToVRMLAction

  • static SoType getClassTypeId (void)
  • static void addMethod (const SoType type, SoActionMethod method)
  • static void enableElement (const SoType type, const int stackindex)
  • static void initClass (void)

🎀 Static Public Member Functions inherited from SoAction

  • static void initClass (void)
  • static void initClasses (void)
  • static SoType getClassTypeId (void)
  • static void nullAction (SoAction *action, SoNode *node)

🧚 Protected Member Functions

  • virtual const SoEnabledElementsList & getEnabledElements (void) const
  • virtual void beginTraversal (SoNode *node)

🌸 Protected Member Functions inherited from SoAction

  • SoAction (void)
  • virtual void endTraversal (SoNode *node)
  • void setTerminated (const SbBool flag)
  • virtual SbBool shouldCompactPathList (void) const

💫 Static Protected Member Functions

  • static SoEnabledElementsList * getClassEnabledElements (void)
  • static SoActionMethodList * getClassActionMethods (void)

💜 Static Protected Member Functions inherited from SoToVRMLAction

  • static SoEnabledElementsList * getClassEnabledElements (void)
  • static SoActionMethodList * getClassActionMethods (void)

🫶 Static Protected Member Functions inherited from SoAction

  • static SoEnabledElementsList * getClassEnabledElements (void)
  • static SoActionMethodList * getClassActionMethods (void)

✨ Additional Inherited Members

Public Types inherited from SoAction:

  • enum AppliedCode { NODE = 0, PATH = 1, PATH_LIST = 2 }
  • enum PathCode { NO_PATH = 0, IN_PATH = 1, BELOW_PATH = 2, OFF_PATH = 3 }

Protected Attributes inherited from SoAction:

  • SoState * state
  • SoActionMethodList * traversalMethods

📖 Detailed Description 📖

okay so SoToVRML2Action builds a brand new scene graph, and it uses only VRML97/VRML2 nodes to do it. no cap. 🔥

This action is the one you call when you want to convert a scene graph made of VRML1/Coin nodes into a shiny new scene graph built entirely out of VRML97/VRML2 nodes. it's a whole transformation arc, honestly 🦋

here's the tea though: because VRML1/Coin and VRML2 are just built different (VRML2 doesn't really have a traversal state, bestie 😭), the new scene graph will typically end up somewhat larger. to minimize that, the action tries to reuse nodes whenever it can. resourceful queen behavior 👑

so like, VRML1 nodes get converted into their equivalent VRML2 nodes, easy. but Coin nodes that have no VRML2 equivalent? those get converted to IndexedFaceSet. and it gets specific: if the DrawStyle is POINTS, all geometry gets built using PointSet; if it's LINES, then IndexedLineSet is what's used. it's giving "i know exactly what to do here" 💅

here's a basic usage example of this action — a complete, standalone program, no edits needed:

#include <Inventor/SoDB.h>
#include <Inventor/SoInteraction.h>
#include <Inventor/SoInput.h>
#include <Inventor/SoOutput.h>
#include <Inventor/actions/SoWriteAction.h>
#include <Inventor/actions/SoToVRML2Action.h>
#include <Inventor/nodes/SoSeparator.h>
#include <Inventor/VRMLnodes/SoVRMLGroup.h>

int
main(int argc, char *argv[])
{
  SoDB::init();
  SoInteraction::init();
  SoInput in;
  in.openFile(argv[1]);
  printf("Reading...\n");
  SoSeparator *root = SoDB::readAll(&in);

  if (root) {
    root->ref();
    SbString hdr = in.getHeader();
    in.closeFile();

    printf("Converting...\n");
    SoToVRML2Action tovrml2;
    tovrml2.apply(root);
    SoVRMLGroup *newroot = tovrml2.getVRML2SceneGraph();
    newroot->ref();
    root->unref();

    printf("Writing...\n");

    SoOutput out;
    out.openFile("out.wrl");
    out.setHeaderString("#VRML V2.0 utf8");
    SoWriteAction wra(&out);
    wra.apply(newroot);
    out.closeFile();

    newroot->unref();
  }

  return 0;
}
⚠️ important note bestie: if VRML97 support is not present in the Coin library, this action does nothing and getVRML2SceneGraph always returns NULL. like, it's not even gonna try. 💀

See also

  • SoToVRMLAction

Since

  • Coin 2.0
  • TGS Inventor 2.5

🛠️ Constructor & Destructor Documentation 🛠️

💖 SoToVRML2Action::SoToVRML2Action (void )

Constructor. makes the thing. iconic behavior, honestly ✨

💖 SoToVRML2Action::~SoToVRML2Action (void ) [virtual]

The destructor. it cleans up after itself, as one does 🫶

💖 Member Function Documentation 💖

okay bestie, this is the part where we meet all the actual functions. grab a snack, there's a bunch 🍓

🌟 SoType SoToVRML2Action::getTypeId (void ) const [virtual]

Returns the type identification of an object derived from a class inheriting SoAction. It's the whole "who even am I at runtime" situation — used for runtime type checking and "downward" casting.

Reimplemented from SoToVRMLAction. 💅

🌟 SoType SoToVRML2Action::getClassTypeId (void ) [static]

This static method returns the SoType object associated with objects of this class. Like the class's official ID card fr.

🌟 void SoToVRML2Action::addMethod (const SoType type, SoActionMethod method) [static]

This API member is considered internal to the library, as it is not likely to be of interest to the application programmer. so like… not your business bestie, it's giving backstage pass only 🙈

🌟 void SoToVRML2Action::enableElement (const SoType type, const int stackindex) [static]

Same energy: this API member is considered internal to the library, as it is not likely to be of interest to the application programmer. 💀

🌟 const SoEnabledElementsList & SoToVRML2Action::getEnabledElements (void ) const [protected], [virtual]

Returns list of enabled elements. that's it, that's the whole vibe.

Reimplemented from SoToVRMLAction.

🌟 SoEnabledElementsList * SoToVRML2Action::getClassEnabledElements (void ) [static], [protected]

Returns list of enabled elements for this class.

okay so here's the lore: the enabledElements and methods variables are protected in the original OIV API. This is not such a good idea, since exposed static class member variables is a major grievance with regard to Win32 DLLs. This function is an extension for Coin, and it is not available in the original SGI Open Inventor v2.1 API. periodt. 👑

🌟 SoActionMethodList * SoToVRML2Action::getClassActionMethods (void ) [static], [protected]

Returns list of action methods for this class.

And the same tea again: the enabledElements and methods variables are protected in the original OIV API. This is not such a good idea, since exposed static class member variables is a major grievance with regard to Win32 DLLs. This function is an extension for Coin, and it is not available in the original SGI Open Inventor v2.1 API. 🫶

🌟 void SoToVRML2Action::initClass (void ) [static]

Initializes the runtime type system for this class, and sets up the enabled elements and action method list. it's the setup montage moment ✨

🌟 void SoToVRML2Action::apply (SoNode * root) [virtual]

Applies the action to the scene graph rooted at root.

Note that you should not apply an action to a node with a zero reference count. The behavior in that case is undefined. so like… don't, bestie, that's literally undefined behavior territory 😭

Reimplemented from SoToVRMLAction.

🌟 void SoToVRML2Action::apply (SoPath * path) [virtual]

Applies the action to the parts of the graph defined by path.

Note that an SoPath will also contain all nodes that may influence e.g. geometry nodes in the path. So for instance applying an SoGLRenderAction on an SoPath will render that path as expected in the view, where geometry will get its materials, textures, and other appearance settings correctly. the way it just pulls the whole look together 💅

If the path ends in an SoGroup node, the action will also traverse the tail node's children. it goes deep, no cap.

Reimplemented from SoToVRMLAction.

🌟 void SoToVRML2Action::apply (const SoPathList & pathlist, SbBool obeysrules = FALSE) [virtual]

Applies action to the graphs defined by pathlist. If obeysrules is set to TRUE, pathlist must obey the following four conditions (which is the case for path lists returned from search actions for non-group nodes and path lists returned from picking actions):

  1. All paths must start at the same head node.
  2. All paths must be sorted in traversal order.
  3. The paths must be unique.
  4. No path can continue through the end point of another path.

four rules, all mandatory, it's giving strict bestie rules 🌸

See also

SoAction::apply(SoPath * path)

Reimplemented from SoToVRMLAction.

🌟 SoVRMLGroup * SoToVRML2Action::getVRML2SceneGraph (void ) const

Return a pointer to the root node of the generated scene graph of only VRML2 / VRML97 nodes.

Will return NULL if VRML97 support was not compiled into the library. so if you get nothing back, that's why — not a you problem, it's a build problem 🙈

🌟 void SoToVRML2Action::reuseAppearanceNodes (SbBool appearance)

Set the flag deciding if appearance nodes should be reused if possible. The default is FALSE.

Please note that support for reusing Appearance nodes is not implemented yet. so yeah, flag exists, feature doesn't 💀

🌟 SbBool SoToVRML2Action::doReuseAppearanceNodes (void ) const

Get the flag deciding if appearance nodes should be reused if possible. The default is FALSE.

Please note that support for reusing Appearance nodes is not implemented yet, so this method will always return FALSE. always. every single time. iconic consistency honestly.

🌟 void SoToVRML2Action::reusePropertyNodes (SbBool property)

Set the flag deciding if property nodes should be reused if possible. The default is FALSE. this one actually has no sad little note attached, slay ✨

🌟 SbBool SoToVRML2Action::doReusePropertyNodes (void ) const

Get the flag deciding if property nodes should be reused if possible. The default is FALSE. yes bestie, still FALSE by default.

🌟 void SoToVRML2Action::reuseGeometryNodes (SbBool geometry)

Set the flag deciding if geometry nodes should be reused if possible. The default is FALSE.

Please note that support for reusing Geometry nodes is not implemented yet. 😭

🌟 SbBool SoToVRML2Action::doReuseGeometryNodes (void ) const

Get the flag deciding if geometry nodes should be reused if possible. The default is FALSE.

Please note that support for reusing Geometry nodes is not implemented yet, so this function will always return FALSE. every. single. time. 💀

🌟 void SoToVRML2Action::beginTraversal (SoNode * node) [protected], [virtual]

This virtual method is called from SoAction::apply(), and is the entry point for the actual scene graph traversal. it's the main character entrance 🚪✨

It can be overridden to initialize the action at traversal start, for specific initializations in the action subclasses inheriting SoAction.

Default method just calls traverse(), which any overridden implementation of the method must do too (or call SoAction::beginTraversal()) to trigger the scene graph traversal. so if you override it, don't forget to actually kick off the traversal, bestie, or nothing happens and you'll be confused for hours 🫶

Reimplemented from SoToVRMLAction.

🦋 Author 🦋

Generated automatically by Doxygen for Coin from the source code. not a human, just a very hardworking robot doing its thing 🤖💖

and that's a wrap on SoToVRML2Action(3)!! this page came from Coin version 4.0.10, dated Thu Jun 25 2026 00:00:00, so if you're reading this from some future timeline, hi, hope your build worked 🌈 stay slaying, go reuse those nodes (jk you can't yet, they're not implemented) 💜🎀

📦 where this page comes from