SoGLLazyElement(3)

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

✨ SoGLLazyElement ✨

okay bestie, welcome to the <code>SoGLLazyElement</code> page 💖 — this one lives in the Coin manual, section 3, so you know it's a library/API thing and not some command you type in your shell. It's giving ✨developer documentation✨ and honestly? iconic.

🎀 NAME 🎀

SoGLLazyElement — the class that is meant to optimize GL rendering. 💅

That's it, that's the whole vibe for this bit. The SoGLLazyElement class exists to make your GL rendering faster, fr fr. 🔥

✨ SYNOPSIS ✨

#include <Inventor/elements/SoGLLazyElement.h>

Inherits SoLazyElement. (yes bestie it's giving nepo baby but make it Open Inventor 💅)

🎀 Classes 🎀

  • struct GLState — the whole GL state vibe, no further details given, bestie 😭

💅 Public Member Functions 💅

  • virtual void init (SoState *state) — init goes brrr, no doc though ✨
  • virtual void push (SoState *state) — push it, push it real good 💅
  • virtual void pop (SoState *state, const SoElement *prevtopelement) — pop off queen 👑
  • void sendDiffuseByIndex (const int index) const — FIXME: write doc. bestie the docs are literally not doc-ing 😭
  • void send (const SoState *state, uint32_t mask) const — FIXME: write doc. the tea is missing 💀
  • void sendVPPacked (SoState *state, const unsigned char *pcolor) — FIXME: write doc. no cap, no doc 🙈
  • void reset (SoState *state, uint32_t bitmask) const — reset and refresh, periodt ✨
  • virtual void setDiffuseElt (SoNode *, int32_t numcolors, const SbColor *colors, SoColorPacker *packer) — set the diffuse element, slay 💙
  • virtual void setPackedElt (SoNode *node, int32_t numcolors, const uint32_t *colors, const SbBool packedtransparency) — packed and thriving 📦✨
  • virtual void setColorIndexElt (SoNode *node, int32_t numindices, const int32_t *indices) — index it, bestie 💅
  • virtual void setTranspElt (SoNode *node, int32_t numtransp, const float *transp, SoColorPacker *packer) — transparency vibes 🌈
  • virtual void setTranspTypeElt (int32_t type) — type it out ✨
  • virtual void setAmbientElt (const SbColor *color) — ambient glow up 💖
  • virtual void setEmissiveElt (const SbColor *color) — emissive and iconic 👑
  • virtual void setSpecularElt (const SbColor *color) — specular sparkle ✨
  • virtual void setShininessElt (float value) — shine bright like a diamond 💎
  • virtual void setColorMaterialElt (SbBool value) — material girl 💅
  • virtual void enableBlendingElt (int sfactor, int dfactor, int alpha_sfactor, int alpha_dfactor) — blend it out 🎨
  • virtual void disableBlendingElt (void) — no blending, no problem 💅
  • virtual void setLightModelElt (SoState *state, int32_t model) — model behavior ✨
  • virtual void setMaterialElt (SoNode *node, uint32_t bitmask, SoColorPacker *packer, const SbColor *diffuse, const int numdiffuse, const float *transp, const int numtransp, const SbColor &ambient, const SbColor &emissive, const SbColor &specular, const float shininess, const SbBool istransparent) — the whole material world 🌍
  • virtual void setVertexOrderingElt (VertexOrdering ordering) — order up 🍟
  • virtual void setBackfaceCullingElt (SbBool onoff) — cull those backfaces, periodt ✂️
  • virtual void setTwosideLightingElt (SbBool onoff) — two-sided lighting, double the fun ✨
  • virtual void setShadeModelElt (SbBool flatshading) — shade model, slay 💅
  • virtual void setAlphaTestElt (int func, float value) — alpha test, bestie 🧪
  • void updateColorVBO (SoVBO *vbo) — update that VBO, vroom vroom 🏎️

💖 Public Member Functions inherited from SoLazyElement 💖

  • virtual SbBool matches (const SoElement *) const — does it match? the vibes say yes 💅
  • virtual SoElement * copyMatchInfo (void) const — copy that match info, periodt ✨
  • int32_t getNumDiffuse (void) const — how many diffuse? no doc, just vibes 😭
  • int32_t getNumTransparencies (void) const — transparency count, bestie 🌈
  • int32_t getNumColorIndices (void) const — color indices go brrr 🎨
  • SbBool isPacked (void) const — packed? yes or no, no cap 📦
  • SbBool isTransparent (void) const — transparent? the tea ☕
  • const uint32_t * getPackedPointer (void) const — pointer to the packed, slay 👑
  • const SbColor * getDiffusePointer (void) const — diffuse pointer, iconic 💅
  • const int32_t * getColorIndexPointer (void) const — index pointer, periodt ✨
  • const float * getTransparencyPointer (void) const — transparency pointer, bestie 🌈

🌸 Public Member Functions inherited from SoElement 🌸

  • const SoType getTypeId (void) const — type ID, the identity 💅
  • int getStackIndex (void) const — stack index, stack it up 📚
  • void setDepth (const int depth) — set the depth, deep 💀
  • int getDepth (void) const — get the depth, how deep is your love 🎶
  • virtual void print (FILE *file=stdout) const — print it, bestie 🖨️
  • virtual ~SoElement () — destructor, bye bye 👋

👑 Static Public Member Functions 👑

  • static SoType getClassTypeId (void) — class type ID, iconic ✨
  • static int getClassStackIndex (void) — class stack index, stack it 📚
  • static void * createInstance (void) — create an instance, main character energy 👑
  • static void initClass () — init the class, slay 💅
  • static void sendAllMaterial (SoState *state) — FIXME: write doc. the docs are ghosting us 😭
  • static void sendNoMaterial (SoState *state) — FIXME: write doc. no material, no doc 💀
  • static void sendOnlyDiffuseColor (SoState *state) — FIXME: write doc. only diffuse, only vibes ✨
  • static void sendLightModel (SoState *state, const int32_t model) — send the light model, periodt 💡
  • static void sendPackedDiffuse (SoState *state, const uint32_t diffuse) — send packed diffuse, 📦
  • static void sendFlatshading (SoState *state, const SbBool onoff) — flatshading, on or off 💅
  • static void sendVertexOrdering (SoState *state, const VertexOrdering ordering) — send vertex ordering, order up 🍟
  • static void sendTwosideLighting (SoState *state, const SbBool onoff) — twoside lighting, double trouble ✨
  • static void sendBackfaceCulling (SoState *state, const SbBool onoff) — backface culling, cull it ✂️
  • static SbBool isColorIndex (SoState *state) — FIXME: write doc. color index? the mystery 🕵️
  • static SoGLLazyElement * getInstance (const SoState *state) — FIXME: write doc. get the instance, bestie 👑
  • static void beginCaching (SoState *state, SoGLLazyElement::GLState *prestate, SoGLLazyElement::GLState *poststate) — begin caching, cache me outside 🧊
  • static void endCaching (SoState *state) — end caching, periodt ✨
  • static SbBool preCacheCall (const SoState *state, const SoGLLazyElement::GLState *prestate) — pre-cache call, early bird 🐦
  • static void postCacheCall (const SoState *state, const SoGLLazyElement::GLState *poststate) — post-cache call, later gator 🐊
  • static void mergeCacheInfo (SoState *state, SoGLLazyElement::GLState *childprestate, SoGLLazyElement::GLState *childpoststate) — merge that cache info, slay 💅

💖 Static Public Member Functions inherited from SoLazyElement 💖

  • static SoType getClassTypeId (void) — class type ID, again 💅
  • static int getClassStackIndex (void) — class stack index, stack it 📚
  • static void * createInstance (void) — create instance, main character ✨
  • static void initClass () — init class, slay 👑
  • static void setToDefault (SoState *state) — set to default, basic but iconic 💅
  • static void setDiffuse (SoState *state, SoNode *node, int32_t numcolors, const SbColor *colors, SoColorPacker *packer) — set diffuse, colorful ✨
  • static void setTransparency (SoState *state, SoNode *node, int32_t numvalues, const float *transparency, SoColorPacker *packer) — set transparency, see-through 💎
  • static void setPacked (SoState *state, SoNode *node, int32_t numcolors, const uint32_t *colors, const SbBool packedtransparency=FALSE) — set packed, 📦
  • static void setColorIndices (SoState *state, SoNode *node, int32_t numindices, const int32_t *indices) — set color indices, index it 🎨
  • static void setAmbient (SoState *state, const SbColor *color) — set ambient, glow up 💖
  • static void setEmissive (SoState *state, const SbColor *color) — set emissive, shine ✨
  • static void setSpecular (SoState *state, const SbColor *color) — set specular, sparkle 💅
  • static void setShininess (SoState *state, float value) — set shininess, bling bling 💎
  • static void setColorMaterial (SoState *state, SbBool value) — set color material, material girl 💅
  • static void enableBlending (SoState *state, int sfactor, int dfactor) — enable blending, mix it up 🎨
  • static void enableSeparateBlending (SoState *state, int sfactor, int dfactor, int alpha_sfactor, int alpha_dfactor) — separate blending, separate vibes ✨
  • static void disableBlending (SoState *state) — disable blending, bye 🚫
  • static void setLightModel (SoState *state, const int32_t model) — set light model, 💡
  • static void setVertexOrdering (SoState *state, VertexOrdering ordering) — set vertex ordering, order up 🍟
  • static void setBackfaceCulling (SoState *state, SbBool onoff) — set backface culling, ✂️
  • static void setTwosideLighting (SoState *state, SbBool onoff) — set twoside lighting, double ✨
  • static void setShadeModel (SoState *state, SbBool flatshading) — set shade model, shade it 💅
  • static void setAlphaTest (SoState *state, int func, float value) — set alpha test, 🧪
  • static const SbColor & getDiffuse (SoState *state, int index) — get diffuse, give it to me 💅
  • static float getTransparency (SoState *, int index) — get transparency, 🌈
  • static const uint32_t * getPackedColors (SoState *) — get packed colors, 📦
  • static const int32_t * getColorIndices (SoState *) — get color indices, 🎨
  • static int32_t getColorIndex (SoState *, int num) — get color index, 🔢
  • static const SbColor & getAmbient (SoState *) — get ambient, 💖
  • static const SbColor & getEmissive (SoState *) — get emissive, ✨
  • static const SbColor & getSpecular (SoState *) — get specular, 💅
  • static float getShininess (SoState *) — get shininess, 💎
  • static SbBool getColorMaterial (SoState *) — get color material, 👑
  • static SbBool getBlending (SoState *, int &sfactor, int &dfactor) — get blending, 🎨
  • static SbBool getAlphaBlending (SoState *, int &sfactor, int &dfactor) — get alpha blending, 🌈
  • static int32_t getLightModel (SoState *) — get light model, 💡
  • static int getAlphaTest (SoState *state, float &value) — get alpha test, 🧪
  • static SbBool getTwoSidedLighting (SoState *state) — get two-sided lighting, ✨
  • static SoLazyElement * getInstance (SoState *state) — get instance, 👑
  • static float getDefaultAmbientIntensity (void) — default ambient intensity, 🌟
  • static SbColor getDefaultDiffuse (void) — default diffuse, 💅
  • static SbColor getDefaultAmbient (void) — default ambient, 💖
  • static SbColor getDefaultSpecular (void) — default specular, ✨
  • static SbColor getDefaultEmissive (void) — default emissive, 🔥
  • static float getDefaultShininess (void) — default shininess, 💎
  • static uint32_t getDefaultPacked (void) — default packed, 📦
  • static float getDefaultTransparency (void) — default transparency, 🌈
  • static int32_t getDefaultLightModel (void) — default light model, 💡
  • static int32_t getDefaultColorIndex (void) — default color index, 🎨
  • static void setMaterials (SoState *state, SoNode *node, uint32_t bitmask, SoColorPacker *cPacker, const SbColor *diffuse, const int numdiffuse, const float *transp, const int numtransp, const SbColor &ambient, const SbColor &emissive, const SbColor &specular, const float shininess, const SbBool istransparent) — set materials, all the things ✨
  • static SoLazyElement * getWInstance (SoState *state) — get W instance, winner 🏆
  • static void setTransparencyType (SoState *state, int32_t type) — set transparency type, 🌈

🌸 Static Public Member Functions inherited from SoElement 🌸

  • static void initClass (void) — init class, again 💅
  • static SoType getClassTypeId (void) — class type ID, encore ✨
  • static int getClassStackIndex (void) — class stack index, stack it 📚
  • static void initElements (void) — init elements, elemental 🧚
  • static int getNumStackIndices (void) — number of stack indices, count it 🔢
  • static SoType getIdFromStackIndex (const int stackIndex) — get ID from stack index, identity 💅

🔒 Protected Member Functions 🔒

  • ~SoGLLazyElement () — destructor, bye bestie 👋
  • virtual void lazyDidSet (uint32_t mask) — lazy did set, slay 💅
  • virtual void lazyDidntSet (uint32_t mask) — lazy didn't set, not today 💀

💖 Protected Member Functions inherited from SoLazyElement 💖

  • ~SoLazyElement () — destructor, peace out ✌️

🌸 Protected Member Functions inherited from SoElement 🌸

  • SoElement (void) — constructor, hey bestie 👋
  • void capture (SoState *const state) const — capture it, 📸
  • virtual void captureThis (SoState *state) const — capture this, 📸
  • void setTypeId (const SoType typeId) — set type ID, identity 💅
  • void setStackIndex (const int index) — set stack index, 📚
  • SoElement * getNextInStack (void) const — get next in stack, next 💅
  • SoElement * getNextFree (void) const — get next free, free bird 🕊️

🦋 Additional Inherited Members 🦋

💖 Public Types inherited from SoLazyElement 💖

enum cases

enum cases { LIGHT_MODEL_CASE = 0, COLOR_MATERIAL_CASE, DIFFUSE_CASE,
    AMBIENT_CASE, EMISSIVE_CASE, SPECULAR_CASE, SHININESS_CASE,
    BLENDING_CASE, TRANSPARENCY_CASE, VERTEXORDERING_CASE, TWOSIDE_CASE,
    CULLING_CASE, SHADE_MODEL_CASE, ALPHATEST_CASE, GLIMAGE_CASE,
    LAZYCASES_LAST }

enum masks

enum masks { LIGHT_MODEL_MASK = 1 << LIGHT_MODEL_CASE,
    COLOR_MATERIAL_MASK = 1 << COLOR_MATERIAL_CASE, DIFFUSE_MASK = 1 <<
    DIFFUSE_CASE, AMBIENT_MASK = 1 << AMBIENT_CASE, EMISSIVE_MASK =
    1<<EMISSIVE_CASE, SPECULAR_MASK = 1 << SPECULAR_CASE, SHININESS_MASK
    = 1 << SHININESS_CASE, TRANSPARENCY_MASK = 1 << TRANSPARENCY_CASE,
    BLENDING_MASK = 1 << BLENDING_CASE, VERTEXORDERING_MASK = 1 <<
    VERTEXORDERING_CASE, TWOSIDE_MASK = 1 << TWOSIDE_CASE, CULLING_MASK
    = 1 << CULLING_CASE, SHADE_MODEL_MASK = 1 << SHADE_MODEL_CASE,
    ALPHATEST_MASK = 1 << ALPHATEST_CASE, GLIMAGE_MASK = 1 <<
    GLIMAGE_CASE, ALL_MASK = (1 << LAZYCASES_LAST)-1 }

enum internalMasks

enum internalMasks { OTHER_COLOR_MASK =
    AMBIENT_MASK|EMISSIVE_MASK|SPECULAR_MASK|SHININESS_MASK,
    ALL_COLOR_MASK = OTHER_COLOR_MASK|DIFFUSE_MASK, NO_COLOR_MASK =
    ALL_MASK & (~ALL_COLOR_MASK), ALL_BUT_DIFFUSE_MASK = ALL_MASK &(~
    DIFFUSE_MASK), DIFFUSE_ONLY_MASK = ALL_MASK &(~ OTHER_COLOR_MASK) }

enum LightModel

enum LightModel { BASE_COLOR, PHONG }

enum VertexOrdering

enum VertexOrdering { CW, CCW }

🌸 Static Protected Member Functions inherited from SoElement 🌸

  • static SoElement * getElement (SoState *const state, const int stackIndex) — get element, elemental 🧚
  • static const SoElement * getConstElement (SoState *const state, const int stackIndex) — get const element, const queen 👑
  • static int createStackIndex (const SoType id) — create stack index, 📚

💖 Protected Attributes inherited from SoLazyElement 💖

  • struct SoLazyElement::CoinState coinstate — coin state, coin it 💰

🌸 Protected Attributes inherited from SoElement 🌸

  • SoType typeId — type ID, identity 💅
  • int stackIndex — stack index, 📚
  • int depth — depth, deep 💀

🌟 Static Protected Attributes inherited from SoElement 🌟

  • static int classStackIndex — class stack index, static vibes ✨
  • static SoTypeList * stackToType — stack to type, mapping it 💅

✨ Detailed Description ✨

okay so bestie, the tea on SoGLLazyElement is that it's literally built to optimize GL rendering. that's its whole thing. its purpose. its moment. 💅

but like... plot twist 🙈 — this one is just a wrap-around implementation for compatibility. it should (hopefully 🫶) work exactly the same way as the Inventor class though. so no cap, same behavior, just wrapped.

🎀 Constructor & Destructor Documentation 🎀

SoGLLazyElement::~SoGLLazyElement () [protected]

the destructor. it destroys. it cleans up. goodbye queen 👑 — and it's protected, so you can't just call it yourself, iykyk.

💖 Member Function Documentation 💖

SoType SoGLLazyElement::getClassTypeId (void ) [static]

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

int SoGLLazyElement::getClassStackIndex (void ) [static]

this static method returns the state stack index for the class. iconic, honestly.

void * SoGLLazyElement::createInstance (void ) [static]

this API member is considered internal to the library, since it is not likely to be of interest to the application programmer. 🔒

it creates a new instance of the class type corresponding to the SoType object.

void SoGLLazyElement::initClass (void ) [static]

initialize relevant common data for all instances, like the type system. gotta set the groundwork before the main character energy kicks in 🌈

void SoGLLazyElement::init (SoState * state) [virtual]

this function initializes the element type in the given SoState. it gets called for the first element of each enabled element type in SoState objects.

Reimplemented from SoLazyElement.

void SoGLLazyElement::push (SoState * state) [virtual]

this method is called every time a new element is required in one of the stacks. that happens when a writable element is requested — using SoState::getElement() or indirectly SoElement::getElement() — and the depth of the current element is less than the state depth.

override this method if your element needs to copy data from the previous top of stack. the push() method is called on the new element, and the previous element can be found using SoElement::getNextInStack().

Reimplemented from SoLazyElement.

void SoGLLazyElement::pop (SoState * state, const SoElement * prevTopElement) [virtual]

this method is called when the state is popped, and the depth of the element is bigger than the current state depth. pop() is called on the new top of stack, and a pointer to the previous top of stack gets passed in as prevTopElement.

override this method if you need to copy some state information from the previous top of stack. 🫶

Reimplemented from SoElement.

void SoGLLazyElement::reset (SoState * stateptr, uint32_t mask) const

reset the element GL state (set state to invalid). use this method to notify this element when you use your own GL code that changes the OpenGL state. basically: if you go messing with GL behind its back, tell it, so it doesn't get confused 😭 fr fr.

void SoGLLazyElement::setDiffuseElt (SoNode * node, int32_t numcolors, const SbColor * colors, SoColorPacker * packer) [virtual]

Reimplemented from SoLazyElement.

void SoGLLazyElement::setPackedElt (SoNode * node, int32_t numcolors, const uint32_t * colors, const SbBool packedtransparency) [virtual]

Reimplemented from SoLazyElement.

void SoGLLazyElement::setColorIndexElt (SoNode * node, int32_t numindices, const int32_t * indices) [virtual]

Reimplemented from SoLazyElement.

void SoGLLazyElement::setTranspElt (SoNode * node, int32_t numtransp, const float * transp, SoColorPacker * packer) [virtual]

Reimplemented from SoLazyElement.

void SoGLLazyElement::setTranspTypeElt (int32_t type) [virtual]

Reimplemented from SoLazyElement.

void SoGLLazyElement::setAmbientElt (const SbColor * color) [virtual]

Reimplemented from SoLazyElement.

void SoGLLazyElement::setEmissiveElt (const SbColor * color) [virtual]

Reimplemented from SoLazyElement.

void SoGLLazyElement::setSpecularElt (const SbColor * color) [virtual]

Reimplemented from SoLazyElement.

void SoGLLazyElement::setShininessElt (float value) [virtual]

Reimplemented from SoLazyElement.

void SoGLLazyElement::setColorMaterialElt (SbBool value) [virtual]

Reimplemented from SoLazyElement.

void SoGLLazyElement::enableBlendingElt (int sfactor, int dfactor, int alpha_sfactor, int alpha_dfactor) [virtual]

Reimplemented from SoLazyElement.

void SoGLLazyElement::disableBlendingElt (void ) [virtual]

Reimplemented from SoLazyElement.

void SoGLLazyElement::setLightModelElt (SoState * state, int32_t model) [virtual]

Reimplemented from SoLazyElement.

void SoGLLazyElement::setMaterialElt (SoNode * node, uint32_t bitmask, SoColorPacker * packer, const SbColor * diffuse, const int numdiffuse, const float * transp, const int numtransp, const SbColor & ambient, const SbColor & emissive, const SbColor & specular, const float shininess, const SbBool istransparent) [virtual]

Reimplemented from SoLazyElement.

void SoGLLazyElement::setVertexOrderingElt (VertexOrdering ordering) [virtual]

Reimplemented from SoLazyElement.

void SoGLLazyElement::setBackfaceCullingElt (SbBool onoff) [virtual]

Reimplemented from SoLazyElement.

void SoGLLazyElement::setTwosideLightingElt (SbBool onoff) [virtual]

Reimplemented from SoLazyElement.

void SoGLLazyElement::setShadeModelElt (SbBool flatshading) [virtual]

Reimplemented from SoLazyElement.

void SoGLLazyElement::setAlphaTestElt (int func, float value) [virtual]

Reimplemented from SoLazyElement.

void SoGLLazyElement::mergeCacheInfo (SoState * state, SoGLLazyElement::GLState * childprestate, SoGLLazyElement::GLState * childpoststate) [static]

merge cache info from a child cache (when doing nested caching) into the current cache. nested caching really said "let me hand you my info" 🤝

void SoGLLazyElement::lazyDidSet (uint32_t mask) [protected], [virtual]

Reimplemented from SoLazyElement.

void SoGLLazyElement::lazyDidntSet (uint32_t mask) [protected], [virtual]

Reimplemented from SoLazyElement.

🌸 Author 🌸

generated automatically by Doxygen for Coin from the source code. not a human typing this out at 3am, just the robot doing its little thing 🤖✨

and that's the whole page bestie, we ate and left no crumbs 💅 this was Coin version 4.0.10, dated Thu Jun 25 2026 00:00:00 — so like, mark your calendars, that's when this SoGLLazyElement(3) moment was frozen in time 🦋 periodt 💖

📦 where this page comes from