SoShapeHints(3)

📦 version 3.1.3, in fedora 43, fedora 44

💖 SoShapeHints(3) 💖

okay bestie, this is the Library Functions Manual page for SoShapeHints, and it's literally the node that holds hints about how to render geometry. no cap. it inherits from SoNode, and we're about to go through every single type, function, attribute, and inherited goodie. periodt. 💅

🌸 NAME 🌸

SoShapeHints — The SoShapeHints class is a node containing hints about how to render geometry. ✨

✨ SYNOPSIS ✨

#include <Inventor/nodes/SoShapeHints.h>

Inherits SoNode. 🫶

🎀 Public Types 🎀

okay so first up, the enums that live directly in SoShapeHints. slay.

enum VertexOrdering { UNKNOWN_ORDERING =
    SoShapeHintsElement::UNKNOWN_ORDERING, CLOCKWISE =
    SoShapeHintsElement::CLOCKWISE, COUNTERCLOCKWISE =
    SoShapeHintsElement::COUNTERCLOCKWISE }
enum ShapeType { UNKNOWN_SHAPE_TYPE =
    SoShapeHintsElement::UNKNOWN_SHAPE_TYPE, SOLID =
    SoShapeHintsElement::SOLID }
enum FaceType { UNKNOWN_FACE_TYPE =
    SoShapeHintsElement::UNKNOWN_FACE_TYPE, CONVEX =
    SoShapeHintsElement::CONVEX }
enum WindingType { NO_WINDING_TYPE = 0 }

🌟 Public Types inherited from SoNode 🌟

and here's the enum it picked up from SoNode, because inheritance is iconic like that:

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 }

💅 Public Member Functions 💅

these are the ones SoShapeHints brings to the group chat itself:

  • virtual SoType getTypeId (void) const
  • SoShapeHints (void)
  • virtual void doAction (SoAction *action)
  • virtual void GLRender (SoGLRenderAction *action)
  • virtual void callback (SoCallbackAction *action)
  • virtual void getBoundingBox (SoGetBoundingBoxAction *action)
  • virtual void pick (SoPickAction *action)

🦋 Public Member Functions inherited from SoNode 🦋

