SoShadowGroup(3)

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

👑 NAME 👑

okay so bestie, welcome to SoShadowGroup(3) — this is the Coin manpage for SoShadowGroup, and it's the group node you use for shadow rendering. that's the whole vibe. shadow group. group node. shadows. periodt. 💅

🦋 SYNOPSIS 🦋

#include <FXViz/nodes/SoShadowGroup.h>

it Inherits SoSeparator, so everything a separator can do, it can do too — it just also does the shadow thing. main character energy fr. ✨

💖 Public Types 💖

  • enum VisibilityFlag — <cyan>{ ABSOLUTE_RADIUS, LONGEST_BBOX_EDGE_FACTOR, PROJECTED_BBOX_DEPTH_FACTOR }</cyan>

🌸 Public Types inherited from SoSeparator 🌸

  • enum CacheEnabled — <mint>{ OFF, ON, AUTO }</mint>

🌈 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, COIN_4_0 = 0x20000 }

that's a lot of node types and honestly? iconic of them. every single one stays, no cuts. 🎀

✨ Public Member Functions ✨

these are the ones SoShadowGroup brings to the party itself:

  • virtual SoType getTypeId (void) const
  • SoShadowGroup (void) — the constructor, she's simple, she's ready
  • virtual void GLRenderBelowPath (SoGLRenderAction *action)
  • virtual void GLRenderInPath (SoGLRenderAction *action)
  • virtual void notify (SoNotList *nl)
  • void enableSubgraphSearchOnNotify (const SbBool onoff)

💜 Public Member Functions inherited from SoSeparator 💜

  • SoSeparator (void)
  • SoSeparator (const int nchildren)
  • virtual void doAction (SoAction *action)
  • virtual void GLRender (SoGLRenderAction *action)
  • virtual void GLRenderOffPath (SoGLRenderAction *action)
  • virtual void callback (SoCallbackAction *action)
  • virtual void getBoundingBox (SoGetBoundingBoxAction *action)
  • virtual void getMatrix (SoGetMatrixAction *action)
  • virtual void handleEvent (SoHandleEventAction *action)
  • virtual void rayPick (SoRayPickAction *action)
  • virtual void search (SoSearchAction *action)
  • virtual void getPrimitiveCount (SoGetPrimitiveCountAction *action)
  • virtual void audioRender (SoAudioRenderAction *action)
  • virtual SbBool affectsState (void) const

🫶 Public Member Functions inherited from SoGroup 🫶

  • SoGroup (void)
  • SoGroup (int nchildren)
  • virtual void addChild (SoNode *node)
  • virtual void insertChild (SoNode *child, int newchildindex)
  • virtual SoNode * getChild (int index) const
  • virtual int findChild (const SoNode *node) const
  • virtual int getNumChildren (void) const
  • virtual void removeChild (int childindex)
  • virtual void removeChild (SoNode *child)
  • virtual void removeAllChildren (void)
  • virtual void replaceChild (int index, SoNode *newchild)
  • virtual void replaceChild (SoNode *oldchild, SoNode *newchild)
  • virtual void pick (SoPickAction *action)
  • virtual void write (SoWriteAction *action)
  • virtual SoChildList * getChildren (void) const
  • virtual void addWriteReference (SoOutput *out, SbBool isfromfield=FALSE)

⭐ 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 grabEventsSetup (void)
  • virtual void grabEventsCleanup (void)
  • virtual void startNotify (void)
  • SbUniqueId getNodeId (void) const
  • virtual void writeInstance (SoOutput *out)
  • virtual SoNode * addToCopyDict (void) const
  • virtual SoFieldContainer * copyThroughConnection (void) const

🍓 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)
  • 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 🧚

  • 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 — Returns TRUE if the type of this object is either of the same type or inherited from type.
  • 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 🌟

the class-level girlies, no instance required:

  • static SoType getClassTypeId (void)
  • static void initClass (void)
  • static void init (void)
  • static SbBool isSupported (void)

💫 Static Public Member Functions inherited from SoSeparator 💫

  • static SoType getClassTypeId (void)
  • static void initClass (void) — Sets up initialization for data common to all instances of this class, like submitting necessary information to the Coin type system.
  • static void setNumRenderCaches (const int howmany)
  • static int getNumRenderCaches (void)

