---
name: "SoLazyElement"
section: "3"
platform: "linux"
package: "coin"
version: "1:4.0.10-1"
release: "Arch Linux 2026-11-01"
platforms: ["linux"]
url: "https://new.carta.tech/SoLazyElement"
---

# SoLazyElement(3)

The SoLazyElement class is used to handle material and shape properties.

## NAME

SoLazyElement - The **SoLazyElement** class is used to handle material and shape properties.

## SYNOPSIS

\#include \<Inventor/elements/SoLazyElement.h\>

Inherits **SoElement**.

Inherited by **SoGLLazyElement**.

### Classes

struct **CoinState**\

### Public Types

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** { **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** { **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** { **BASE\_COLOR**, **PHONG** }\
 enum **VertexOrdering** { **CW**, **CCW** }\

### Public Member Functions

virtual void **init** (**SoState** \*state)\
 virtual void **push** (**SoState** \*state)\
 virtual SbBool **matches** (const **SoElement** \*) const\
 virtual **SoElement** \* **copyMatchInfo** (void) const\
 int32\_t **getNumDiffuse** (void) const\
 int32\_t **getNumTransparencies** (void) const\
 int32\_t **getNumColorIndices** (void) const\
 SbBool **isPacked** (void) const\
 SbBool **isTransparent** (void) const\
 const uint32\_t \* **getPackedPointer** (void) const\
 const **SbColor** \* **getDiffusePointer** (void) const\
 const int32\_t \* **getColorIndexPointer** (void) const\
 const float \* **getTransparencyPointer** (void) const\

Public Member Functions inherited from **SoElement** const **SoType** **getTypeId** (void) const\
 int **getStackIndex** (void) const\
 virtual void **pop** (**SoState** \*state, const **SoElement** \*prevTopElement)\
 void **setDepth** (const int **depth**)\
 int **getDepth** (void) const\
 virtual void **print** (FILE \*file=stdout) const\
 virtual **~SoElement** ()\

### Static Public Member Functions

static **SoType** **getClassTypeId** (void)\
 static int **getClassStackIndex** (void)\
 static void \* **createInstance** (void)\
 static void **initClass** ()\
 static void **setToDefault** (**SoState** \*state)\
 static void **setDiffuse** (**SoState** \*state, **SoNode** \*node, int32\_t numcolors, const **SbColor** \*colors, **SoColorPacker** \*packer)\
 static void **setTransparency** (**SoState** \*state, **SoNode** \*node, int32\_t numvalues, const float \*transparency, **SoColorPacker** \*packer)\
 static void **setPacked** (**SoState** \*state, **SoNode** \*node, int32\_t numcolors, const uint32\_t \*colors, const SbBool packedtransparency=FALSE)\
 static void **setColorIndices** (**SoState** \*state, **SoNode** \*node, int32\_t numindices, const int32\_t \*indices)\
 static void **setAmbient** (**SoState** \*state, const **SbColor** \*color)\
 static void **setEmissive** (**SoState** \*state, const **SbColor** \*color)\
 static void **setSpecular** (**SoState** \*state, const **SbColor** \*color)\
 static void **setShininess** (**SoState** \*state, float value)\
 static void **setColorMaterial** (**SoState** \*state, SbBool value)\
 static void **enableBlending** (**SoState** \*state, int sfactor, int dfactor)\
 static void **enableSeparateBlending** (**SoState** \*state, int sfactor, int dfactor, int alpha\_sfactor, int alpha\_dfactor)\
 static void **disableBlending** (**SoState** \*state)\
 static void **setLightModel** (**SoState** \*state, const int32\_t model)\
 static void **setVertexOrdering** (**SoState** \*state, VertexOrdering ordering)\
 static void **setBackfaceCulling** (**SoState** \*state, SbBool onoff)\
 static void **setTwosideLighting** (**SoState** \*state, SbBool onoff)\
 static void **setShadeModel** (**SoState** \*state, SbBool flatshading)\
 static void **setAlphaTest** (**SoState** \*state, int func, float value)\
 static const **SbColor** & **getDiffuse** (**SoState** \*state, int index)\
 static float **getTransparency** (**SoState** \*, int index)\
 static const uint32\_t \* **getPackedColors** (**SoState** \*)\
 static const int32\_t \* **getColorIndices** (**SoState** \*)\
 static int32\_t **getColorIndex** (**SoState** \*, int num)\
 static const **SbColor** & **getAmbient** (**SoState** \*)\
 static const **SbColor** & **getEmissive** (**SoState** \*)\
 static const **SbColor** & **getSpecular** (**SoState** \*)\
 static float **getShininess** (**SoState** \*)\
 static SbBool **getColorMaterial** (**SoState** \*)\
 static SbBool **getBlending** (**SoState** \*, int &sfactor, int &dfactor)\
 static SbBool **getAlphaBlending** (**SoState** \*, int &sfactor, int &dfactor)\
 static int32\_t **getLightModel** (**SoState** \*)\
 static int **getAlphaTest** (**SoState** \*state, float &value)\
 static SbBool **getTwoSidedLighting** (**SoState** \*state)\
 static **SoLazyElement** \* **getInstance** (**SoState** \*state)\
 static float **getDefaultAmbientIntensity** (void)\
 static **SbColor** **getDefaultDiffuse** (void)\
 static **SbColor** **getDefaultAmbient** (void)\
 static **SbColor** **getDefaultSpecular** (void)\
 static **SbColor** **getDefaultEmissive** (void)\
 static float **getDefaultShininess** (void)\
 static uint32\_t **getDefaultPacked** (void)\
 static float **getDefaultTransparency** (void)\
 static int32\_t **getDefaultLightModel** (void)\
 static int32\_t **getDefaultColorIndex** (void)\
 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)\
 static **SoLazyElement** \* **getWInstance** (**SoState** \*state)\
 static void **setTransparencyType** (**SoState** \*state, int32\_t type)\

Static Public Member Functions inherited from **SoElement** static void **initClass** (void)\
 static **SoType** **getClassTypeId** (void)\
 static int **getClassStackIndex** (void)\
 static void **initElements** (void)\
 static int **getNumStackIndices** (void)\
 static **SoType** **getIdFromStackIndex** (const int **stackIndex**)\

### Protected Member Functions

**~SoLazyElement** ()\
 virtual void **lazyDidSet** (uint32\_t mask)\
 virtual void **lazyDidntSet** (uint32\_t mask)\
 virtual void **setDiffuseElt** (**SoNode** \*, int32\_t numcolors, const **SbColor** \*colors, **SoColorPacker** \*packer)\
 virtual void **setPackedElt** (**SoNode** \*node, int32\_t numcolors, const uint32\_t \*colors, const SbBool packedtransparency)\
 virtual void **setColorIndexElt** (**SoNode** \*node, int32\_t numindices, const int32\_t \*indices)\
 virtual void **setTranspElt** (**SoNode** \*node, int32\_t numtransp, const float \*transp, **SoColorPacker** \*packer)\
 virtual void **setTranspTypeElt** (int32\_t type)\
 virtual void **setAmbientElt** (const **SbColor** \*color)\
 virtual void **setEmissiveElt** (const **SbColor** \*color)\
 virtual void **setSpecularElt** (const **SbColor** \*color)\
 virtual void **setShininessElt** (float value)\
 virtual void **setColorMaterialElt** (SbBool value)\
 virtual void **enableBlendingElt** (int sfactor, int dfactor, int alpha\_sfactor, int alpha\_dfactor)\
 virtual void **disableBlendingElt** (void)\
 virtual void **setLightModelElt** (**SoState** \*state, int32\_t model)\
 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)\
 virtual void **setVertexOrderingElt** (VertexOrdering ordering)\
 virtual void **setBackfaceCullingElt** (SbBool onoff)\
 virtual void **setTwosideLightingElt** (SbBool onoff)\
 virtual void **setShadeModelElt** (SbBool flatshading)\
 virtual void **setAlphaTestElt** (int func, float value)\