the SoNode hand-me-downs, and there are a lot. we love a generous ancestor:

  • void setOverride (const SbBool state)
  • SbBool isOverride (void) const
  • void setNodeType (const NodeType type)
  • NodeType getNodeType (void) const
  • virtual SoNode * copy (SbBool copyconnections=FALSE) const
  • virtual SbBool affectsState (void) const
  • virtual void GLRenderBelowPath (SoGLRenderAction *action)
  • virtual void GLRenderInPath (SoGLRenderAction *action)
  • virtual void GLRenderOffPath (SoGLRenderAction *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 audioRender (SoAudioRenderAction *action)
  • virtual void getPrimitiveCount (SoGetPrimitiveCountAction *action)
  • virtual void grabEventsSetup (void)
  • virtual void grabEventsCleanup (void)
  • virtual void startNotify (void)
  • virtual void notify (SoNotList *l)
  • uint32_t getNodeId (void) const
  • virtual SoChildList * getChildren (void) const
  • virtual void writeInstance (SoOutput *out)
  • virtual SoNode * addToCopyDict (void) const
  • virtual void copyContents (const SoFieldContainer *from, SbBool copyconnections)
  • virtual SoFieldContainer * copyThroughConnection (void) const

🌸 Public Member Functions inherited from SoFieldContainer 🌸

more inherited magic, this time from SoFieldContainer:

  • void setToDefaults (void)
  • SbBool hasDefaultValues (void) const
  • SbBool fieldsAreEqual (const SoFieldContainer *container) const
  • void copyFieldValues (const SoFieldContainer *container, SbBool copyconnections=FALSE)
  • SbBool set (const char *const fielddata)
  • void get (SbString &fielddata)
  • virtual int getFields (SoFieldList &l) const
  • virtual int getAllFields (SoFieldList &l) const
  • virtual SoField * getField (const SbName &name) const
  • virtual SoField * getEventIn (const SbName &name) const
  • virtual SoField * getEventOut (const SbName &name) const
  • SbBool getFieldName (const SoField *const field, SbName &name) const
  • SbBool enableNotify (const SbBool flag)
  • SbBool isNotifyEnabled (void) const
  • SbBool set (const char *fielddata, SoInput *input)
  • void get (SbString &fielddata, SoOutput *out)
  • virtual SbBool validateNewFieldValue (SoField *field, void *newval)
  • virtual void addWriteReference (SoOutput *out, SbBool isfromfield=FALSE)
  • SbBool getIsBuiltIn (void) const
  • virtual void getFieldsMemorySize (size_t &managed, size_t &unmanaged) const
  • void setUserData (void *userdata) const
  • void * getUserData (void) const

💜 Public Member Functions inherited from SoBase 💜

and the SoBase classics, because every family reunion has that one ancestor:

  • void ref (void) const
  • void unref (void) const
  • void unrefNoDelete (void) const
  • int32_t getRefCount (void) const
  • void touch (void)
  • SbBool isOfType (SoType type) const
  • virtual SbName getName (void) const
  • virtual void setName (const SbName &newname)
  • void addAuditor (void *const auditor, const SoNotRec::Type type)
  • void removeAuditor (void *const auditor, const SoNotRec::Type type)
  • const SoAuditorList & getAuditors (void) const
  • SbBool shouldWrite (void)
  • void assertAlive (void) const

⭐ Static Public Member Functions ⭐

static besties, no instance needed, they just show up:

  • static SoType getClassTypeId (void)
  • static void initClass (void)

🌈 Static Public Member Functions inherited from SoNode 🌈

  • static uint32_t getCompatibilityTypes (const SoType &nodetype)
  • static SoType getClassTypeId (void)
  • static SoNode * getByName (const SbName &name)
  • static int getByName (const SbName &name, SoNodeList &l)
  • static void initClass (void)
  • static void initClasses (void)
  • static uint32_t getNextNodeId (void)
  • static int getActionMethodIndex (const SoType type)
  • static void getBoundingBoxS (SoAction *action, SoNode *node)
  • static void GLRenderS (SoAction *action, SoNode *node)
  • static void callbackS (SoAction *action, SoNode *node)
  • static void getMatrixS (SoAction *action, SoNode *node)
  • static void handleEventS (SoAction *action, SoNode *node)
  • static void pickS (SoAction *action, SoNode *node)
  • static void rayPickS (SoAction *action, SoNode *node)
  • static void searchS (SoAction *action, SoNode *node)
  • static void writeS (SoAction *action, SoNode *node)
  • static void audioRenderS (SoAction *action, SoNode *node)
  • static void getPrimitiveCountS (SoAction *action, SoNode *node)

✨ Static Public Member Functions inherited from SoFieldContainer ✨

  • static void initClass (void)
  • static SoType getClassTypeId (void)
  • static void cleanupClass (void)
  • static void initCopyDict (void)
  • static void addCopy (const SoFieldContainer *orig, const SoFieldContainer *copy)
  • static SoFieldContainer * checkCopy (const SoFieldContainer *orig)
  • static SoFieldContainer * findCopy (const SoFieldContainer *orig, const SbBool copyconnections)
  • static void copyDone (void)

🦋 Static Public Member Functions inherited from SoBase 🦋

  • static void initClass (void)
  • static SoType getClassTypeId (void)
  • static void addName (SoBase *const base, const char *const name)
  • static void removeName (SoBase *const base, const char *const name)
  • static void incrementCurrentWriteCounter (void)
  • static void decrementCurrentWriteCounter (void)
  • static SoBase * getNamedBase (const SbName &name, SoType type)
  • static int getNamedBases (const SbName &name, SoBaseList &baselist, SoType type)
  • static SbBool read (SoInput *input, SoBase *&base, SoType expectedtype)
  • static void setInstancePrefix (const SbString &c)
  • static void setTraceRefs (SbBool trace)
  • static SbBool getTraceRefs (void)
  • static SbBool connectRoute (SoInput *input, const SbName &fromnodename, const SbName &fromfieldname, const SbName &tonodename, const SbName &tofieldname)
  • static SbBool readRoute (SoInput *input)

🦋 Public Attributes 🦋

these are the public fields you can actually set, and they're giving main character energy:

  • SoSFEnum vertexOrdering
  • SoSFEnum shapeType
  • SoSFEnum faceType
  • SoSFEnum windingType
  • SoSFBool useVBO
  • SoSFFloat creaseAngle

🧚 Protected Member Functions 🧚

protected, so don't touch unless you're subclassing, bestie:

  • virtual const SoFieldData * getFieldData (void) const
  • virtual ~SoShapeHints ()

💖 Protected Member Functions inherited from SoNode 💖

  • SoNode (void)
  • virtual ~SoNode ()
  • virtual SbBool readInstance (SoInput *in, unsigned short flags)

💖 Protected Member Functions inherited from SoFieldContainer 💖

  • SoFieldContainer (void)
  • virtual ~SoFieldContainer ()

💖 Protected Member Functions inherited from SoBase 💖

  • SoBase (void)
  • virtual ~SoBase ()
  • virtual void destroy (void)
  • SbBool hasMultipleWriteRefs (void) const
  • SbBool writeHeader (SoOutput *out, SbBool isgroup, SbBool isengine) const
  • void writeFooter (SoOutput *out) const
  • virtual const char * getFileFormatName (void) const

💜 Static Protected Member Functions 💜

  • static const SoFieldData ** getFieldDataPtr (void)

🌟 Static Protected Member Functions inherited from SoNode 🌟

  • static const SoFieldData ** getFieldDataPtr (void)
  • static void setNextActionMethodIndex (int index)
  • static int getNextActionMethodIndex (void)
  • static void incNextActionMethodIndex (void)
  • static void setCompatibilityTypes (const SoType &nodetype, const uint32_t bitmask)

🌟 Static Protected Member Functions inherited from SoBase 🌟

  • static uint32_t getCurrentWriteCounter (void)
  • static void staticDataLock (void)
  • static void staticDataUnlock (void)

🌈 Additional Inherited Members 🌈

🎀 Protected Types inherited from SoBase 🎀

enum BaseFlags { IS_ENGINE = 0x01, IS_GROUP = 0x02 }

🎀 Protected Attributes inherited from SoNode 🎀

  • uint32_t uniqueId

🎀 Protected Attributes inherited from SoFieldContainer 🎀

  • SbBool isBuiltIn

🎀 Static Protected Attributes inherited from SoNode 🎀

  • static uint32_t nextUniqueId = 1
  • static int nextActionMethodIndex = 0

💖 Detailed Description 💖

okay bestie, listen. The SoShapeHints class is literally just a node that holds hints about how to render geometry. That's it. That's the whole vibe.

The SoShapeHints node is how you drop little clues to the rendering subsystem about how particular aspects of the subsequent geometry in the scene graph should be drawn. Think of it as passing notes in class, except the notes are about backface culling 🫶

So here's the tea: the default settings of the rendering system are tuned towards programmer convenience. For instance, the default is to render both sides of all polygons, so we never get any "holes" in the geometry if the vertex ordering happens to differ between different polygons. Cozy, right? But cozy costs ya.

If the programmer gives up some of that convenience and uses SoShapeHints nodes to more closely specify information about the scene graph geometry, then the clues from the SoShapeHints node(s) get used by the rendering subsystem to avoid certain costly operations. Significant gains in rendering speed could be seen as a result. no cap, speed is the whole point ✨

⚠️ Be aware that the way backface culling and two-sided lighting is decided by the rendering system is not at all intuitive. Like, at all. Here are the common rules of how primitive shapes will render themselves with regard to how the SoShapeHints::vertexOrdering and SoShapeHints::shapeType fields are set:
  • vertexOrdering == CLOCKWISE or COUNTERCLOCKWISE, shapeType == SOLID: causes primitives to be backface culled and rendered with one-sided lighting.
  • vertexOrdering == CLOCKWISE or COUNTERCLOCKWISE, shapeType == UNKNOWN_SHAPE_TYPE: primitives are not backface culled, and they are rendered with two-sided lighting.
  • vertexOrdering == UNKNOWN_ORDERING, any shapeType: primitives are not backface culled, and they are rendered with one-sided lighting. The OpenGL vertex ordering will be set to counter clockwise ordering.

The UNKNOWN_ORDERING enum has a special and non-intuitive meaning. The ordering is really set to counter clockwise — in OpenGL and when generating normals. However, if you want to render your geometry with one-sided lighting and backface culling disabled, you have to use this enum value, and your polygons need to be in counter clockwise ordering. it's giving "the name lies to you" energy, iykyk 💀

📁 FILE FORMAT/DEFAULTS 📁

ShapeHints {
    vertexOrdering UNKNOWN_ORDERING
    shapeType UNKNOWN_SHAPE_TYPE
    faceType CONVEX
    creaseAngle 0
}

🧚 Member Enumeration Documentation 🧚

enum SoShapeHints::VertexOrdering

Enumeration of available ways to specify ordering of vertices for a polygon.

Enumerator

  • UNKNOWN_ORDERING — Ordering not known, render both sides of the polygon.
  • CLOCKWISE — Vertices are specified in a clockwise order.
  • COUNTERCLOCKWISE — Vertices are specified in a counter-clockwise order.

enum SoShapeHints::ShapeType

Enumeration of different shape types.

Enumerator

  • UNKNOWN_SHAPE_TYPE — Nothing known about the shape, be conservative when rendering.
  • SOLID — The subsequent shapes in the graph are all known to be completely "closed", solid 3D shapes. Backface culling will be done if vertexOrdering is known.

enum SoShapeHints::FaceType

Enumeration of polygon face types.

Enumerator

  • UNKNOWN_FACE_TYPE — Signifies: nothing is known about subsequent polygon data, be conservative when rendering.

All polygons in the scene will be analyzed to see if they needs to be tessellated (broken up) into triangles before passed on to the underlying immediate mode rendering system. yes, "needs" — we don't make the rules 💅

The OpenGL rendering system handles most complex polygon types, but not all: it can for instance have problems with many-sided, concave polygons (concave polygons are "hollow", that is: rounded inwards). Coin's internal tessellator will most often handle the cases that OpenGL fails on.

So if you are seeing weird artifacts in how complex polygons are rendered, try to change the SoShapeHints::faceType field to this value and see if they are then rendered correctly. sometimes the fix is just that 🎀

🚨 Beware that turning on this functionality might have the effect of making the rendering performance worse. If it has a noticeable effect on your particular scenegraph, we advise that you investigate whether you could change how the polygons are generated for Coin rendering and then avoid using this flag. like, it works, but at what cost 😭
  • CONVEX — Subsequent faces are all convex, so turn off the check for and tessellation of inconvex faces.

Subsequent polygons from faceset-type nodes (like SoFaceSet and SoIndexedFaceSet) will be sent unmodified to OpenGL, thereby assuming that the polygons are in a form handled by OpenGL.

🌸 Constructor & Destructor Documentation 🌸

SoShapeHints::SoShapeHints (void )

Constructor. (the birth of a legend 👑)

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

Destructor. (rip bozo, protected + virtual 🦋)

✨ Member Function Documentation ✨

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

Returns the type identification of an object derived from a class inheriting SoBase. This is used for run-time type checking and "downward" casting.

Usage example:

void foo(SoNode * node)
{
  if (node->getTypeId() == SoFile::getClassTypeId()) {
    SoFile * filenode = (SoFile *)node;  // safe downward cast, knows the type
  }
}

For application programmers wanting to extend the library with new nodes, engines, nodekits, draggers or others: this method needs to be overridden in all subclasses. This is typically done as part of setting up the full type system for extension classes, which is usually accomplished by using the pre-defined macros available through for instance Inventor/nodes/SoSubNode.h (SO_NODE_INIT_CLASS and SO_NODE_CONSTRUCTOR for node classes), Inventor/engines/SoSubEngine.h (for engine classes) and so on.

For more information on writing Coin extensions, see the class documentation of the toplevel superclasses for the various class groups.

Implements SoBase.

const SoFieldData * SoShapeHints::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.

void SoShapeHints::doAction (SoAction * action) [virtual]

This function performs the typical operation of a node for any action.

Reimplemented from SoNode.

void SoShapeHints::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.

void SoShapeHints::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.

void SoShapeHints::getBoundingBox (SoGetBoundingBoxAction * action) [virtual]

Action method for the SoGetBoundingBoxAction.

Calculates bounding box and center coordinates for node and modifies the values of the action to encompass the bounding box for this node and to shift the center point for the scene more towards the one for this node.

Nodes influencing how geometry nodes calculates their bounding box also overrides this method to change the relevant state variables.

Reimplemented from SoNode.

void SoShapeHints::pick (SoPickAction * action) [virtual]

Action method for SoPickAction.

Does common processing for SoPickAction action instances.

Reimplemented from SoNode.

💜 Member Data Documentation 💜

SoSFEnum SoShapeHints::vertexOrdering

Specifies how vertices are ordered for polygon faces.

Set this field to SoShapeHints::CLOCKWISE or SoShapeHints::COUNTERCLOCKWISE if possible to turn on backface culling and thereby optimize rendering.

Default value is SoShapeHints::UNKNOWN_ORDERING.

SoSFEnum SoShapeHints::shapeType

Hint about whether or not shapes are known to be "closed". Default value is SoShapeHints::UNKNOWN_SHAPE_TYPE.

SoSFEnum SoShapeHints::faceType

Hint about whether or not polygon faces are known to be convex. Default value is SoShapeHints::CONVEX.

SoSFFloat SoShapeHints::creaseAngle

When normals are automatically generated by Coin (i.e. SoNormal nodes are not used), this is the smallest angle between two faces where we would still calculate normals to do flatshading.

If the angle between the normals of two neighboring faces is less than the value of this field, the faces will be smoothshaded around their common edge.

The angle is specified in radians, and the default value is 0.0, meaning no smoothing will be done by default. flat king behavior, honestly ⭐

🫶 Author 🫶

Generated automatically by Doxygen for Coin from the source code.

and that's the whole page bestie!! this was Coin Version 3.1.3, manual page SoShapeHints(3) — go forth and cull those backfaces responsibly 🌈💖🎀

📦 where this page comes from