SoVRMLBackground(3)

📦 version 2.5.0, in fedora 43, fedora 44

💖 SoVRMLBackground 💖

okay bestie, listen up, because SoVRMLBackground(3) is about to be your new fave. this is the class that handles specifying a viewer panorama, and honestly? it's giving main character energy. let's get into it. 🌸

✨ NAME ✨

SoVRMLBackground — the class you use for specifying a viewer panorama. that's the whole gig. that's what she does. 💅

🦋 SYNOPSIS 🦋

start by pulling her in, no cap:

#include <Inventor/VRMLnodes/SoVRMLBackground.h>

Inherits SoNode. so like, everything SoNode can do? she can do too. nepo baby behavior but make it useful. 👑

🌟 Public Member Functions 🌟

these are the ones she owns herself, her own little signature moves:

virtual SoType getTypeId (void) const — the type-id getter, virtual so it plays nice with the whole inheritance situation.
SoVRMLBackground (void) — the constructor. she's here, she's built, she's ready. ✨
virtual void GLRender (SoGLRenderAction *action) — the actual render moment, where she does her thing with the SoGLRenderAction.

🎀 Public Member Functions inherited from `SoNode` 🎀

bestie these come free with the SoNode DNA, obsessed:

void setOverride (const SbBool state)
SbBool isOverride (void) const
void setNodeType (const NodeType type)
NodeType getNodeType (void) const
virtual SoNode * copy (SbBool copyconnections=0) const
virtual SbBool affectsState (void) const
virtual void doAction (SoAction *action)
virtual void GLRenderBelowPath (SoGLRenderAction *action)
virtual void GLRenderInPath (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 pick (SoPickAction *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

that's a whole lot of inherited slay, and yes, every single one of them is staying. no cuts, no skips. 💜

💫 Public Member Functions inherited from `SoFieldContainer` 💫

the field-container side of the family, she's fancy:

void setToDefaults (void)
SbBool hasDefaultValues (void) const
SbBool fieldsAreEqual (const SoFieldContainer *container) const
void copyFieldValues (const SoFieldContainer *container, SbBool copyconnections=0)
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 *in)
void get (SbString &fielddata, SoOutput *out)
virtual SbBool validateNewFieldValue (SoField *field, void *newval)
virtual void addWriteReference (SoOutput *out, SbBool isfromfield=0)
SbBool getIsBuiltIn (void) const
void setUserData (void *userdata) const
void * getUserData (void) const

🌈 Public Member Functions inherited from `SoBase` 🌈

and the OGs, the base-est of the base class behavior:

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 ⭐

the class-level girls, no instance required:

static SoType getClassTypeId (void) — the class type id, static style.
static void initClass (void) — the init hook, call her when you're setting things up.

✨ 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 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 *in, SoBase *&base, SoType expectedtype)
static void setInstancePrefix (const SbString &c)
static void setTraceRefs (SbBool trace)
static SbBool getTraceRefs (void)
static SbBool connectRoute (SoInput *in, const SbName &fromnodename, const SbName &fromfieldname, const SbName &tonodename, const SbName &tofieldname)
static SbBool readRoute (SoInput *in)

🍓 Public Attributes 🍓

these are the actual fields, the little knobs she exposes to the world, and bestie there are a LOT:

SoMFColor groundColor
SoMFFloat groundAngle
SoMFColor skyColor
SoMFFloat skyAngle
SoMFString backUrl
SoMFString bottomUrl
SoMFString frontUrl
SoMFString leftUrl
SoMFString rightUrl
SoMFString topUrl

all the directions, all the colors, all the angles. she's thorough. 💅

🧚 Protected Member Functions 🧚

the ones only she and her subclasses get to touch:

virtual const SoFieldData * getFieldData (void) const
virtual ~SoVRMLBackground () — the destructor, protected, as she deserves.

🌸 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)
~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)

🦋 Protected Attributes 🦋

SoSFBool set_bind
SoSFBool isBound

🦋 Protected Attributes inherited from `SoNode` 🦋

uint32_t uniqueId

🦋 Protected Attributes inherited from `SoFieldContainer` 🦋

SbBool isBuiltIn

👑 Additional Inherited Members 👑

more freebies from the family tree, no cap:

Public Types inherited from `SoNode`

the big enum energy:

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
}

Protected Types inherited from `SoBase`

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

Static Protected Attributes inherited from `SoNode`

static uint32_t nextUniqueId = 0
static int nextActionMethodIndex = 0

and that's only part 1 bestie, don't go anywhere, there's more coming and you're gonna want to see it 👀💖

💖 Detailed Description 💖