🎀 Static Public Member Functions inherited from SoGroup 🎀

  • static SoType getClassTypeId (void)
  • static void initClass (void) — Sets up initialization for data common to all instances of this class, like submitting necessary information to the Coin type system.

🔥 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) — Sets up initialization for data common to all instances of this class, like submitting necessary information to the Coin type system.
  • static void initClasses (void)
  • static SbUniqueId 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) — Sets up initialization for data common to all instances of this class, like submitting necessary information to the Coin type system.
  • static SoType getClassTypeId (void) — This static method returns the SoType object associated with objects of this class.
  • 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) — Sets up initialization for data common to all instances of this class, like submitting necessary information to the Coin type system.
  • static SoType getClassTypeId (void) — This static method returns the SoType object associated with objects of this class.
  • 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 fields you actually poke at when you're setting up your shadows:

  • SoSFBool isActive
  • SoSFFloat intensity
  • SoSFFloat precision
  • SoSFFloat quality
  • SoSFFloat smoothBorder
  • SoSFBool shadowCachingEnabled
  • SoSFFloat visibilityNearRadius
  • SoSFFloat visibilityRadius
  • SoSFEnum visibilityFlag
  • SoSFFloat epsilon
  • SoSFFloat threshold

🦋 Public Attributes inherited from SoSeparator 🦋

  • SoSFEnum renderCaching
  • SoSFEnum boundingBoxCaching
  • SoSFEnum renderCulling
  • SoSFEnum pickCulling

🫧 Protected Member Functions 🫧

for the subclasses only, bestie — you can look, but that's their business:

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

🌸 Protected Member Functions inherited from SoSeparator 🌸

  • virtual ~SoSeparator ()
  • virtual SbBool cullTest (SoState *state)
  • virtual SbBool cullTest (SoGLRenderAction *action, int &cullresults)
  • virtual SbBool readInstance (SoInput *in, unsigned short flags)

🌷 Protected Member Functions inherited from SoGroup 🌷

  • virtual ~SoGroup ()
  • virtual SbBool readChildren (SoInput *in)
  • virtual void copyContents (const SoFieldContainer *from, SbBool copyconnections)
  • virtual SoNotRec createNotRec (void)
  • void setOperation (const SoNotRec::OperationType opType=SoNotRec::UNSPECIFIED, const SoNode *cc=NULL, const SoNode *pc=NULL, const int ci=-1)

🧸 Protected Member Functions inherited from SoNode 🧸

  • SoNode (void)
  • virtual ~SoNode ()

💐 Protected Member Functions inherited from SoFieldContainer 💐

  • SoFieldContainer (void)
  • virtual ~SoFieldContainer ()
💖 that's the end of part 1 of 3 — and no, we are NOT done yet, there's so much more where this came from. keep reading bestie, the rest of this page is still coming and it's giving lore. ✨

🎀 Protected Member Functions inherited from SoBase 🎀

These are the lil' behind-the-scenes functions your class gets handed down from SoBase, bestie — you don't call them, they just vibe in the background:

  • SoBase (void) — the base constructor, doing its quiet little setup thing 💅
  • virtual ~SoBase () — the base destructor, virtual so it cleans up properly ✨
  • virtual void destroy (void) — nukes the instance, virtual style
  • SbBool hasMultipleWriteRefs (void) const — checks for multiple write refs, returns an SbBool
  • SbBool writeHeader (SoOutput *out, SbBool isgroup, SbBool isengine) const — writes the header out to the given SoOutput
  • void writeFooter (SoOutput *out) const — writes the footer out, also takes an SoOutput *
  • virtual const char * getFileFormatName (void) const — hands you back the file format name as a const char *

💜 Static Protected Member Functions 💜

  • static const SoFieldData ** getFieldDataPtr (void) — yep, another one of these field-data-pointer getters, static this time

🌸 Static Protected Member Functions inherited from SoSeparator 🌸

  • static const SoFieldData ** getFieldDataPtr (void) — same deal, but it came from SoSeparator 🦋

🌸 Static Protected Member Functions inherited from SoGroup 🌸

  • static const SoFieldData ** getFieldDataPtr (void) — and this one's inherited from SoGroup

