SoIndexedFaceSet(3)

📦 version 3.1.3, in fedora 43, fedora 44

💅 SoIndexedFaceSet(3) — Library Functions Manual 💅

okay so bestie, welcome to the SoIndexedFaceSet(3) page, straight out of the Library Functions Manual ✨ she's a big one so we're doing this in three parts and this is part one. hydrate, sit down, let's go 🫶

🎀 NAME 🎀

SoIndexedFaceSet — the class used to handle generic indexed facesets. that's her whole thing. she's the one you call when you've got faces and indices and you need somebody to handle it 💁‍♀️ no cap.

✨ SYNOPSIS ✨

#include <Inventor/nodes/SoIndexedFaceSet.h>

Inherits SoIndexedShape. so she's got family, and we're about to list the entire family tree because that's just how C++ do 🙈

🌸 Public Member Functions 🌸

her own functions, the ones she actually wrote, the main character moments 👑

  • virtual SoType getTypeId (void) const — the type-id getter, virtual, hers 💖
  • SoIndexedFaceSet (void) — the constructor, front and center, no arguments, just vibes ✨
  • virtual void GLRender (SoGLRenderAction *action) — takes a SoGLRenderAction *action and renders 🎀
  • virtual void getPrimitiveCount (SoGetPrimitiveCountAction *action) — counts primitives, takes the action, you know how it is 💅
  • virtual SbBool generateDefaultNormals (SoState *state, SoNormalBundle *bundle) — one overload, SoState *state + SoNormalBundle *bundle, returns an SbBool 🦋
  • virtual SbBool generateDefaultNormals (SoState *state, SoNormalCache *cache) — and the other overload, same shape but SoNormalCache *cache this time. two of them. iconic 💅

🦋 Public Member Functions inherited from SoVertexShape 🦋

  • virtual void write (SoWriteAction *action) — inherited, she didn't write it, but it's in the bloodline 💜

🌈 Public Member Functions inherited from SoShape 🌈

  • virtual SbBool affectsState (void) const — inherited ✨
  • virtual void getBoundingBox (SoGetBoundingBoxAction *action) — inherited 💖
  • virtual void rayPick (SoRayPickAction *action) — inherited 🎀
  • virtual void callback (SoCallbackAction *action) — inherited 🌸
  • const SoBoundingBoxCache * getBoundingBoxCache (void) const — inherited, and it's const and it returns a const SoBoundingBoxCache *, she's consistent 💅

👑 Public Member Functions inherited from SoNode 👑

  • 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 void doAction (SoAction *action)
  • 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 pick (SoPickAction *action)
  • virtual void search (SoSearchAction *action)
  • virtual void audioRender (SoAudioRenderAction *action)
  • virtual void grabEventsSetup (void)
  • virtual void grabEventsCleanup (void)
  • virtual void startNotify (void)
  • 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

all of these came from SoNode, so like, she inherited them, not her fault, we still list them 💀

💜 Public Member Functions inherited 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

look at all these. set twice, get twice, overloads everywhere. she contains multitudes 🫶

🍓 Public Member Functions inherited from SoBase 🍓

  • 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

and that's the SoBase set, the origin story, the ancestors, the whole lineage 🌸

⭐ Static Public Member Functions ⭐

  • static SoType getClassTypeId (void) — static, class-level, no instance needed 💅
  • static void initClass (void) — also static ✨

🌟 Static Public Member Functions inherited from SoIndexedShape 🌟

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

💫 Static Public Member Functions inherited from SoVertexShape 💫

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

🧚 Static Public Member Functions inherited from SoShape 🧚

  • static SoType getClassTypeId (void)
  • static void initClass (void)
  • static void getScreenSize (SoState *const state, const SbBox3f &boundingbox, SbVec2s &rectsize)
  • static float getDecimatedComplexity (SoState *state, float complexity)

🔥 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)

the ...S ones are all there, every single one, don't @ me, they're all accounted for 💀✨

💖 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)

🎀 Protected Member Functions 🎀

the ones you can't touch unless you're in the family, iykyk 🙈

  • virtual const SoFieldData * getFieldData (void) const — virtual, protected, returns a const SoFieldData * 💅
  • virtual ~SoIndexedFaceSet () — the destructor, protected, virtual, she goes out the way she came in ✨
  • virtual void generatePrimitives (SoAction *action) — virtual, takes the action 🦋