Protected Member Functions inherited from **SoElement** **SoElement** (void)\
 void **capture** (**SoState** \*const state) const\
 virtual void **captureThis** (**SoState** \*state) const\
 void **setTypeId** (const **SoType** **typeId**)\
 void **setStackIndex** (const int index)\
 **SoElement** \* **getNextInStack** (void) const\
 **SoElement** \* **getNextFree** (void) const\

### Protected Attributes

struct **SoLazyElement::CoinState** **coinstate**\

Protected Attributes inherited from **SoElement** **SoType** **typeId**\
 int **stackIndex**\
 int **depth**\

### Additional Inherited Members

Static Protected Member Functions inherited from **SoElement** static **SoElement** \* **getElement** (**SoState** \*const state, const int **stackIndex**)\
 static const **SoElement** \* **getConstElement** (**SoState** \*const state, const int **stackIndex**)\
 static int **createStackIndex** (const **SoType** id)\

Static Protected Attributes inherited from **SoElement** static int **classStackIndex**\
 static **SoTypeList** \* **stackToType**\

## Detailed Description

The **SoLazyElement** class is used to handle material and shape properties.

So\[GL\]LazyElement is, as the name implies, an element that is lazy about sending things to OpenGL. The changes are not sent to OpenGL until **SoGLLazyElement::send()** is called. This means that you can change the state of certain attributes several times, but the state will only be sent to OpenGL once.