🌸 Static Protected Member Functions inherited from SoNode 🌸

  • static const SoFieldData ** getFieldDataPtr (void) — the SoNode version of the field data pointer getter
  • static void setNextActionMethodIndex (int index) — sets the next action method index, takes an int
  • static int getNextActionMethodIndex (void) — returns that next action method index as an int
  • static void incNextActionMethodIndex (void) — bumps the next action method index up by one, iconic
  • static void setCompatibilityTypes (const SoType &nodetype, const uint32_t bitmask) — sets compatibility types from an SoType reference plus a uint32_t bitmask

🌸 Static Protected Member Functions inherited from SoBase 🌸

  • static uint32_t getCurrentWriteCounter (void) — returns the current write counter as a uint32_t
  • static void staticDataLock (void) — locks the static data, no cap 🔒
  • static void staticDataUnlock (void) — and unlocks it again, balance restored 🙌

⭐ Additional Inherited Members ⭐

🫶 Protected Types inherited from SoBase 🫶

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

🫶 Protected Attributes inherited from SoGroup 🫶

  • SoChildList * children — the child list pointer, literally the whole point of a group node

🫶 Protected Attributes inherited from SoNode 🫶

  • SbUniqueId uniqueId — every node's own unique id, main character energy for real

🫶 Protected Attributes inherited from SoFieldContainer 🫶

  • SbBool isBuiltIn — flags whether the thing is built in

🫶 Static Protected Attributes inherited from SoNode 🫶

  • static SbUniqueId nextUniqueId = 1 — the next unique id to hand out, starts at 1
  • static int nextActionMethodIndex = 0 — the next action method index, starts at 0

🌈 Detailed Description 🌈

The SoShadowGroup node is a group node used for shadow rendering. Periodt. 💅

Children of this node can receive shadows, and cast shadows on other children. Use the SoShadowStyle node to control shadow casters and shadow receivers. That's the whole assignment, bestie.

Please note that all shadow casters will be rendered twice. Once to create the shadow map, and once for normal rendering. If you're having performance issues, you should consider reducing the number of shadow casters. 😭