🌸 Protected Member Functions inherited from SoIndexedShape 🌸

  • SoIndexedShape (void)
  • virtual ~SoIndexedShape ()
  • virtual void computeBBox (SoAction *action, SbBox3f &box, SbVec3f &center)
  • int getNumVerts (const int startCoord)
  • void setupIndices (const int numParts, const int numFaces, const SbBool needNormals, const SbBool needTexCoords)
  • const int32_t * getNormalIndices (void)
  • const int32_t * getColorIndices (void)
  • const int32_t * getTexCoordIndices (void)
  • SbBool getVertexData (SoState *state, const SoCoordinateElement *&coords, const SbVec3f *&normals, const int32_t *&cindices, const int32_t *&nindices, const int32_t *&tindices, const int32_t *&mindices, int &numcindices, const SbBool needNormals, SbBool &normalCacheUsed)

💜 Protected Member Functions inherited from SoVertexShape 💜

  • SoVertexShape (void)
  • virtual ~SoVertexShape ()
  • virtual SbBool shouldGLRender (SoGLRenderAction *action)
  • void setNormalCache (SoState *const state, const int num, const SbVec3f *normals)
  • SoNormalCache * getNormalCache (void) const
  • SoNormalCache * generateAndReadLockNormalCache (SoState *const state)
  • void getVertexData (SoState *state, const SoCoordinateElement *&coords, const SbVec3f *&normals, const SbBool neednormals)
  • void readLockNormalCache (void)
  • void readUnlockNormalCache (void)
heads up bestie: getVertexData shows up in both SoIndexedShape and SoVertexShape and they are not the same signature — the SoIndexedShape one takes const int32_t *&cindices, const int32_t *&nindices, const int32_t *&tindices, const int32_t *&mindices, int &numcindices, const SbBool needNormals, SbBool &normalCacheUsed, and the SoVertexShape one takes const SbBool neednormals. don't mix them up, that's a vibe check you do not want to fail 😭

and that's where part one ends, bestie — we're not even close to done, keep going 💖

🔒 Protected Member Functions inherited from SoShape

bestie these are the ones you get handed down from SoShape — not yours to call from the outside, but they're the family recipes 💖

  • SoShape(void) — constructor, it exists, that's the vibe.
  • virtual ~SoShape() — destructor, virtual, so it cleans up properly.
  • float getComplexityValue(SoAction *action) — hands back the complexity value for the action in question.
  • void beginSolidShape(SoGLRenderAction *action) — open up the solid-shape rendering bit.
  • void endSolidShape(SoGLRenderAction *action) — and close it back up. matching set, periodt.
  • void GLRenderBoundingBox(SoGLRenderAction *action) — renders the bounding box, exactly like it says.
  • SbBool shouldPrimitiveCount(SoGetPrimitiveCountAction *action) — tells you whether the primitive count step should happen for this action.
  • SbBool shouldRayPick(SoRayPickAction *const action) — tells you whether this thing should bother with ray picking for the action.
  • void computeObjectSpaceRay(SoRayPickAction *const action) — works out the ray in object space.
  • void computeObjectSpaceRay(SoRayPickAction *const action, const SbMatrix &matrix) — same energy, but you hand it a matrix to work with.
  • virtual SoDetail * createTriangleDetail(SoRayPickAction *action, const SoPrimitiveVertex *v1, const SoPrimitiveVertex *v2, const SoPrimitiveVertex *v3, SoPickedPoint *pp) — makes the triangle detail, from three primitive vertices v1, v2, v3 and a picked point.
  • virtual SoDetail * createLineSegmentDetail(SoRayPickAction *action, const SoPrimitiveVertex *v1, const SoPrimitiveVertex *v2, SoPickedPoint *pp) — same thing but for a line segment, two vertices only.
  • virtual SoDetail * createPointDetail(SoRayPickAction *action, const SoPrimitiveVertex *v, SoPickedPoint *pp) — and for a single point. one vertex, one detail.
  • void invokeTriangleCallbacks(SoAction *const action, const SoPrimitiveVertex *const v1, const SoPrimitiveVertex *const v2, const SoPrimitiveVertex *const v3) — fires off the triangle callbacks.
  • void invokeLineSegmentCallbacks(SoAction *const action, const SoPrimitiveVertex *const v1, const SoPrimitiveVertex *const v2) — fires off the line segment callbacks.
  • void invokePointCallbacks(SoAction *const action, const SoPrimitiveVertex *const v) — fires off the point callbacks. tiny but mighty ✨
  • void beginShape(SoAction *const action, const TriangleShape shapetype, SoDetail *const detail=NULL) — starts a shape off, you pass the shapetype and an optional detail (defaults to NULL).
  • void shapeVertex(const SoPrimitiveVertex *const v) — drops in a vertex for the shape.
  • void endShape(void) — wraps the shape up.
  • void generateVertex(SoPrimitiveVertex *const pv, const SbVec3f &point, const SbBool useTexFunc, const SoTextureCoordinateElement *const tce, const float s, const float t, const SbVec3f &normal) — builds a primitive vertex from a point, useTexFunc, a texture coordinate element, s, t and a normal.
  • void generateVertex(SoPrimitiveVertex *const pv, const SbVec3f &point, const SbBool useTexFunc, const SoTextureCoordinateElement *const tce, const float s, const float t, const float r, const SbVec3f &normal) — the other overload, this one also takes r. 👑
  • SbBool startVertexArray(SoGLRenderAction *action, const SoCoordinateElement *coords, const SbVec3f *pervertexnormals, const SbBool texpervertex, const SbBool colorpervertex) — kicks off the vertex array with coords, per-vertex normals, and the per-vertex texture/color flags.
  • void finishVertexArray(SoGLRenderAction *action, const SbBool vbo, const SbBool normpervertex, const SbBool texpervertex, const SbBool colorpervertex) — closes the vertex array, with the vbo and per-vertex flags.