so like… the SoVRMLBackground class is literally the thing that gives your viewer a whole panorama. that's its job. that's the vibe. 🦋

the full class documentation is taken verbatim from the VRML97 standard (ISO/IEC 14772-1:1997). it's copyright The Web3D Consortium, and it's used by permission of the Consortium. so we're being polite about it, bestie 💅

Background {
  eventIn      SFBool   set_bind
  exposedField MFFloat  groundAngle  []         # [0,pi/2]
  exposedField MFColor  groundColor  []         # [0,1]
  exposedField MFString backUrl      []
  exposedField MFString bottomUrl    []
  exposedField MFString frontUrl     []
  exposedField MFString leftUrl      []
  exposedField MFString rightUrl     []
  exposedField MFString topUrl       []
  exposedField MFFloat  skyAngle     []         # [0,pi]
  exposedField MFColor  skyColor     0 0 0      # [0,1]
  eventOut     SFBool   isBound
}

okay so the Background node is used to specify a colour backdrop that simulates ground and sky, AND a background texture (aka a panorama) that's placed behind all the geometry in the scene and in front of the ground and sky. it's giving layers. ✨

Background nodes are specified in the local coordinate system and they're affected by the accumulated rotation of their ancestors as described below. Background nodes are bindable nodes, as described in 4.6.10, Bindable children nodes (http://www.web3d.org/x3d/specifications/vrml/ISO-IEC-14772-VRML97/part1/concepts.html#4.6.10). there's a Background stack, and the top-most Background on the stack is the currently active Background. to move a Background to the top of the stack, you send a TRUE value to the set_bind eventIn. once it's active, the Background is then bound to the browser's view. a FALSE value sent to set_bind removes the Background from the stack and unbinds it from the browser's view. more detail on the bind stack lives in 4.6.10, Bindable children nodes (http://www.web3d.org/x3d/specifications/vrml/ISO-IEC-14772-VRML97/part1/concepts.html#4.6.10).

the backdrop is conceptually a partial sphere (the ground) enclosed inside of a full sphere (the sky) in the local coordinate system, with the viewer placed at the centre of the spheres. both spheres have infinite radius, and each one is painted with concentric circles of interpolated colour perpendicular to the local Y-axis of the sphere. 🎨

the Background node is subject to the accumulated rotations of its ancestors' transformations. Scaling and translation transformations are ignored. the sky sphere is always slightly farther away from the viewer than the ground partial sphere, which is why the ground appears in front of the sky where they overlap. iconic behaviour honestly 👑

the skyColor field specifies the colour of the sky at various angles on the sky sphere. the first value of the skyColor field specifies the colour of the sky at 0.0 radians, representing the zenith (i.e., straight up from the viewer). the skyAngle field specifies the angles from the zenith in which concentric circles of colour appear. the zenith of the sphere is implicitly defined to be 0.0 radians, the natural horizon is at pi/2 radians, and the nadir (i.e., straight down from the viewer) is at pi radians. skyAngle is restricted to non-decreasing values in the range [0.0, pi]. there shall be one more skyColor value than there are skyAngle values. the first colour value is the colour at the zenith, which is not specified in the skyAngle field. if the last skyAngle is less than pi, then the colour band between the last skyAngle and the nadir is clamped to the last skyColor. the sky colour is linearly interpolated between the specified skyColor values.

the groundColor field specifies the colour of the ground at the various angles on the ground partial sphere. the first value of the groundColor field specifies the colour of the ground at 0.0 radians, representing the nadir (i.e., straight down from the user). the groundAngle field specifies the angles from the nadir that the concentric circles of colour appear. the nadir of the sphere is implicitly defined at 0.0 radians. groundAngle is restricted to non-decreasing values in the range [0.0, pi/2]. there shall be one more groundColor value than there are groundAngle values. the first colour value is for the nadir, which is not specified in the groundAngle field. if the last groundAngle is less than pi/2, the region between the last groundAngle and the equator is non-existant. the ground colour is linearly interpolated between the specified groundColor values.

the backUrl, bottomUrl, frontUrl, leftUrl, rightUrl, and topUrl fields specify a set of images that define a background panorama between the ground/sky backdrop and the scene's geometry. 🖼️ the panorama consists of six images, each of which is mapped onto a face of an infinitely large cube contained within the backdrop spheres and centred in the local coordinate system. the images are applied individually to each face of the cube.

on the front, back, right, and left faces of the cube, when viewed from the origin looking down the negative Z-axis with the Y-axis as the view up direction, each image is mapped onto the corresponding face with the same orientation as if the image were displayed normally in 2D (backUrl to back face, frontUrl to front face, leftUrl to left face, and rightUrl to right face).