The algorithm used to render the shadows is Variance Shadow Maps (http://www.punkuser.net/vsm/). As an extra bonus, all geometry rendered with shadows can also be rendered with per fragment Phong lighting. It's giving glow-up ✨

This node will search its subgraph and calculate shadows for all SoSpotLight nodes. The node will use one texture unit for each spot light, so for this node to work 100%, you need to have num-spotlights free texture units while rendering the subgraph.

Currently, we only support scenes with maximum two texture units active while doing shadow rendering (unit 0 and unit 1). This is due to the fact that we emulate the OpenGL shading model in a shader program, and we're still working on creating a solution that updates the shader program during the scene graph traversal. Right now a shader program is created when entering the SoShadowGroup node, and this is used for the entire subgraph.

FILE FORMAT/DEFAULTS:

SoShadowGroup {
  isActive TRUE
  intensity 0.5
  precision 0.5
  quality 0.5
  shadowCachingEnabled TRUE
  visibilityRadius -1.0
  visibilityFlag LONGEST_BBOX_EDGE_FACTOR

  epsilon 0.00001
  threshold 0.1
  smoothBorder 0.0

}

Example scene graph:

#Inventor V2.1 ascii

# to get some lighting when headlight is turned off in the viewer
DirectionalLight { direction 0 0 -1 intensity 0.2 }

ShadowGroup {
  quality 1 # to get per pixel lighting

  ShadowStyle { style NO_SHADOWING }

  SpotLight {
    location -8 -8 8.0
    direction 1 1 -1
    cutOffAngle 0.35
    dropOffRate 0.7
  }

  ShadowStyle { style CASTS_SHADOW_AND_SHADOWED }

  Separator {
    Complexity { value 1.0 }
    Material { diffuseColor 1 1 0 specularColor 1 1 1 shininess 0.9 }
    Shuttle { translation0 -3 1 0 translation1 3 -5 0 speed 0.25 on TRUE }
    Translation { translation -5 0 2 }
    Sphere { radius 2.0 }
  }

  Separator {
    Material { diffuseColor 1 0 0 specularColor 1 1 1 shininess 0.9 }
    Shuttle { translation0 0 -5 0 translation1 0 5 0 speed 0.15 on TRUE }
    Translation { translation 0 0 -3 }
    Cube { depth 1.8 }
  }
  Separator {
    Material { diffuseColor 0 1 0 specularColor 1 1 1 shininess 0.9 }
    Shuttle { translation0 -5 0 0 translation1 5 0 0 speed 0.3 on TRUE }
    Translation { translation 0 0 -3 }
    Cube { }
  }

  ShadowStyle { style SHADOWED }
  Coordinate3 { point [ -10 -10 -3, 10 -10 -3, 10 10 -3, -10 10 -3 ] }
  Material { specularColor 1 1 1 shininess 0.9 }

  Complexity { textureQuality 0.1 }
  Texture2 { image 2 2 3 0xffffff 0x225588 0x225588 0xffffff }
  Texture2Transform { scaleFactor 4 4 }
  FaceSet { numVertices 4 }
}

Since

Coin 2.5

🦋 Constructor & Destructor Documentation 🦋

SoShadowGroup::SoShadowGroup (void )

Default constructor. Just your classic "hey I exist now" moment 🫶

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

Destructor. Say bye bestie 👋

👑 Member Function Documentation 👑

SoType SoShadowGroup::getClassTypeId (void ) [static]

This static method returns the SoType object associated with objects of this class. Iconic static behaviour, honestly.

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

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

Reimplemented from SoSeparator.

const SoFieldData ** SoShadowGroup::getFieldDataPtr (void ) [static], [protected]

This API member is considered internal to the library, as it is not likely to be of interest to the application programmer. 🙈 (not me reading the internal stuff anyway)

Returns the SoFieldData class which holds information about fields in this node.

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

void SoShadowGroup::initClass (void ) [static]

(no extra description in the original — it just does its init class thing, slay)

SbBool SoShadowGroup::isSupported (void ) [static]

Reports whether or not the shadow nodes can be used successfully on the current system. 🕵️♀️

The result will depend on the specific qualities of the graphics card and OpenGL driver on the system.

An important note about this function:

The API design of this function has a serious shortcoming, as features of OpenGL should be tested within an OpenGL context, and this function does not provide any means of specifying the context. It is implemented in this manner to match the function signature in TGS Inventor, for compatibility reasons.

(A temporary offscreen OpenGL context is set up for the feature tests. This should usually be sufficient to decide whether or not the graphics driver / card supports the features needed for rendering shadows.)

Since

Coin 3.1

void SoShadowGroup::GLRenderBelowPath (SoGLRenderAction * action) [virtual]

SGI Open Inventor v2.1 obsoleted support for SoGLRenderAction::addMethod(). Instead, GLRender() might be called directly, and to optimize traversal, the SoSeparator node calls GLRenderBelowPath whenever the path code is BELOW_PATH or NO_PATH (path code is guaranteed not to change). To be compatible with SGI's Inventor (and thereby also TGS') we have chosen to follow their implementation in this respect.

SoSeparator::GLRenderBelowPath() does not traverse its children using SoChildList::traverse(), but calls GLRenderBelowPath() directly for all its children.

Reimplemented from SoSeparator.

void SoShadowGroup::GLRenderInPath (SoGLRenderAction * action) [virtual]

Implements the SoAction::IN_PATH traversal method for the rendering action.

Reimplemented from SoSeparator.

void SoShadowGroup::notify (SoNotList * l) [virtual]

Notifies all auditors for this instance when changes are made. Gossip network, but make it scene graph 📣

Reimplemented from SoSeparator.

void SoShadowGroup::enableSubgraphSearchOnNotify (const SbBool onoff)

By default, the SoShadowGroup node will search its subgraph for new spot lights whenever a group node under it is touched. However, this might lead to bad performance in some cases so it is possible to disable this feature using this method. If you do disable this feature, make sure you enable it again before inserting a new spot light, or insert all spot lights in the scene graph before you render the scene once, and just set "on" to FALSE if you want to toggle spot lights on/off on the fly.

Heads up bestie — if you turn this off, you gotta turn it back on before you add a new spot light, or just add all your spot lights up front and render once. Don't say I didn't warn you 💀

Since

Coin 2.6

🌈 Member Data Documentation 🌈

okay bestie, this is the part where we go field by field, one by one, no skipping, because every single one of these matters and I am NOT about to let you skim. 💅

✨ SoSFBool SoShadowGroup::isActive

the on/off switch, the vibe check of the whole shadow operation. flip this to control whether shadow rendering happens for the subgraph. Default value is TRUE. so yes, by default, shadows are ON, we are shadowing, we are thriving. 🦋