🔒 Protected Member Functions inherited from SoNode

  • SoNode(void) — constructor.
  • virtual ~SoNode() — destructor.
  • virtual SbBool readInstance(SoInput *in, unsigned short flags) — reads the instance from in with those flags.

🔒 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) — the destroy routine.
  • SbBool hasMultipleWriteRefs(void) const — checks whether there are multiple write refs.
  • SbBool writeHeader(SoOutput *out, SbBool isgroup, SbBool isengine) const — writes the header out, told whether it's a group and whether it's an engine.
  • void writeFooter(SoOutput *out) const — writes the footer.
  • virtual const char * getFileFormatName(void) const — returns the file format name.

🛡️ Static Protected Member Functions

  • static const SoFieldData ** getFieldDataPtr(void) — pointer to the field data pointer. the classic.

Static Protected Member Functions inherited from SoIndexedShape

  • static const SoFieldData ** getFieldDataPtr(void) — same deal, indexed-shape flavoured.
  • static SbBool areTexCoordsIndexed(SoAction *action) — tells you whether texture coords are indexed for this action.

Static Protected Member Functions inherited from SoVertexShape

  • static const SoFieldData ** getFieldDataPtr(void) — again, but from SoVertexShape.

Static Protected Member Functions inherited from SoShape

  • static const SoFieldData ** getFieldDataPtr(void) — and again from SoShape.

Static Protected Member Functions inherited from SoNode

  • static const SoFieldData ** getFieldDataPtr(void) — from SoNode.
  • static void setNextActionMethodIndex(int index) — sets the next action method index to index.
  • static int getNextActionMethodIndex(void) — gets it back.
  • static void incNextActionMethodIndex(void) — bumps it up by one.
  • static void setCompatibilityTypes(const SoType &nodetype, const uint32_t bitmask) — sets compatibility types for a node type with a bitmask.

Static Protected Member Functions inherited from SoBase

  • static uint32_t getCurrentWriteCounter(void) — hands back the current write counter.
  • static void staticDataLock(void) — locks the static data.
  • static void staticDataUnlock(void) — unlocks it. balance, babe 🧚

🫶 Additional Inherited Members

all the stuff you also get for free just by existing in this family tree 💅

Public Types inherited from SoShape

enum TriangleShape { TRIANGLE_STRIP, TRIANGLE_FAN, TRIANGLES, POLYGON,
    QUADS, QUAD_STRIP, POINTS, LINES, LINE_STRIP }

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 }