When creating a new shape node in Coin, it's a common operation to modify the OpenGL diffuse color. There are several ways you can send the color to OpenGL. If you're not going to use the color outside your node, you can just as well send it using plain OpenGL. You can also set the color in the element, and then force a send by using SoGLLazyElement::send(state, SoLazyElement::DIFFUSE\_MASK).

However, when creating an extension shape node, it's always recommended to create an instance of **SoMaterialBundle** on the stack. If this instance is created after you update **SoLazyElement** with a new color, the new color will be sent to OpenGL when you call **SoMaterialBundle::sendFirst()**. This call will also update all other lazy OpenGL state, and it is actually required to either use **SoMaterialBundle::sendFirst()** or call SoGLLazyElement::send(state, SoLazyElement::ALL\_MASK) when creating a shape node.

If you decide to send the color to OpenGL using glColor\*(), you should notify **SoGLLazyElement** about this by calling SoGLLazyElement::reset(state, SoLazyElement::DIFFUSE\_MASK). This will notify **SoGLLazyElement** that the current OpenGL diffuse color is unknown.

## Constructor & Destructor Documentation

### SoLazyElement::~SoLazyElement () \[protected\]

Destructor.

## Member Function Documentation

### SoType SoLazyElement::getClassTypeId (void ) \[static\]

This static method returns the **SoType** object associated with objects of this class.

### int SoLazyElement::getClassStackIndex (void ) \[static\]

This static method returns the state stack index for the class.

### void \* SoLazyElement::createInstance (void ) \[static\]

*This API member is considered internal to the library, as it is not likely to be of interest to the application programmer.*\

 Creates a new instance of the class type corresponding to the **SoType** object.

### void SoLazyElement::initClass (void ) \[static\]

Initialize relevant common data for all instances, like the type system.

### void SoLazyElement::init (SoState \* state) \[virtual\]

This function initializes the element type in the given **SoState**. It is called for the first element of each enabled element type in **SoState** objects.

Reimplemented from **SoElement**.

Reimplemented in **SoGLLazyElement**.

### void SoLazyElement::push (SoState \* state) \[virtual\]

This method is called every time a new element is required in one of the stacks. This 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 **SoElement**.

Reimplemented in **SoGLLazyElement**.

### SbBool SoLazyElement::matches (const SoElement \* element) const \[virtual\]

Will always return TRUE in Coin.

Implements **SoElement**.

### SoElement \* SoLazyElement::copyMatchInfo (void ) const \[virtual\]

Just returns NULL in Coin.

Implements **SoElement**.

### void SoLazyElement::setToDefault (SoState \* state) \[static\]

Internal function used for resetting the OpenGL state before FBO rendering.

## Author

Generated automatically by Doxygen for Coin from the source code.