✨ SoSFFloat SoShadowGroup::intensity

Not used yet. Provided for TGS Inventor compatibility. that's it, that's the whole field, it's just sitting there looking pretty for compatibility reasons. 💀

✨ SoSFFloat SoShadowGroup::precision

this one is for calculating the size of the shadow map. A precision of 1.0 means the maximum shadow buffer size will be used (typically 2048x2048 on current graphics cards). Default value is 0.5. so crank it if you want the big fancy maps, but note the default is giving "balanced, sensible, lowkey chill". 🌸

✨ SoSFFloat SoShadowGroup::quality

use this to tune the shader program complexity. A higher value will mean that more calculations are done per fragment instead of per vertex. Default value is 0.5. basically: higher = more math per fragment, more per-fragment work, more glow. ✨

✨ SoSFFloat SoShadowGroup::smoothBorder

okay so this one has a whole lil nested situation going on, because the VisibilityFlag values got documented inside it, so let's do the flags first and then come back, exactly like the page does:

  • SoShadowGroup::VisibilityFlag SoShadowGroup::ABSOLUTE_RADIUS — the absolute values of visibilityNearRadius and visibilityRadius will be used. straight up, take the numbers literally. 💯
  • SoShadowGroup::VisibilityFlag SoShadowGroup::LONGEST_BBOX_EDGE_FACTOR — the longest bounding box edge will be used to determine near and far clipping planes. 📐
  • SoShadowGroup::VisibilityFlag SoShadowGroup::PROJECTED_BBOX_DEPTH_FACTOR — the bounding box depth (projected to face the camera) will be used to calculate the clipping planes.
We have some problems with this feature so it's not supported at the moment. 🚨

and NOW, back to smoothBorder proper:

it's used to add shadow border smoothing. This is currently done as a post processing step on the shadow map. The algorithm used is Gauss Smoothing, but in the future we'll probably change this, and use a summed area sampling method instead. The value should be a number between 0 (no smoothing), and 1 (max smoothing).

If you want to enable smoothing, choosing a low value (~0.1) works best in the current implementation. bestie listen to this, do NOT max it out, 0.1 is the moment. 🙈

Default value is 0.0. so by default, no smoothing, we're rawdogging those shadow edges. 😭

✨ SoSFBool SoShadowGroup::shadowCachingEnabled

Not used yet. Provided for TGS Inventor compatibility. same energy as intensity, it's just here for the compatibility vibes. 👑

✨ SoSFFloat SoShadowGroup::visibilityNearRadius

can be used to manually set the near clipping plane of the shadow maps. If a negative value is provided, the group will calculate a near plane based on the bounding box of the children. Default value is -1.0.

See also: visibilityFlag

✨ SoSFFloat SoShadowGroup::visibilityRadius

can be used to manually set the far clipping plane of the shadow maps. If a negative value is provided, the group will calculate a near plane based on the bounding box of the children. Default value is -1.0.

See also: visibilityFlag

✨ SoSFEnum SoShadowGroup::visibilityFlag

this one determines how visibilityRadius and visibilitNearRadius are used to calculate near and far clipping planes for the shadow volume. yes, the page really does spell it visibilitNearRadius there, and yes I am leaving it exactly as it is because the one rule is: keep every detail. 🤝

✨ SoSFFloat SoShadowGroup::epsilon

epsilon is used to offset the shadow map depth from the model depth. Should be set to as low a number as possible without causing flickering in the shadows or on non-shadowed objects. Default value is 0.00001. tiny number, big responsibility, main character energy fr fr. 🎀

✨ SoSFFloat SoShadowGroup::threshold

can be used to avoid light bleeding in merged shadows cast from different objects.

A threshold to completely eliminate all light bleeding can be computed from the ratio of overlapping occluder distances from the light's perspective. See http://forum.beyond3d.com/showthread.php?t=38165 for a discussion about this problem. iykyk. 🔥

🫶 Author 🫶

Generated automatically by Doxygen for Coin from the source code. not a human, just a little robot doing its best, and honestly? it ate. 💖

and that's the whole page, bestie, you made it all the way to the end. this was Version 4.0.10, dated Thu Jun 25 2026 00:00:00, and yes it's SoShadowGroup(3) in case you forgot which manual you were living in. go forth and render some absolutely iconic shadows. slay 💅✨🌈

📦 where this page comes from