on the top face of the cube, when viewed from the origin looking along the +Y-axis with the +Z-axis as the view up direction, the topUrl image is mapped onto the face with the same orientation as if the image were displayed normally in 2D.

on the bottom face of the box, when viewed from the origin along the negative Y-axis with the negative Z-axis as the view up direction, the bottomUrl image is mapped onto the face with the same orientation as if the image were displayed normally in 2D.

Figure 6.1

Figure 6.1 illustrates the Background node backdrop and background textures.

alpha values in the panorama images (i.e., two or four component images) specify that the panorama is semi-transparent or transparent in regions, allowing the groundColor and skyColor to be visible. see 4.6.11, Texture maps, for a general description of texture maps. often, the bottomUrl and topUrl images will not be specified, to allow sky and ground to show. the other four images may depict surrounding mountains or other distant scenery. 🏔️

browsers shall support the JPEG (see 2.[JPEG]) and PNG (see 2.[PNG]) image file formats, and in addition, may support any other image format (e.g., CGM) that can be rendered into a 2D image. support for the GIF (see E.[GIF]) format is recommended (including transparency). more detail on the url fields can be found in 4.5, VRML and the World Wide Web (http://www.web3d.org/x3d/specifications/vrml/ISO-IEC-14772-VRML97/part1/concepts.html#4.5).

🎀 Constructor & Destructor Documentation 🎀

`SoVRMLBackground::SoVRMLBackground (void )`

Constructor. that's the whole thing. it constructs. 💖

References SoVRMLBackground().

Referenced by getClassTypeId(), and SoVRMLBackground().

`SoVRMLBackground::~SoVRMLBackground ()` — `[protected]`, `[virtual]`

Destructor. bye bestie 🦋

✨ Member Function Documentation ✨

`SoType SoVRMLBackground::getClassTypeId (void )` — `[static]`

and underneath that one, the class's fields, all listed out with their little descriptions:

SoMFFloat SoVRMLBackground::groundAngle — the ground angles where different colors should be used.
SoMFColor SoVRMLBackground::groundColor — the color for each groundAngle.
SoMFFloat SoVRMLBackground::skyAngle — the sky angles where different colors should be used.
SoMFColor SoVRMLBackground::skyColor — the color for each skyAngle.
SoMFString SoVRMLBackground::backUrl — URL for the background image.
SoMFString SoVRMLBackground::bottomUrl — URL for the bottom image.
SoMFString SoVRMLBackground::frontUrl — URL for the front image.
SoMFString SoVRMLBackground::leftUrl — URL for the left image.
SoMFString SoVRMLBackground::rightUrl — URL for the right image.
SoMFString SoVRMLBackground::topUrl — URL for the top image.
SoSFBool SoVRMLBackground::set_bind — an eventIn which is triggered when the node is bound.
SoSFBool SoVRMLBackground::isBound — an eventOut that is sent after the node has been bound/unbound.

References SoVRMLBackground().

`SoType SoVRMLBackground::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. no cap, that's the whole point of it 🔥

usage example, and yes you're gonna read every line of it:

void foo(SoNode * node)
{
  if (node->getTypeId() == SoFile::getClassTypeId()) {
    SoFile * filenode = (SoFile *)node;  // safe downward cast, knows the type
  }
  else if (node->getTypeId().isOfType(SoGroup::getClassTypeId())) {
    SoGroup * group = (SoGroup *)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 * SoVRMLBackground::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 SoVRMLBackground::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, override this method. 💅

Reimplemented from SoNode.

References SoAction::getPathCode(), SoAction::getState(), SbRotation::inverse(), SoState::pop(), and SoState::push().

🌸 Author 🌸

Generated automatically by Doxygen for Coin from the source code.

that's the whole page bestie, you made it to the end, so proud 🫶 this was the Coin documentation, Version 2.5.0, page SoVRMLBackground(3) — go forth and render your panorama ✨🌈👑

📦 where this page comes from

fedora 43: Coin2-devel 2.5.0-52.fc43 · GPL-2.0-only
fedora 43: Coin2-devel 2.5.0-52.fc43 · GPL-2.0-only
fedora 44: Coin2-devel 2.5.0-54.fc44 · GPL-2.0-only
fedora 44: Coin2-devel 2.5.0-54.fc44 · GPL-2.0-only
💖 girlified by deepseek-ai/DeepSeek-V4.1-Flash on 2026-10-14: a language model's rewrite of the original, under its terms

SoVRMLBackground(3)