Public Attributes inherited from SoIndexedShape

  • SoMFInt32 coordIndex
  • SoMFInt32 materialIndex
  • SoMFInt32 normalIndex
  • SoMFInt32 textureCoordIndex

Public Attributes inherited from SoVertexShape

  • SoSFNode vertexProperty

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

So the SoIndexedFaceSet class is your girl for handling generic indexed facesets. literally her whole job 💖

Faces get specified using the coordIndex field. Every face has to be terminated by a negative (-1) index. Coordinates, normals, materials and texture coordinates from the current state (or from the vertexProperty node if it's set) can be indexed to create triangles, quads or polygons. slay.

Here's a usage example of just about the simplest possible use of this node, showing off a single polygon face:

#Inventor V2.1 ascii

Separator {
   Coordinate3 {
      point [ 0 0 0, 1 0 0, 1 1 0 ]
   }
   IndexedFaceSet {
      coordIndex [ 0, 1, 2, -1 ]
   }
}

Binding PER_VERTEX_INDEXED, PER_VERTEX, PER_FACE_INDEXED, PER_FACE or OVERALL can be set for material, and normals. The default material binding is OVERALL. The default normal binding is PER_VERTEX_INDEXED. When PER_VERTEX_INDEXED binding is used and the corresponding materialIndex, normalIndex, texCoordIndex field is empty, the coordIndex field will be used to index material, normal or texture coordinate. If you do specify indices for material, normals or texture coordinates for PER_VERTEX_INDEXED binding, make sure your index array matches the coordIndex array: there should be a -1 wherever there is a -1 in the coordIndex field. This is done to make this node more easily readable for humans. (aw, they did it for us 🥹)

A fairly common request when rendering facesets is how to display a set of faces with different colors on the backside versus the frontside. There is not direct support for this in the API, but it can easily be implemented by duplicating all faces in both the SoShapeHints::COUNTERCLOCKWISE and the SoShapeHints::CLOCKWISE order. Here's a simple usage example, showing the technique for a single polygon, using two SoFaceSet nodes for rendering the same polygon from both sides:

#Inventor V2.1 ascii

Separator {
   Coordinate3 { point [ 0 0 0, 1 0 0, 1 1 0 ] }

   Separator {
      Material { diffuseColor [ 1 1 0 ] }
      ShapeHints {
         vertexOrdering COUNTERCLOCKWISE
         shapeType SOLID
      }
      FaceSet { numVertices [ 3 ] }
   }

   Separator {
      Material { diffuseColor [ 1 0 0 ] }
      ShapeHints {
         vertexOrdering CLOCKWISE
         shapeType SOLID
      }
      FaceSet { numVertices [ 3 ] }
   }
}

The same effect can also be done in the following manner, using an SoIndexedFaceSet to explicitly render the polygon coordinates in both directions (clockwise and counterclockwise):

#Inventor V2.1 ascii

Separator {
   Coordinate3 { point [ 0 0 0, 1 0 0, 1 1 0 ] }

   Material { diffuseColor [ 1 0 0, 1 1 0 ] }
   MaterialBinding { value PER_FACE_INDEXED }

   ShapeHints {
      vertexOrdering COUNTERCLOCKWISE
      shapeType SOLID
   }

   IndexedFaceSet {
      coordIndex [ 0, 1, 2, -1, 2, 1, 0, -1 ]
      materialIndex [ 0, 1 ]
   }
}

Another rather rare issue that might be interesting to know about is that to render polygons with concave borders, you should set up an SoShapeHints node with SoShapeHints::faceType set to SoShapeHints::UNKNOWN_FACE_TYPE in the scene graph before the SoIndexedFaceSet (or SoFaceSet) node. This needs to be done to force the rendering code to tessellate the polygons properly to triangles before sending it off to OpenGL. Without it, the polygons will be sent as-is to OpenGL, and the OpenGL implementation's tessellator is often not able to tessellate properly. 😭 Here's an example which usually fails without the SoShapeHints node (try commenting it out, and see what happens):

#Inventor V2.1 ascii

ShapeHints { faceType UNKNOWN_FACE_TYPE }

Coordinate3
{
        point [ 2 0 0,
                1 0 0,
                1 1 0,
                0 1 0,
                0 2 0,
                1 2 0,
                2 2 0,
                2 1 0 ]
}

FaceSet {}

FILE FORMAT/DEFAULTS:

IndexedFaceSet {
    vertexProperty NULL
    coordIndex 0
    materialIndex -1
    normalIndex -1
    textureCoordIndex -1
}

See also

SoFaceSet, SoIndexedTriangleStripSet

🌸 Constructor & Destructor Documentation

SoIndexedFaceSet::SoIndexedFaceSet (void )

Constructor. 💖

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

Destructor. 🫶

and there's still more where this came from 👀

💖 MEMBER FUNCTION DOCUMENTATION 💖

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

Okay so bestie, this one hands you back the type identification of any object that's derived from a class inheriting SoBase. What's it for? Run-time type checking and "downward" casting, periodt. ✨

Usage example, and yes this is verbatim, don't come for me:

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

Now listen 👑 — if you're an application programmer who wants to extend the library with new nodes, engines, nodekits, draggers or whatever else, this method needs to be overridden in all subclasses. No skips, no shortcuts. 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.

Wanna know more about writing Coin extensions? Go read the class documentation of the toplevel superclasses for the various class groups. iykyk 🦋

Reimplemented from SoIndexedShape.

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

Returns a pointer to the class-wide field data storage object for this instance. And if there are no fields present? It returns NULL. That's it, that's the whole vibe. 💅

Reimplemented from SoIndexedShape.

void SoIndexedFaceSet::GLRender(SoGLRenderAction * action) [virtual]

Action method for the SoGLRenderAction. 🌈

This one gets called during rendering traversals. Nodes that influence the rendering state in any way, or that just wanna throw geometry primitives at OpenGL, override this method. Very main character of them, honestly.

Reimplemented from SoShape.

void SoIndexedFaceSet::getPrimitiveCount(SoGetPrimitiveCountAction * action) [virtual]

Action method for the SoGetPrimitiveCountAction. 🔢

It calculates the number of triangle, line segment and point primitives for the node, and adds these to the counters of the action. Math girlies rise up.

And heads up — nodes that influence how geometry nodes calculate their primitive count also override this method to change the relevant state variables.

Reimplemented from SoShape.

SbBool SoIndexedFaceSet::generateDefaultNormals(SoState * state, SoNormalBundle * bundle) [virtual]

Heads up bestie: this API member is considered internal to the library, since it is not likely to be of interest to the application programmer. 🫶

Subclasses should override this method to generate default normals using the SoNormalBundle class. Return TRUE if normals were generated, FALSE otherwise. Simple as that.

The default method returns FALSE. 🙈

This function is an extension for Coin, and it is not available in the original SGI Open Inventor v2.1 API.

Reimplemented from SoVertexShape.

SbBool SoIndexedFaceSet::generateDefaultNormals(SoState * state, SoNormalCache * cache) [virtual]

Same internal-energy disclaimer as above — this API member is considered internal to the library, as it is not likely to be of interest to the application programmer. 🎀

Subclasses should override this method to generate default normals using the SoNormalCache class. And here's the tea: this is more effective than using SoNormalGenerator. Return TRUE if normals were generated, FALSE otherwise.

The default method just returns FALSE. Nothing more, nothing less.

This function is an extension for Coin, and it is not available in the original SGI Open Inventor v2.1 API.

Reimplemented from SoVertexShape.

void SoIndexedFaceSet::generatePrimitives(SoAction * action) [protected], [virtual]

This method implements action behavior for shape nodes for SoCallbackAction. It gets invoked from SoShape::callback(). And listen — subclasses should not override SoNode::callback(). Do not do it. 💀

The subclass implementations uses the convenience methods SoShape::beginShape(), SoShape::shapeVertex(), and SoShape::endShape(), with SoDetail instances, to pass the primitives making up the shape back to the caller. Chef's kiss, honestly. ✨

Implements SoShape.

🌸 AUTHOR 🌸

Generated automatically by Doxygen for Coin from the source code. She didn't write herself, bestie, she was born that way. 💅

And that's a wrap on the whole page, no cap! 🎉 This gorgeous thing lives in Coin, Version 3.1.3, and she's filed under SoIndexedFaceSet(3). Go forth and index those face sets, you absolute icon. 👑🦋💖

📦 where this page comes from