Coin Logo http://www.sim.no/
http://www.coin3d.org/

Class List
Here are the classes, structs, unions and interfaces with brief descriptions:
oCcc_stringThe cc_string type is a C ADT for ASCII string management.This is a Coin extension
oCSbBarrierImplements the "barrier" multi-thread synchronization technique.A barrier is a synchronization mechanism that is used for blocking threads as they enter the barrier until a given number of threads are blocked, at which point all the threads are released again
oCSbBox2d2 dimensional box with double precision corner coordinates.This box class is used by many other classes in Coin for data exchange and storage. It provides two box corners with double precision coordinates, which is among other things useful for representing screen or canvas dimensions in normalized coordinates
oCSbBox2f2 dimensional box with floating point corner coordinates.This box class is used by many other classes in Coin for data exchange and storage. It provides two box corners with floating point coordinates, which is among other things useful for representing screen or canvas dimensions in normalized coordinates
oCSbBox2s2 dimensional box with short integer coordinates.This box class is used by other classes in Coin for data exchange. It provides storage for two box corners with short integer coordinates, which is among other things useful for representing screen or canvas areas in absolute window coordinates
oCSbBox3dAbstraction for an axis aligned 3 dimensional box.This box abstraction class is used by other entities in the Coin library for data exchange and storage. It provides a representation of the defining corners of a box in 3D space, with the sides aligned with the 3 principal axes
oCSbBox3fAbstraction for an axis aligned 3 dimensional box.This box abstraction class is used by other entities in the Coin library for data exchange and storage. It provides a representation of the defining corners of a box in 3D space, with the sides aligned with the 3 principal axes
oCSbBox3s3 dimensional box with short integer coordinates.This box class is used by other classes in Coin for data exchange. It provides storage for two box corners with short integer coordinates, which is among other things useful for representing screen or canvas areas in absolute window coordinates
oCSbBSPTreeBinary space partitioning container.This class can be used to organize searches for 3D points or normals in a set in O(log(n)) time
oCSbClipGeneric polygon clipper class.It is used by first adding all vertices in the polygon, and then clipping against any number of planes. If you need to supply additional information per vertex (e.g. texture coordinates), you should supply a callback in the constructor, and a pointer to your vertex structure in addVertex(). For every new vertex created, the callback is called with the line being clipped, including the pointers to your vertex structures and the position of the new (clipped against some plane) vertex. You should then create a new vertex structure, calculate your data (e.g. a new texture coordinate) and return a pointer to this structure
oCSbColorRed, green and blue components which make up a color value.This class is used within other classes in Coin. It inherits the SbVec3f class, interpreting the 3 component vector as a vector in the RGB cube where the red, green and blue components corresponds to x, y and z respectively
oCSbColor4fRed, green, blue and alpha components which make up a color value.This class is used internally within other classes in Coin. It contains a 4 component vector as a position in the RGB cube with an additional transparency value
oCSbCondVarA class for synchronizing access to global variables.Condition variables are used to protect global variables in an environment where multiple threads are running concurrently
oCSbCylinderRepresentation of a cylinder.This class is used within other classes in Coin. It contains data to represent a cylinder by an axis and a radius. The cylinder has no length/height value, which means it is treated as of infinite length
oCSbCylinderPlaneProjectorProjects 2D points to a half-cylinder and a plane.This projector uses a plane along with the half-cylinder of SbCylinderSectionProjector for projections. If the 2D point mapping "misses" the cylinder section, the 3D point will be projected onto the plane
oCSbCylinderProjectorAbstract base class for mapping to cylindrical surfaces.The cylinder projectors map 2D points to various surface types based on cylindrical shapes
oCSbCylinderSectionProjectorThe SbCylinderSectionProjector projects 2D points to a sliced cylinder.The projection cylinder for this class is sliced by a clipping plane parallel to its height axis. Projections will be mapped to the remaining cylinder part
oCSbCylinderSheetProjectorProjects 2D points to 3D points on a sheet covering a cylindrical shape
oCSbDictOrganizes a dictionary of keys and values.It uses hashing to quickly insert and find entries in the dictionary. An entry consists of an unique key and a generic pointer
oCSbDPLineLine in 3D space.SbDPLine is used by many other classes in Coin. It provides a way of specifying a directed line (also known as a ray) through a specified point (origin) and a direction in 3D space. Note that the line is infinite in both directions from its definition point
oCSbDPMatrix4x4 dimensional representation of a double-precision matrix.This class is like the SbMatrix class, but uses double-precision floating point values for its elements. For more class documentation, see SbMatrix
oCSbDPRotationRotation in 3D space.SbDPRotation is used extensively throughout the Coin library
oCSbDPViewVolumeDouble precision viewing volume in 3D space.This class contains the necessary information for storing a view volume. It has methods for projection of primitives from or into the 3D volume, doing camera transforms, view volume transforms etc
oCSbFifoA class for managing a pointer first-in, first-out queue
oCSbHeapGeneric heap class.FIXME: write doc
oCSbHeapFuncsThe SbHeapFuncs struct is used to specify functions on heap elements
oCSbImageAbstract datatype for 2D and 3D images.Be aware that this class is an extension for Coin, and it is not available in the original SGI Open Inventor v2.1 API
oCSbIntListContainer for integer list arrays
oCSbLineLine in 3D space.SbLine provides a way of specifying a directed line, through a 3D point (origin) and a vector direction in 3D space
oCSbLineProjectorProjects 2D points to 3D points along a line.The 3D projection of the 2D coordinates is for this projector class constrained to lie along a pre-defined line
oCSbListThe SbList class is a template container class for lists.SbList is an extension of the Coin library versus the original Open Inventor API. Open Inventor handles most list classes by inheriting the SbPList class, which contains an array of generic void* pointers. By using this template-based class instead, we can share more code and make the list handling code more typesafe
oCSbMatrix4x4 dimensional representation of a matrix.SbMatrix is used by many other classes in Coin. It provides storage for a 4x4 matrix of single-precision floating point values
oCSbMutexA basic class for managing a mutex.This class provides a portable framework around the mutex interface of the underlying native thread-handling toolkit
oCSbNameStores strings by reference.The class is used by Coin for storing keywords, names and other strings. They are stored in a manner where identical strings are guaranteed to map to the same memory address (as returned by the SbName::getString() method)
oCSbOctTreeDefines a generic oct tree for fast geometry searches.Be aware that this class is an extension for Coin, and it is not available in the original SGI Open Inventor v2.1 API
oCSbOctTreeFuncs
oCSbPlanePlane in 3D space.SbDPPlane is used by many other classes in Coin. It provides a way of representing a plane, specified by a plane normal vector and a distance from the origin of the coordinate system
oCSbPlaneProjectorProjects 2D points to 3D points in a plane.The 3D projection of the 2D coordinates is for this projector class constrained to lie inside a pre-defined 3D plane
oCSbPListContainer class for void pointers
oCSbProfilingDataData structure for gathering scene graph traversal profiling information
oCSbProjectorAbstract base projector class.Projectors are used in the Coin library for mapping 2D coordinates (typically from the position of the mouse cursor in the rendering window) to 3D "world" coordinates
oCSbRotationRotation in 3D space.SbRotation is used extensively throughout the Coin library
oCSbRWMutex
oCSbSphereRepresentation of a sphere.This class is used within many other classes in Coin. It contains the data neccessary to represent a sphere (a 3D point and a radius)
oCSbSpherePlaneProjectorProjects 2D points to a half-sphere and a plane.This projector uses a plane along with the half-sphere of SbSphereSectionProjector for projections. If the 2D point mapping "misses" the sphere section, the 3D point will be projected onto the plane
oCSbSphereProjectorAbstract base class for mapping to spherical surfaces.The sphere projectors map 2D points to various surface types based on spherical shapes
oCSbSphereSectionProjectorThe SbSphereSectionProjector projects 2D points to a sliced sphere.The projection sphere for this class is sliced by a clipping plane. Projections will be mapped to the remaining sphere part
oCSbSphereSheetProjectorProjects 2D points to 3D points on a sheet covering a spherical shape.The following stand-alone example shows how screen space coordinates projects into 3D when mapped with an SbSphereSheetProjector. It outputs the resulting projections as an SoPointSet in a Inventor-file on stdout:
oCSbStorageManages thread-local memory.This class manages thread-local memory. When different threads access the memory an SbStorage object manages, they will receive different memory blocks back
oCSbStringString class with convenience functions for string operations.This is the class used for storing and working with character strings. It automatically takes care of supporting all the "bookkeeping" tasks usually associated with working with character strings, like memory allocation and deallocation etc
oCSbStringListContainer for arrays of SbString pointers.Note that upon using the equality and inequality operators, the strings themselves are not compared, only the pointer values
oCSbTesselatorUsed to tessellate polygons into triangles.SbTesselator is used within Coin to split polygons into triangles. It handles concave polygons, does Delaunay triangulation and avoids generating self-intersecting triangles
oCSbThreadA class for managing threads.This class provides a portable framework around the tasks of instantiating, starting, stopping and joining threads
oCSbThreadAutoLockSimple convenience class for locking access to a function.This class provides a simple convenience mechanism for automatically locking access to a function that is not re-entrant
oCSbTimeInstances represents time values.SbTime is a convenient way of doing system independent representation and calculations on time values of high resolution
oCSbTypedStorageThe SbTypedStorage class manages generic thread-local memory.This class manages thread-local memory. When different threads access the memory an SbTypedStorage object manages, they will receive different memory blocks back
oCSbVec2bVector class for containing two byte integers
oCSbVec2d2 dimensional vector with double precision floating point coordinates.This vector class is used by many other classes in Coin. It provides storage for a vector in 2 dimensions aswell as simple floating point arithmetic operations on this vector
oCSbVec2f2 dimensional vector with floating point coordinates.This vector class is used by many other classes in Coin. It provides storage for a vector in 2 dimensions aswell as simple floating point arithmetic operations on this vector
oCSbVec2i322 dimensional vector with short integer coordinates.This vector class is used by many other classes in Coin. It provides storage for a vector in 2 dimensions as well as simple integer arithmetic operations
oCSbVec2s2 dimensional vector with short integer coordinates.This vector class is used by many other classes in Coin. It provides storage for a vector in 2 dimensions as well as simple integer arithmetic operations
oCSbVec2ub
oCSbVec2ui32
oCSbVec2us
oCSbVec3b
oCSbVec3d3 dimensional vector with double precision floating point coordinates.This vector class provides storage for a 3 dimensional double precision floating point vector aswell as simple floating point arithmetic operations
oCSbVec3f3 dimensional vector with floating point coordinates.This vector class is used by many other classes in Coin. It provides storage for a 3 dimensional vector aswell as simple floating point arithmetic operations
oCSbVec3fListContainer for arrays of SbVec3f pointers.Note that upon using the equality and inequality operators, the SbVec3f objects themselves are not compared, only the pointer values
oCSbVec3i32
oCSbVec3s3 dimensional vector with short integer coordinates.This vector class provides storage for a 3 dimensional vector as well as simple integer arithmetic operations
oCSbVec3ub
oCSbVec3ui32
oCSbVec3us
oCSbVec4b
oCSbVec4d4 dimensional vector with double precision floating point coordinates.This vector class is not by many other classes in Coin. It provides storage for a 3 dimensional homogeneoues vector (with the 4 components usually referred to as <x, y, z, w>) aswell as simple double precision floating point arithmetic operations
oCSbVec4f4 dimensional vector with floating point coordinates.This vector class is used by many other classes in Coin. It provides storage for a 3 dimensional homogeneoues vector (with the 4 components usually referred to as <x, y, z, w>) aswell as simple floating point arithmetic operations
oCSbVec4i32
oCSbVec4s
oCSbVec4ub
oCSbVec4ui32
oCSbViewportRegionViewport within a full window.The SbViewportRegion class contains information to represent a subview within a window. It stores information about the origin and size of the subview, aswell as the size of the underlying "full" window
oCSbViewVolumeViewing volume in 3D space.This class contains the necessary information for storing a view volume. It has methods for projection of primitives into the 3D volume from 2D points in the projection plane or vice versa, doing camera transforms, view volume transforms, etc
oCSbXfBox3d3 dimensional box with double precision coordinates and an attached transformation.It provides storage for two box corners with double precision floating point coordinates, and for a double precision 4x4 transformation matrix
oCSbXfBox3f3 dimensional box with floating point coordinates and an attached transformation.This box class is used by many other classes in Coin for data exchange. It provides storage for two box corners with floating point coordinates, and for a floating point 4x4 transformation matrix
oCScXMLNamespace for static ScXML-related functions
oCScXMLEventBase class for events sent to SCXML state machines
oCScXMLInvokeImplementation of the <invoke> SCXML element
oCScXMLObjectBase class for all SCXML objects
oCScXMLStateMachineManager for processing events and setting states in SCXML structures
oCSoAccumulatedElementAbstract class for storing accumulated state.This is the superclass of elements where new element data accumulates with older data
oCSoActionBase class for all traversal actions.Applying actions is the basic mechanism in Coin for executing various operations on scene graphs or paths within scene graphs, including search operations, rendering, interaction through picking, etc
oCSoActionMethodListFunction pointers for action methods.An SoActionMethodList contains one function pointer per node type. Each action contains an SoActioMethodList to know which functions to call during scene graph traversal
oCSoAlarmSensorSensor which will trigger once at a specified time.SoAlarmSensor provides a convenient way of setting up triggers for jobs which should be executed only once when they are scheduled
oCSoAmbientColorElementYet to be documented
oCSoAnnotationThe SoAnnotation node draws all its child geometry on top of other geometry.This group-type node uses delayed rendering in combination with Z-buffer disabling to let its children transparently render their geometry on top of the other geometry in the scene
oCSoAnnoText3CharOrientElementYet to be documented.FIXME: write doc
oCSoAnnoText3FontSizeHintElementYet to be documented.FIXME: write doc
oCSoAnnoText3RenderPrintElementYet to be documented.FIXME: write doc
oCSoAntiSquishUsed to reset to uniform scaling.When traversed, this node replaces the scale vector of the matrix with uniform values, based on one of the SoAntiSquish::Sizing strategies
oCSoAppearanceKitNode kit catalog that collects miscellaneous appearance node types.Node kit structure (new entries versus parent class marked with arrow prefix):
oCSoArrayGroup node for setting up regular arrays of subgraphs.SoArray presents a convenient way of duplicating a node (typically a shape node) or a complete subgraph in 1 to 3 dimensions
oCSoAsciiTextRenders flat 3D text.The text is rendered using 3D polygon geometry
oCSoAudioDeviceUsed to control an audio device.The SoAudioDevice class is responsible for initialization of an audio device, as well as enabling and disabling sound. It is a singleton class
oCSoAudioRenderActionRenders the aural parts of the scene graph.Applying this method at a root node for a scene graph, path or pathlist will render all sound-related nodes contained within that instance to the current SoAudioDevice
oCSoAuditorListUsed to keep track of auditors for certain object classes.This class is mainly for internal use (from SoBase) and it should not be necessary to be familiar with it for "ordinary" Coin use
oCSoBaseTop-level superclass for a number of class-hierarchies.SoBase provides the basic interfaces and methods for doing reference counting, type identification and import/export. All classes in Coin which uses these mechanisms are descendent from this class
oCSoBaseColorNode type for convenient setting of the base material color.If you want to just set the diffuse color of the following geometry, you can use this node for simplicity
oCSoBaseKitToplevel superclass for nodekits.Node kits are collections of nodes and other node kits (from here on node kits which are part of some other node kit, will only be referred to as nodes or parts, see catalogs and parts), organized in a way that is convenient for its use. A node kit inherits SoNode and can thus be inserted into a scenegraph as any other node
oCSoBaseListContainer for pointers to SoBase derived objects.The additional capability of the SoBaseList class over its parent class, SbPList, is to automatically handle referencing and dereferencing of items as they are added or removed from the lists
oCSoBBoxModelMatrixElementKeeps track of the current model matrix during a scene graph traversal. It is used by amongst others the SoGetBoundingBoxAction class
oCSoBlinkerCycling switch node.This switch node cycles its children SoBlinker::speed number of times per second. If the node has only one child, it will be cycled on and off. Cycling can be turned off using the SoBlinker::on field, and the node then behaves like a normal SoSwitch node
oCSoBoolOperationThe SoBoolOperation engine evaluates expressions of boolean logic.The multivalue fields SoBoolOperation::a and SoBoolOperation::b are combined according to the operations set in SoBoolOperation::operation, with the resulting TRUE or FALSE value set on SoBoolOperation::output
oCSoBoundingBoxCacheUsed to cache bounding boxes
oCSoBoxHighlightRenderActionRenders the scene with highlighted boxes around selections.This action performs the same tasks as its parent class, SoGLRenderAction, with the added ability to render highlighted bounding boxes around geometry in selected nodes. This is a simple but convenient way of giving feedback to the user upon interaction with the scene graph
oCSoBumpMapUsed to map a bump map onto subsequent shapes.SoBumpMap has support for two types of maps. If the image is a three component (RGB) image, it will be treated as a normal map, where the red image component equals the X normal component, green equals Y, and blue is Z. See http://www.paulsprojects.net/tutorials/simplebump/simplebump.html for a nice introduction about bump mapping and normal maps
oCSoBumpMapCoordinateNode for providing bump map coordinates to shape nodes.When encountering nodes of this type during traversal, the coordinates it contains will be put on the state stack for later use by shape nodes. The bump map coordinates can be used to specify explicit coordinates for a bump map. The SoBumpMap node is used to specify a bump map for the shape nodes
oCSoBumpMapCoordinateElementYet to be documented.FIXME: write doc
oCSoBumpMapMatrixElementUsed to manage the bump map matrix stack.The bump map matrix is used to transform bump map coordinates before being used to map bump maps onto polygons
oCSoBumpMapTransformUsed to define 2D bump map transformations.Bump maps applied to shapes in the scene can be transformed by "prefixing" in the state with instances of this node type. Translations, rotations and scaling in 2D can all be done
oCSoBundleSuperclass for all bundle classes
oCSoButtonEventBase class for all button events.The event classes which results from the user pushing buttons on some device (keyboard, mouse or spaceball) all inherit this class. The SoButtonEvent class contains methods for setting and getting the state of the button(s)
oCSoCacheSuperclass for all internal cache classes.It organizes reference counting to make it possible to share cache instances. It also organizes a list of elements that will affect the cache. If any of the elements have changed since the cache was created, the cache is invalid
oCSoCacheElementStores and manages the open caches
oCSoCacheHintNode containing hints about how to cache geometry.The SoCacheHint node is used to set up clues to the rendering subsystem about how Coin should cache vertex data
oCSoCalculatorGeneral purpose calculator for floats and 3D float vectors.The SoCalculator uses the values from the input fields (which are either single floating point values or vectors) as variables in the free-form engine expressions and places the results on the output fields
oCSoCallbackNode type which provides a means of setting callback hooks in the scene graph.By inserting SoCallback nodes in a scene graph, the application programmer can set up functions to be executed at certain points in the traversal
oCSoCallbackActionInvokes callbacks at specific nodes.This action has mechanisms for tracking traversal position and traversal state. In combination with the ability to pass geometry primitives to callback actions set by the user, this does for instance make it rather straightforward to extract the geometry of a scene graph
oCSoCallbackListThe SoCallbackList is a container for callback function pointers.This list stores callback function pointers (along with user-specified extra data to pass to the callbacks) and provides a method for triggering the callback functions
oCSoCameraAbstract base class for camera definition nodes.To be able to view a scene, one needs to have a camera in the scene graph. A camera node will set up the projection and viewing matrices for rendering of the geometry in the scene
oCSoCameraKitNode kit with a transform and a camera.Node kit structure (new entries versus parent class marked with arrow prefix):
oCSoCenterballDraggerDragger you can rotate and translate.Here's how the dragger looks with its default geometry in the inactive state:
oCSoCenterballManipThe SoCenterballManip wraps an SoCenterballDragger for convenience.
oCSoChildListContainer for node children.This class does automatic notification on the parent nodes upon adding or removing children
oCSoClipPlaneNode type for specifying clipping planes.A scene graph without any SoClipPlane nodes uses six clipping planes to define the viewing frustum: top, bottom, left, right, near and far. If you want extra clipping planes for "slicing" the visible geometry, you can do that by using nodes of this type. Geometry on the back side of the clipping plane is clipped away
oCSoClipPlaneElementUsed to manage the clip plane stack
oCSoClipPlaneManipUsed to manipulate clip planes.
oCSoColorIndexUsed to specify color indices for subsequent shapes.This node should only be used in OpenGL color-index mode, and only when the current light model is set to SoLightModel::BASE_COLOR
oCSoComplexityNode type which is used to set the tradeoff between quality and performance.By inserting SoComplexity nodes in the scene graph, you can control the accuracy by which complex shapes are rendered and the quality of the texture mapping used for geometry in the scene
oCSoComplexityElementCurrent shape complexity for a graph traverser
oCSoComplexityTypeElementYet to be documented.FIXME: write doc
oCSoComposeMatrixUsed to compose a matrix from miscellaneous transformations
oCSoComposeRotationUsed to compose rotations from angle and axis.Simple usage example:
oCSoComposeRotationFromToUsed to compose rotations based on from and to vectors
oCSoComposeVec2fUsed to compose 2D vectors from two floats
oCSoComposeVec3fUsed to compose 3D vectors from floats
oCSoComposeVec4fUsed to compose 4D vectors from four floats
oCSoComputeBoundingBoxUsed to calculate a bounding box.This engine is simply a wrapper around the SoGetBoundingBoxAction, for a convenient way of having automatic updating of some data in the scene graph which is dependent on the bounding box of some other part of the scene
oCSoConcatenateUsed to concatenate several inputs into one output.Takes all the values from the 10 input multivalue fields in turn and concatenates them into the multivalue output
oCSoConeFor rendering cone shapes.Insert a cone shape into the scenegraph. The cone is rendered with the current material, texture and drawstyle settings (if any, otherwise the default settings are used)
oCSoConeDetailInformation about the parts of a SoCone shape.Instances of this class are used for storing information about hit points on cone geometry after pick operations, and for storing information returned to tessellation callbacks
oCSoContextHandlerFor now to be treated as an internal class
oCSoConvexDataCacheUsed to cache convexified polygons.SoConvexDataCache is used to speed up rendering of concave polygons by tessellating all polygons into triangles and storing the newly generated primitives in an internal cache
oCSoCoordinate3Node for providing coordinates to shape nodes.When encountering nodes of this type during traversal, the coordinates it contains will be put on the state stack for later use by shape nodes of types which needs coordinate sets (like SoFaceSet nodes or SoPointSet nodes)
oCSoCoordinate4Node for providing coordinates to shape nodes.When encountering nodes of this type during traversal, the coordinates it contains will be put on the statestack for later use by shape nodes of types which needs coordinate sets (like SoFaceSet nodes or SoPointSet nodes)
oCSoCoordinateElementYet to be documented.FIXME: write doc
oCSoCounterInteger counter engine.The engine counts from its min value to its max value, adding the value of step each time trigger is touched
oCSoCreaseAngleElementStores the crease angle during a scene graph traversal
oCSoCubeFor rendering cubes.Insert a cube shape into the scenegraph. The cube is rendered with the current material, texture and drawstyle settings (if any, otherwise the default settings are used)
oCSoCubeDetailInformation about the parts of a SoCube shape.Instances of this class are used for storing information about hit points on cone geometry after pick operations, and for storing information returned to tessellation callbacks
oCSoCullElementUsed internally for render and pick culling.The element holds all planes the geometry should be inside, and keeps a bitflag to signal which planes need to be tested
oCSoCylinderFor rendering cylinder shapes.Insert a cylinder shape into the scenegraph. The cylinder is rendered with the current material, texture and drawstyle settings (if any, otherwise the default settings are used)
oCSoCylinderDetailInformation about the parts of a SoCylinder shape.Instances of this class are used for storing information about hit points on cylinder geometry after pick operations, and for storing information returned to tessellation callbacks
oCSoDataSensorAbstract base class for sensors monitoring changes in a scene graph.If you need to know when a particular entity (as a field or a node) changes, subclasses of SoDataSensor can be used to monitor the entity and notify you when it changes
oCSoDBKeeps track of internal global data.This class collects various methods for initializing, setting and accessing common global data from the Coin library
oCSoDebug
oCSoDebugErrorInternal debugging message passing mechanism.This class basically serves two purposes:
oCSoDecimationPercentageElementYet to be documented.FIXME: write doc
oCSoDecimationTypeElementYet to be documented.FIXME: write doc
oCSoDecomposeMatrixUsed to decompose a matrix into simple transformations
oCSoDecomposeRotationUsed to decompose a rotation into angle and axis
oCSoDecomposeVec2fUsed to decompose 2D vectors into two floats
oCSoDecomposeVec3fUsed to decompose 3D vectors into three floats
oCSoDecomposeVec4fUsed to decompose 4D vectors into four floats
oCSoDelayQueueSensorAbstract base class for priority scheduled sensors.Delay queue sensors are invoked upon various events not related to time occurrences. See documentation of subclasses to see which types of events can be surveilled by the builtin sensor types
oCSoDepthBufferNode used to control the GL depth buffer
oCSoDepthBufferElementThe SoDepthBufferElement controls the depth buffer settings
oCSoDetailSuperclass for all classes storing detailed information about particular shapes.Detail information about shapes is used in relation to picking actions in Coin. They typically contain the relevant information about what particular part of the shape a pick ray intersected with
oCSoDetailListContainer for pointers to SoDetail objects.This list class will delete the details when destructed/truncated, or when a detail in the list is replaced by another detail. The caller is responsible for allocating the details passed to the list, but should not deallocate them since this will be handled by the list
oCSoDiffuseColorElementYet to be documented.FIXME: write doc
oCSoDirectionalLightNode type for specifying directional light sources.A directional light source provides a model of light sources which are at infinite distance from the geometry it illuminates, thereby having no set position and consisting of an infinite volume of parallel rays
oCSoDirectionalLightDraggerInteractive geometry for manipulating a directional light source.Here's how the dragger looks with its default geometry in the inactive state:
oCSoDirectionalLightManipUsed to manipulate SoDirectionalLight nodes.
oCSoDraggerBase class for all draggers.Draggers is a mechanism used for letting the end-users of your application code interact with elements in 3D, by scaling, rotating or translating geometry or other instances in the scene (like cameras or lightsources)
oCSoDragPointDraggerMechanisms for moving a point in 3D.Here's how the dragger looks with its default geometry in the inactive state:
oCSoDrawStyleSpecificies common rendering properties for shapes.Use SoDrawStyle nodes to influence how shape nodes following them in the scenegraph will be rendered. This node type have fields to help decide how certain aspects of point-based shapes, line-based shapes and filled shape primitives are rendered
oCSoDrawStyleElementYet to be documented.FIXME: write doc
oCSoElapsedTimeControllable time source engine.The additional functionality provided by this engine versus just connecting to the realTime global field is the ability to control the speed of the time source plus logic to reset, stop and restart it
oCSoElementSoElement is the abstract base class for all elements
oCSoEmissiveColorElementYet to be documented.FIXME: write doc
oCSoEnabledElementsListContainer for type info for element types that are enabled in actions.This class is probably not interesting for the application programmer
oCSoEngineSoEngine is the base class for Coin engines.Engines enables the application programmers to make complex connections between fields
oCSoEngineListContainer for SoEngine objects.As this class inherits SoBaseList, referencing and dereferencing will default be done on the objects at append(), remove(), insert() etc
oCSoEngineOutputOutput slots in SoEngine instances.SoEngineOutput has methods for convenient handling of the connections made from SoEngine objects to SoField objects
oCSoEngineOutputDataContainer for a prototype set of outputs.This class is instantiated once for each class of objects which use outputs, and which needs to be able to import and export them
oCSoEngineOutputListContainer for SoEngineOutput objects
oCSoEnvironmentNode for specifying global rendering parameters.This node type provides the application programmer with the ability to set global parameters influencing lighting and fog
oCSoEnvironmentElementYet to be documented.FIXME: write doc
oCSoErrorBase class for all the error handling classes.The default error handler just prints messages on the standard error output channel, but this can be overridden by client applications
oCSoEventBase class for all Coin events.Coin contains its own set of event classes, independent of the underlying window system
oCSoEventCallbackFunctionality for catching events.Use SoEventCallback nodes in the scenegraph for catching user interaction events with the scenegraph's render canvas
oCSoEventManagerEvent handling for a Coin3D viewer
oCSoExtSelectionCan be used for extended selection functionality.This class enables you to select geometry by specifying a lasso (a polygon) or a rectangle on screen. When objects are selected, you'll receive the same callbacks as for the SoSelection node
oCSoFaceDetailFor storing detailed polygon information.Instances of this class are used among other things for storing information about polygons after pick operations, and for storing information returned to tessellation callbacks
oCSoFaceSetUsed to render and organize non-indexed polygonal face data.Faces are specified using the numVertices field. Coordinates, normals, materials and texture coordinates are fetched in order from the current state or from the vertexProperty node if set. For example, if numVertices is set to [3, 4, 5, 3], this node would specify a triangle from coordinates 0, 1 and 2, a quad from coordinates 3, 4, 5 and 6, a polygon from coordinates 7, 8, 9, 10 and 11 and finally a triangle from coordinates 12, 13, 14
oCSoFieldTop-level abstract base class for fields.Fields is the mechanism used throughout Coin for encapsulating basic data types to detect changes made to them, and to provide conversion, import and export facilities
oCSoFieldContainerBase class for all classes that contain fields.The classes containing fields in Coin are the node and engine classes, so they are all subclasses of SoFieldContainer
oCSoFieldConverterAbstract base class for field converters.When fields of different types are attempted connected, the Coin library tries to find a field converter class which can be inserted between them, acting as a filter converting values from the master field to values matching the type of the slave field
oCSoFieldDataContainer for a prototype set of fields.This class is instantiated once for each class of objects which use fields, and which needs to be able to import and export them
oCSoFieldListContainer for pointers to SoField objects
oCSoFieldSensorDetects changes to a field.Attach a field to a sensor of this type to put it under surveillance, so you can act upon changes to the field
oCSoFileNode container for another model file.This node provides a way to split your models into a set of "component" models to include into larger "master" files
oCSoFloatElementSoFloatElement is an abstract base class for elements that consists of a single float value.This is the superclass of elements where the new element data replaces the old data, and where the data the element stores is a simple single precision floating point value
oCSoFocalDistanceElementYet to be documented.FIXME: write doc
oCSoFontAppearance node for setting fonts.Successive text rendering nodes (like SoText2, SoText3, SoAsciiText, etc) will use the font specified from an SoFont node when visualizing text
oCSoFontNameElementYet to be documented.FIXME: write doc
oCSoFontSizeElementYet to be documented.FIXME: write doc
oCSoFontStyleChanges the appearance of fonts for text rendering nodes.Successive text rendering nodes will use fonts with the style settings of this node, if a font with the given settings can be found and loaded from the system
oCSoForeignFileKitAbstract base class for foreign file format support in Coin
oCSoFragmentShaderUsed for setting up fragment shader programs.See Shaders in Coin for more information on how to set up a scene graph with shaders
oCSoFrustumCameraDefines a camera with a generic frustum.
oCSoFullPathAllows examination of hidden children in paths.SoPath allows only access from the head node to the first node with hidden children, but not any further
oCSoGateUsed to selectively copy values from input to output.This engine will forward values from the SoGate::input field to the SoGate::output field when the SoGate::enable field is TRUE
oCSoGeoCoordinateUsed to specify a list of geographical coordinates.FILE FORMAT/DEFAULTS:
oCSoGeoElementYet to be documented.FIXME: write doc
oCSoGeoLocationUsed to georeference the following nodes.FILE FORMAT/DEFAULTS:
oCSoGeometryShaderUsed for loading geometry shader programs.See Shaders in Coin for more information on how to set up a scene graph with shaders
oCSoGeoOriginUsed to specify an absolute geographic location against which geometry is referenced.FILE FORMAT/DEFAULTS:
oCSoGeoSeparatorUsed to georeference a scene graph.FILE FORMAT/DEFAULTS:
oCSoGetBoundingBoxActionCalculates bounding boxes for nodes and subgraphs.If this action is applied to a path or scene graph root, it will calculate the bounding box and the center point of the geometry contained within the scene
oCSoGetMatrixActionAction for accumulating the transformation matrix of a subgraph.This action makes it easy to calculate and convert to and from the global coordinate system of your scene and local coordinates of parts in a hierarchical model
oCSoGetPrimitiveCountActionCounts the primitives in a scene.Apply this action to a scene if you need to know the number of primitives present in a scenegraph, or parts of a scenegraph
oCSoGLBigImageUsed to handle 2D OpenGL textures of any size
oCSoGLCacheListUsed to store and manage OpenGL caches
oCSoGLClipPlaneElementYet to be documented.FIXME: write doc
oCSoGLColorIndexElementSets the current OpenGL color.This element is only used when the OpenGL canvas is in colorindex mode, ie where colors for individual pixels are fetched from a color lookup table ("CLUT"). The usual thing to do is to set up a canvas in RGBA truecolor mode
oCSoGLCoordinateElementYet to be documented.FIXME: write doc
oCSoGLCubeMapImageUsed to handle cube map textures
oCSoGLDepthBufferElementThe SoGLDepthBufferElement controls the OpenGL depth buffer
oCSoGLDisplayListStores and manages OpenGL display lists.The TEXTURE_OBJECT type is not directly supported in Coin. We handle textures differently in a more flexible class called SoGLImage, which also stores some information about the texture used when rendering. Old code which use this element should not stop working though. The texture object extension will just not be used, and the texture will be stored in a display list instead
oCSoGLDrawStyleElementThe SoGLDrawStyleElement updates the current draw style in OpenGL
oCSoGLDriverDatabaseUsed for looking up broken/slow features in OpenGL drivers
oCSoGLEnvironmentElementFor setting GL fog etc
oCSoGLImageUsed to handle OpenGL 2D/3D textures
oCSoGLLazyElementMeant to optimize GL rendering.This is just a wrap-around implementation for compatibility. It should (hopefully) work in the same way as the Inventor class though
oCSoGLLightIdElementYet to be documented.FIXME: write doc
oCSoGLLinePatternElementYet to be documented.FIXME: write doc
oCSoGLLineWidthElementChanges the linewidth setting of the OpenGL render state.Requests from the scenegraph to change the linewidth when rendering OpenGL line primitives will be made through this element, which forwards it to the appropriate native OpenGL call
oCSoGLModelMatrixElementYet to be documented.FIXME: write doc
oCSoGLMultiTextureCoordinateElementStores the current gltexture coordinates for several units
oCSoGLMultiTextureImageElementThe SoGLMultiTextureImageElement is used to control the current GL texture for texture units
oCSoGLMultiTextureMatrixElementUsed to update the OpenGL texture matrix.Since (for some weird reason) most OpenGL implementations have a very small texture matrix stack, and since the matrix stack also is broken on many OpenGL implementations, the texture matrix is always loaded into OpenGL. We do not push() and pop() matrices
oCSoGLNormalElementYet to be documented.FIXME: write doc
oCSoGlobalSimplifyActionFor globally simplifying the geometry of a scene graph, globally
oCSoGLPointSizeElementChanges the pointsize setting of the OpenGL render state.Requests from the scenegraph to change the pointsize when rendering point primitives will be made through this element, which forwards it to the appropriate native OpenGL call
oCSoGLPolygonOffsetElementYet to be documented.FIXME: write doc
oCSoGLProjectionMatrixElementYet to be documented.FIXME: write doc
oCSoGLRenderActionRenders the scene graph with OpenGL calls.Applying this method at a root node for a scene graph, path or pathlist will render all geometry contained within that instance to the current OpenGL context
oCSoGLRenderCacheUsed to cache OpenGL calls
oCSoGLRenderPassElementYet to be documented.FIXME: write doc
oCSoGLShadowCullingElementYet to be documented.FIXME: write doc
oCSoGLShapeHintsElementYet to be documented.FIXME: write doc
oCSoGLTexture3EnabledElementElement which controls whether 3D texturing is enabled or not.Be aware that this class is an extension for Coin, and it is not available in the original SGI Open Inventor v2.1 API
oCSoGLTextureCoordinateElementStores the current gltexture coordinates
oCSoGLTextureEnabledElementElement which controls whether texturing is enabled or not
oCSoGLTextureImageElementThe SoGLTextureImageElement is used to control the current GL texture.This is a lazy element. It is evaluated in SoShape::shouldGLRender()
oCSoGLTextureMatrixElementUsed to update the OpenGL texture matrix.Since (for some weird reason) most OpenGL implementations have a very small texture matrix stack, and since the matrix stack also is broken on many OpenGL implementations, the texture matrix is always loaded into OpenGL. We do not push() and pop() matrices
oCSoGLUpdateAreaElementYet to be documented.FIXME: write doc
oCSoGLVBOElementUsed to store VBO state.FIXME: write doc
oCSoGLViewingMatrixElementUsed to store the current viewing matrix.The viewing matrix contains the inverse camera coordinate system matrix. The camera coordinate system is built from the field values in the current SoCamera (currently either SoPerspectiveCamera or SoOrthographicCamera) and any transformations prior to the camera in the scene graph
oCSoGLViewportRegionElementYet to be documented.FIXME: write doc
oCSoGlyphUsed to generate and reuse font glyph bitmaps and outlines
oCSoGroupNode which managed other node instances.The internal scene data structures in Coin are managed as directed graphs. The graphs are built by setting up a hierarchy through the use of group nodes (either of this type, or from subclasses like SoSeparator) which is then traversed when applying actions (like SoGLRenderAction) to it
oCSoHandleBoxDraggerSupport for interactive scaling and translation.Here's how the dragger looks with its default geometry in the inactive state:
oCSoHandleBoxManipWraps an SoHandleBoxDragger for manipulating a transformation.
oCSoHandleEventActionDistributes user events to the scene.This is the action used by the GUI viewer classes to pass interaction events from the window system to the nodes in the scene graph
oCSoHardCopyStatic class for initializing the hardcopy support
oCSoHeightMapToNormalMapEngine for computing a normal map from a height map
oCSoIdleSensorSensor which will trigger as soon as the application is idle.An SoIdleSensor differs from an SoOneShotSensor in that it will not trigger if the delay queue processing is occurring due to the delay queue timeout, but only when the application is idle
oCSoImageDraws a 2D image on the viewport.An image can be specified either by using the image field, or by specifying a filename. If width and or height is specified, the image will be resized to match those values before it is displayed
oCSoIndexedFaceSetUsed to handle generic indexed facesets.Faces are specified using the coordIndex field. Each face must be terminated by a negative (-1) index. Coordinates, normals, materials and texture coordinates from the current state (or from the vertexProperty node if set), can be indexed to create triangles, quads or polygons
oCSoIndexedLineSetUsed to render and otherwise represent indexed lines.The indexed counterpart of SoLineSet. Lines can specified using indices for coordinates, normals, materials and texture coordinates
oCSoIndexedMarkerSetUsed to display a set of bitmap markers at 3D positions.This node either uses the coordinates currently on the state (typically set up by a leading SoCoordinate3 node in the scenegraph) or from a SoVertexProperty node attached to this node to render a set of 3D points
oCSoIndexedNurbsCurveNode for representing smooth curves.Explaining NURBS is beyond the scope of this documentation. If you are unfamiliar with the principles of representing smooth curves and surfaces when doing 3D visualization, we recommend finding a good book on the subject
oCSoIndexedNurbsSurfaceCan be used to render NURBS surfaces.It is very similar to the SoNurbsSurface class, but controlpoints can be specified using indices
oCSoIndexedPointSetUsed to display a set of 3D points.This node either uses the coordinates currently on the state (typically set up by a leading SoCoordinate3 node in the scenegraph) or from a SoVertexProperty node attached to this node to render a set of 3D points
oCSoIndexedShapeSuperclass for all indexed vertex shapes.This is an abstract class which contains storage for four fields for indices to coordinates, normals, materials and texture coordinates for it's subclasses
oCSoIndexedTriangleStripSetKeeps data for rendering and otherwise representing triangle strips.Use nodes of this type as an effective way of drawing triangles which are strung together
oCSoInfoNode for holding text information.This is simply a placeholder for textual information about a scene. Typically used for specifying author and copyright information in Inventor format files, but can also be used for other purposes, of course
oCSoInputAbstraction of file import functionality.This class takes care of most of the chores of doing data import in Coin. It puts a layer of abstraction over the read operations to make it transparent for the rest of the Coin code whether or not we're reading from a file, from a memory buffer or from stdin
oCSoInt32ElementBase class for elements that simply store a 32-bit integer.This is the superclass of elements where the new element data replaces the old data, and where the data the element stores is a simple 32-bit integer value
oCSoInteractionTakes care of initalizing internal classes.SoInteraction is present for the sole purpose of providing an interface to the initialization methods of the classes in Coin which are somehow related to user interaction, like the draggers and manipulators
oCSoInteractionKitBase class for draggers.This nodekit class makes it possible to set surrogate paths for parts. Instead of creating new geometry for the dragger, it is possible to specify an existing path in your scene to be used for interaction. All picks on this path will be handled by the dragger
oCSoInterpolateBase class for all interpolator engines.Interpolators are used to linearly interpolate between two values
oCSoInterpolateFloatUsed to interpolate two floating point values
oCSoInterpolateRotationUsed to interpolate between two rotations
oCSoInterpolateVec2fUsed to interpolate between pairs of 2D vectors
oCSoInterpolateVec3fUsed to interpolate between pairs of 3D vectors
oCSoInterpolateVec4fUsed to interpolate between pairs of 4D vectors
oCSoIntersectingPrimitiveStruct with collision information
oCSoIntersectionDetectionActionFor detecting intersecting primitives in a scene
oCSoJackDraggerDragger you can translate, rotate and scale.Here's how the dragger looks with its default geometry in the inactive state:
oCSoJackManipThe SoJackManip wraps an SoJackDragger for convenience.
oCSoKeyboardEventInformation about keyboard interaction.When the user presses any keys on the keyboard, these will be translated from a system specific event into a Coin event and sent to the scenegraph by using instances of this class
oCSoLabelNode for holding label information in a scene graph.Use this node as a convenient way of labeling nodes or subgraphs within a scene graph
oCSoLazyElementUsed 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
oCSoLevelOfDetailUsed to choose a child based on projected size.A level-of-detail mechanism is typically used by application programmers to assist the library in speeding up the rendering
oCSoLightBase class for light emitting nodes.This node type is abstract and does not in itself provide any light sources to the scene, you need to use one of its subclasses
oCSoLightAttenuationElementYet to be documented.FIXME: write doc
oCSoLightElementManages the currently active light sources
oCSoLightKitKit with a transform, a light and a shape or subgraph.Node kit structure (new entries versus parent class marked with arrow prefix):
oCSoLightModelNode for specifying the model for geometry lighting.Use nodes of this type to set up how lighting should affect subsequent geometry in the scene
oCSoLightModelElementYet to be documented.FIXME: write doc
oCSoLightPathLight version of SoPath.SoLightPath can be used if you only need a temporary path, and don't want the overhead that comes with an SoPath (ref, unref, auditing etc)
oCSoLinearProfileNode for specifying linear profile curves.Use nodes of this type if you want to set up profiles that are simply straight lines connected by control points
oCSoLineDetailFor storing detailed 3D line information.Instances of this class are used among other things for storing information about lines after pick operations, and for storing information returned to tessellation callbacks
oCSoLineHighlightRenderActionRenders selections with line highlighting.See the documentation of SoBoxHighlightRenderAction
oCSoLinePatternElementYet to be documented.FIXME: write doc
oCSoLineSetUsed to render and organize non-indexed polylines.Polylines are specified using the numVertices field. Coordinates, normals, materials and texture coordinates are fetched in order from the current state or from the vertexProperty node if set. For example, if numVertices is set to [3, 4, 2], this node would specify a line through coordinates 0, 1 and 2, a line through coordinates 3, 4, 5 and 6, and finally a single line segment between coordinates 7 and 8
oCSoLineWidthElementChanges the linewidth setting of the render state.Requests from the scenegraph to change the linewidth when rendering line primitives will be made through this element, which forwards it to the appropriate native call in the underlying rendering library
oCSoListenerDefines listener attributes used when rendering sound.When rendering geometry, one needs to have a camera defining certain attributes related to vieweing. The SoListener plays a similar role when it comes to rendering audio
oCSoListenerDopplerElementThe SoListenerDopplerElement holds the doppler velocity and factor of the current listener.The dopplerVelocity and dopplerFactor is set by SoListener nodes during audio rendering. The SoListenerDopplerElement is used when the SoVRMLSound nodes render themselves
oCSoListenerGainElementStores the SoListener gain during a scene graph traversal.This gain is set by SoListener nodes during audio rendering. The SoListenerGainElement is used when the SoVRMLSound nodes render themselves
oCSoListenerOrientationElementThe SoListenerOrientationElement holds the orientation of the current listener.This orientation is set by SoListener nodes and SoCamera Nodes during audio rendering. When a SoListener is visited by the SoAudioRenderAction, it will add a new SoListenerOrientationElement to the state, holding it's orientation and with the setbylistener flag set. When a SoCamera is visited by SoAudioRenderAction, it will add a new SoListenerOrientationElement only if there are no previous elements with the setbylistener flag set
oCSoListenerPositionElementThe SoListenerPositionElement holds the position of the current listener.This position is set by SoListener nodes and SoCamera Nodes during audio rendering. When a SoListener is visited by the SoAudioRenderAction, it will add a new SoListenerPositionElement to the state, holding it's position and with the setbylistener flag set. When a SoCamera is visited by SoAudioRenderAction, it will add a new SoListenerPositionElement only if there are no previous elements with the setbylistener flag set
oCSoLocalBBoxMatrixElementYet to be documented.FIXME: write doc
oCSoLocateHighlightHighlights geometry under the cursor.Note: this node is supposed to draw to the front buffer. However, in Coin we always draw to the back buffer, forcing a scene redraw whenever a highlight state changes
oCSoLocation2EventInformation about 2D movement events.Location2 events are generated by devices capable of 2D, e.g. pointer devices – typically computer mice. Instances of this class contains information about the position of the pointer on the render area
oCSoLockManagerThe SoLockManager is a defunct software license lock mechanism.This is just a dummy implementation of the TGS Inventor class used to provide a license locking mechanism. Since Coin can be used without any royalty fees or client-site license locks, no such mechanism is needed
oCSoLODUsed to choose a child based distance between viewer and object.The class documentation for the SoLOD node class would be similar enough to that of SoLevelOfDetail that we will refer you to look at that one first. It will explain the general principles of what a level-of-detail mechanism is, and why and how to use it
oCSoMarkerSetDisplays a set of 2D bitmap markers in 3D.This node uses the coordinates currently on the state (or in the vertexProperty field) in order. The numPoints field specifies the number of points in the set
oCSoMaterialNode type for setting up material values for scene geometry.After traversing an SoMaterial node, subsequent shape nodes with geometry in the scene graph will use values from the material "pool" of the traversal state set up from nodes of this type
oCSoMaterialBindingNode for setting up how materials are mapped to shapes.The material binding specified in nodes of this type decides how the material values of SoMaterial nodes are mapped on the builtin geometry shape nodes
oCSoMaterialBindingElementYet to be documented.FIXME: write doc
oCSoMaterialBundleSimplifies material handling.Every shape node should create (on the stack) an instance of this class and call sendFirst() before sending anything to GL. During rendering, send() should be used to send material values to GL
oCSoMatrixTransformTransformation node.This class is the most flexible transformation node, as you can use it to accumulate any kind of transformation matrix on top of the current model transformation matrix
oCSoMemoryErrorUsed to inform of problems with memory allocation.Modern operating systems takes care of handling most out of memory conditions for you, but in certain situations it can be wise to do some manual checking and intervention. This class is provided as an aid to help out in these situations
oCSoMFBitMaskContainer for a set of bitmasks.This field is used where nodes, engines or other field containers needs to store multiple bitmasks with values from an enumerated set
oCSoMFBoolContainer for SbBool values.This field is used where nodes, engines or other field containers needs to store multiple boolean on/off or TRUE/FALSE values
oCSoMFColorContainer for SbColor values.This field is used where nodes, engines or other field containers needs to store multiple color values (i.e. "Red Green Blue" triplets)
oCSoMFColorRGBAContainer for SbColor4f values.This field is used where nodes, engines or other field containers needs to store multiple color values (i.e. "Red Green Blue" triplets)
oCSoMFDoubleContainer for double float precision point values.This field is used where nodes, engines or other field containers needs to store a group of multiple floating point values
oCSoMFEngineContainer for engines.This field container stores an array of pointers to engines. It takes care of the necessary functionality for handling copy, import and export operations
oCSoMFEnumContainer for a set of enumerated values.This field is used where nodes, engines or other field containers needs to store values constrained to be from an enumerated set
oCSoMFFloatContainer for floating point values.This field is used where nodes, engines or other field containers needs to store a group of multiple floating point values
oCSoMFieldBase class for fields which can contain multiple values.All field types which may contain more than one member value inherits this class. SoMField is an abstract class
oCSoMFInt32Container for 32-bit integer values.This field is used where nodes, engines or other field containers needs to store a group of multiple 32-bit integer values
oCSoMFMatrixContainer for SbMatrix values.This field is used where nodes, engines or other field containers needs to store matrices
oCSoMFNameContainer for SbName values.This field is used where nodes, engines or other field containers needs to store arrays of names
oCSoMFNodeContainer for nodes.This field container stores an array of pointers to nodes. It takes care of the necessary functionality for handling copy, import and export operations
oCSoMFPathContainer for paths.This field container stores an array of pointers to paths. It takes care of the necessary functionality for handling copy, import and export operations
oCSoMFPlaneContainer for SbPlane values.This field is used where nodes, engines or other field containers needs to store multiple 3D plane definitions
oCSoMFRotationContainer for SbRotation values.This field is used where nodes, engines or other field containers needs to store multiple rotation definitions
oCSoMFShortContainer for short integer values.This field is used where nodes, engines or other field containers needs to store a group of multiple short integer values
oCSoMFStringContainer for SbString values.This field is used where nodes, engines or other field containers needs to store arrays of strings
oCSoMFTimeContainer for SbTime values.This field is used where nodes, engines or other field containers needs to store multiple time representations
oCSoMFUInt32Container for 32-bit unsigned integer values.This field is used where nodes, engines or other field containers needs to store a group of multiple 32-bit unsigned integer values
oCSoMFUShortContainer for unsigned short integer values.This field supports application data sharing through a setValuesPointer() method. See SoMField documentation for information on how to use this function
oCSoMFVec2bContainer for SbVec2b vectors.This field is used where nodes, engines or other field containers needs to store an array of vectors with two elements
oCSoMFVec2dContainer for SbVec2d vectors.This field is used where nodes, engines or other field containers needs to store an array of vectors with two elements
oCSoMFVec2fContainer for SbVec2f vectors.This field is used where nodes, engines or other field containers needs to store an array of vectors with two elements
oCSoMFVec2i32Container for SbVec2i32 vectors.This field is used where nodes, engines or other field containers needs to store an array of vectors with two elements
oCSoMFVec2sContainer for SbVec2s vectors.This field is used where nodes, engines or other field containers needs to store an array of vectors with two elements
oCSoMFVec3bContainer for SbVec3b vectors.This field is used where nodes, engines or other field containers needs to store an array of vectors with three elements
oCSoMFVec3dContainer for SbVec3d vectors.This field is used where nodes, engines or other field containers needs to store an array of vectors with three elements
oCSoMFVec3fContainer for SbVec3f vectors.This field is used where nodes, engines or other field containers needs to store an array of vectors with three elements
oCSoMFVec3i32Container for SbVec3i32 vectors.This field is used where nodes, engines or other field containers needs to store an array of vectors with three elements
oCSoMFVec3sContainer for SbVec3s vectors.This field is used where nodes, engines or other field containers needs to store an array of vectors with three elements
oCSoMFVec4bContainer for SbVec4b vectors.This field is used where nodes, engines or other field containers needs to store an array of vectors with four elements
oCSoMFVec4dContainer for SbVec4d vectors.This field is used where nodes, engines or other field containers needs to store an array of vectors with four elements
oCSoMFVec4fContainer for SbVec4f vectors.This field is used where nodes, engines or other field containers needs to store an array of vectors with four elements
oCSoMFVec4i32Container for SbVec4i32 vectors.This field is used where nodes, engines or other field containers needs to store an array of vectors with four elements
oCSoMFVec4sContainer for SbVec4s vectors.This field is used where nodes, engines or other field containers needs to store an array of vectors with four elements
oCSoMFVec4ubContainer for SbVec4ub vectors.This field is used where nodes, engines or other field containers needs to store an array of vectors with four elements
oCSoMFVec4ui32Container for SbVec4ui32 vectors.This field is used where nodes, engines or other field containers needs to store an array of vectors with four elements
oCSoMFVec4usContainer for SbVec4us vectors.This field is used where nodes, engines or other field containers needs to store an array of vectors with four elements
oCSoModelMatrixElementUsed to manage the current transformation.SoModelMatrixElement contains the object-to-world matrix
oCSoMotion3EventInformation about 3D movement events.Motion3 events are generated by devices capable of "3D motion", for instance spaceballs. Instances of this class contains information about these devices' translations and rotations in all 3 dimensions
oCSoMouseButtonEventInformation about mousebutton interaction.When the user presses any buttons on the mouse, these will be translated from a system specific event into a Coin event and sent to the scenegraph by using instances of this class
oCSoMultipleCopyRedraws it's children multiple times at different transformations.The SoMultipleCopy group node duplicates it's children nodes / subgraphs without using additional memory resources
oCSoMultiTextureEnabledElementElement which stores whether texturing is enabled or not.Be aware that this class is an extension for Coin, and it is not available in the original SGI Open Inventor v2.1 API
oCSoMultiTextureImageElementYet to be documented.FIXME: write doc
oCSoMultiTextureMatrixElementUsed to manage the texture matrix stack for texture units > 0.The texture matrix is used to transform texture coordinates before being used to map textures onto polygons
oCSoNodeBase class for nodes used in scene graphs.Coin is a retained mode 3D visualization library (built on top of the immediate mode OpenGL library). "Retained mode" means that instead of passing commands to draw graphics primitives directly to the renderer, you build up data structures which are rendered by the library on demand
oCSoNodeEngineSoNodeEngine is the base class for Coin node engines.Node engines have the same functionality as normal engines, except that they inherit SoNode, which makes it possible to insert node engines in the scene graph
oCSoNodeKitUsed to initialize the nodekit classes.The sole function of SoNodeKit is to be just a placeholder for the toplevel initialization code for all nodekit-related classes
oCSoNodekitCatalogContainer for nodekit layouts.Nodekits store all their hierarchical layout information and part information in instances of this class
oCSoNodeKitDetailYet to be documented.When a pick action is executed and geometry within a nodekit is hit, the nodekit generates an SoNodeKitDetail object which contains information about the specific part inside the nodekit hit by the pick ray
oCSoNodeKitListPartContainer node.This node is basically just a container node with these differences versus the other group nodes:
oCSoNodeKitPathPath that contains only nodekit nodes.All other nodes are hidden from the user
oCSoNodeListContainer for pointers to SoNode objects
oCSoNodeSensorDetects changes to nodes.Attach a node to a sensor of this type to put it under surveillance, so you can act upon changes to the node
oCSoNonIndexedShapeSuperclass for all non-indexed vertex based shapes.It contains the (now obsoleted) startIndex field and a convenience method for calculating the bounding box
oCSoNormalNode for providing normals to the state.Coin will automatically calculate normals for you if no SoNormal nodes are present in the scene graph, but explicitly setting normals is useful for at least two purposes: 1) a potential increase in performance, 2) you can calculate and use "incorrect" normals to do various special effects
oCSoNormalBindingNode for specifying normal vector bindings.Use nodes of this type to specify how to map normal vectors from SoNormal nodes in the scene graph to shape nodes
oCSoNormalBindingElementThe SoNormalBindingElement is yet to be documented.FIXME: write doc
oCSoNormalBundleSimplifies normal handling.This class is currently not used in Coin but is provided for API compatibility
oCSoNormalCacheUsed to hold cached normals.As an extension to the original SGI Open Inventor v2.1 API, it is also possible to generate normals using this class
oCSoNormalElementYet to be documented.FIXME: write doc
oCSoNormalGeneratorUsed to generate normals.FIXME: document properly
oCSoNotListList of SoNotRec notification records
oCSoNotRecRecords for notification lists
oCSoNurbsCurveNode for representing smooth curves.A general explanation of NURBS is beyond the scope of the Coin documentation. For detailed information, refer to the specialized literature on the topic (for example "An Introduction to NURBS: With Historical Perspective" by David F. Rogers). A basic overview of curve and surface rendering using NURBS can be found in chapter 8 of "The Inventor Mentor"
oCSoNurbsProfileNode for specifying smooth profile curves.Use nodes of this type if you want to set up profiles that are smooth curves
oCSoNurbsSurfaceUsed to render smooth surfaces.A general explanation of NURBS is beyond the scope of the Coin documentation. For detailed information, refer to the specialized literature on the topic (for example "An Introduction to NURBS: With Historical Perspective" by David F. Rogers). A basic overview of curve and surface rendering using NURBS can be found in chapter 8 of "The Inventor Mentor"
oCSoOffscreenRendererUsed for rendering scenes in offscreen buffers.If you want to render to a memory buffer instead of an on-screen OpenGL context, use this class. Rendering to a memory buffer can be used to generate texture maps on-the-fly, or for saving snapshots of the scene to disk files (as pixel bitmaps or as Postscript files for sending to a Postscript-capable printer)
oCSoOneShotTimer that runs for a configurable time and then stops
oCSoOneShotSensorSensor which will trigger once.Since SoOneShotSensor is a subclass of SoDelayQueueSensor, it will trigger as soon as either the run-time system is idle, or if it is continually busy it will trigger within a fixed amount of time (this is by default 1/12th of a second, see SoSensorManager::setDelaySensorTimeout())
oCSoOnOffThe SoOnOff engine is a simple on/off switch
oCSoOrthographicCameraDefines a camera node with orthographic rendering.Orthographic rendering will not give a particularly realistic impression of the scene, but non-realistic rendering is for various reasons widely used in applications for e.g. Computer Aided Design
oCSoOutputAbstraction of an output stream.SoOutput offers the ability to write basic types to a file or a memory buffer in either ASCII or binary format
oCSoOverrideElementThe SoOverrideElement maintains a list of overridable elements and a list over which elements should be overridden.Only certain elements can be overridden
oCSoPackedColorNode for setting diffuse and transparency material values.This node provides a convenient way of setting diffuse colors and transparency values with packed 32-bit RGBA vectors
oCSoPathContainer class for traversal path descriptions.SoPath objects contain a list of SoNode pointers and a list of child indices. Indices are necessary to disambiguate situations where a node uses the same node as a child multiple times
oCSoPathListContainer for pointers to SoPath objects.As this class inherits SoBaseList, referencing and dereferencing will default be done on the objects at append(), remove(), insert() etc
oCSoPathSensorDetects changes to paths.If you need to know when a path changes (i.e. nodes in the path has been removed, or new nodes is added), use this sensor to get a notification
oCSoPathSwitchTraverses only when current path matches a configurable path.FILE FORMAT/DEFAULTS:
oCSoPendulumUsed to create oscillating rotations.A smooth transition between rotation0 and rotation1 is created using a cosine function. In the beginning of the cycle, rotation0 is used. Halfway through the cycle, the resulting rotation equals rotation1, and at the end of the cycle, we're at rotation0 again
oCSoPerspectiveCameraDefines a camera node with perspective rendering.For realistic looking 3D scene, the geometry should be rendered with perspective calculations. Use this camera type to accomplish this
oCSoPickActionBase class for picking actions.The basis for all interaction features that Coin provides for the application programmer is the pick actions. Draggers, manipulators, SoSelection nodes, etc all make use of the functionality provided by the pick actions for selecting and manipulating scene geometry in various ways
oCSoPickedPointUsed for specifying picked points.It holds miscellaneous information about the picked point, such as position, normal, texture coordinate and material index in the current material. It might also hold detail information (an SoDetail subclass) for every node in the picked path
oCSoPickedPointListContainer for pointers to SoPickedPoint objects.This list class will delete the picked points when destructed/truncated, or when a picked point in the list is replaced by another picked point The caller is responsible for allocating the picked points passed to the list, but should not deallocate them since this will be handled by the list
oCSoPickRayElementYet to be documented.FIXME: write doc
oCSoPickStyleNode for setting up how to do picking.By default, all geometry in a scene is available for picking. Upon writing applications with interaction possibilities, this is often not what you want. To exclude parts of the scene graph from pick actions, use the SoPickStyle::UNPICKABLE
oCSoPickStyleElementThe SoPickStyleElement is yet to be documented.FIXME: write doc
oCSoPointDetailFor storing detailed information for a single 3D point.Instances of this class are used among other things for storing information about the vertices of lines and polygons after pick operations, and for storing information returned to tessellation callbacks
oCSoPointLightNode type for light sources.Pointlights emits light equally in all directions from a specified 3D location
oCSoPointLightDraggerInteractive geometry for manipulating a point light source.Here's how the dragger looks with its default geometry in the inactive state:
oCSoPointLightManipUsed to manipulate point light nodes.
oCSoPointSetUsed to display a set of 3D points.This node either uses the coordinates currently on the state (typically set up by a leading SoCoordinate3 node in the scenegraph) or from a SoVertexProperty node attached to this node to render a set of 3D points
oCSoPointSizeElementThe SoPointSizeElement changes the pointsize setting of the render state.Requests from the scenegraph to change the pointsize when rendering point primitives will be made through this element
oCSoPolygonOffsetNode type for "layering" rendering primitives.A common problem with realtime 3D rendering systems is that rendered primitives which are at approximately the same depth with regard to the camera viewpoint will appear to flicker. I.e.: from one angle one primitive will appear to be closer, while at another angle, another primitive will appear closer. When this happens, the rendered graphics at that part of the scene will of course look a lot less visually pleasing
oCSoPolygonOffsetElementYet to be documented.FIXME: write doc
oCSoPrimitiveVertexSingle vertex of a generated primitive.Instances of SoPrimitiveVertex are constructed when generating primitive data, primarily during an SoCallbackAction traversal. Depending on the context the vertex could represent a single 3D point, one of the two vertices in a line or one of the three vertices in a triangle
oCSoPrimitiveVertexCache
oCSoProfileAbstract superclass for profile definitions.Node subclasses of SoProfile specifies profiles for extruded 3D text and nurbs surface data
oCSoProfileCoordinate2Node specifying a set of 2D coordinates for profiles.Use nodes of this type to provide coordinates to profiles
oCSoProfileCoordinate3Node specifying a set of 3D coordinates for profiles.Use nodes of this type to provide coordinates to profiles
oCSoProfileCoordinateElementYet to be documented.FIXME: write doc
oCSoProfileElementYet to be documented.FIXME: write doc
oCSoProfilerMain static class for initializing the scene graph profiling subsystem
oCSoProfilerElementThe SoProfilerElement element class is for registering statistics during scene graph traversals
oCSoProfilerStatsNode for exposing profiling results gathered by SoProfilerElement
oCSoProfilingReportGeneratorConvenience report generator functionality
oCSoProtoHandles PROTO definitions
oCSoProtoInstanceHandles PROTO instances
oCSoPSVectorOutputUsed for writing Postscript
oCSoQuadMeshUsed to render and optimize a quadrilateral mesh.This node uses the coordinates in order, either from the state or from the SoQuadMesh::vertexProperty node, to construct a quadrilateral mesh
oCSoRayPickActionDoes ray intersection with scene graphs.For interaction with the scene graph geometry, it is necessary to be able to do intersection testing for rays. This functionality is provided by the SoRayPickAction class
oCSoReadErrorUsed during model import operations.During model file import, this class will be used to output any error or warning messages
oCSoRenderManager
oCSoReorganizeActionReorganizes your scene graph to optimize traversal/rendering
oCSoReplacedElementAbstract element superclass.This is the superclass of all elements where the new element data replaces the old data, and where the data the element stores is not just a simple float or integer value
oCSoResetTransformNode type which makes it possible to "nullify" state during traversal.SoResetTransform is useful for setting up geometry in the scene graph which will not be influenced by the transformation nodes before it during traversal
oCSoRotateCylindricalDraggerFor rotating geometry around a single axis.Here's how the dragger looks with its default geometry in the inactive state:
oCSoRotateDiscDraggerFor rotating geometry around a single axis.Here's how the dragger looks with its default geometry in the inactive state:
oCSoRotateSphericalDraggerFor rotating geometry in any direction.Here's how the dragger looks with its default geometry in the inactive state:
oCSoRotationRotation transformation.Use nodes of this class type to re-orient geometry data within the scene graph
oCSoRotationXYZNode type for specifying rotation around a particular axis.Application programmers can use nodes of this type instead of SoRotation nodes for simplicity and clarity if the rotation will only happen around one particular axis
oCSoRotorNode used to animate rotations.Insert this node in your hierarchy to apply a continuous rotation to some geometry. Since this node inherits the SoRotation node, rotation is restricted around the axis specified in the rotation field
oCSoScaleNode type for scaling scene graph geometry.Use nodes of this type to apply scaling operations during scenegraph traversals for e.g. rendering. Scale values are specified in a triple-value vector, with one scale factor for each of the 3 principal axes
oCSoScale1DraggerMechanism for the end-user to scale in one dimension.Here's how the dragger looks with its default geometry in the inactive state:
oCSoScale2DraggerMechanism for the end-user to scale in two dimensions.Here's how the dragger looks with its default geometry in the inactive state:
oCSoScale2UniformDraggerMechanism for the end-user to scale in two dimensions.Here's how the dragger looks with its default geometry in the inactive state:
oCSoScaleUniformDraggerMechanism for the end-user to scale in three dimensions.Here's how the dragger looks with its default geometry in the inactive state:
oCSoSceneKitCollects node kits needed to set up a scene: camera, light and shapes.Node kit structure (new entries versus parent class marked with arrow prefix):
oCSoSceneManagerMain interface between the scene graph and the GUI toolkit.The renderarea class from the GUI toolkit you are using uses this class as the interface against the scene graph. Event handling and providing "hooks" to do rendering are the main functions of the class
oCSoSceneTexture2Used to create a 2D texture from a Coin scene graph.Lets the rendering of a scene graph be specified as a texture image to be used in another scene graph. Set up the scene graph used for a texture in the SoSceneTexture2::scene field
oCSoSceneTextureCubeMapRenders a scene into a texture cube map
oCSoScXMLEventAdds an SoEvent holder to the ScXMLEvent base
oCSoScXMLStateMachineIntegration level for using Coin events with SCXML-based state machines
oCSoSearchActionMethods for searching through scene graphs.Nodes can be searched for by pointer, type, and name, or a combination of those criteria. Types can be interpreted as exact types, or the type can match nodes derived from it. Every single node can be searched, or normal traversal rules can be followed when searching (this is especially important to note with regard to switch nodes)
oCSoSelectionManages a list of selected nodes.Inserting an SoSelection node in your scene graph enables you to let the user "pick" with the left mousebutton to select/deselect objects below the SoSelection node
oCSoSelectOneUsed to select one value from a set of values.The output field will be the index'th value of the input multivalue field
oCSoSensorAbstract base class for all sensors.Sensors is a mechanism in Coin for scheduling jobs to be run upon specific events. The events in question could be particular points in time, or changes to entities in the scene graph
oCSoSensorManagerHandles the sensor queues.There are two major sensor types in Coin, "delay" sensors and "timer" sensors:
oCSoSeparatorState-preserving group node.Subgraphs parented by SoSeparator nodes will not affect the state, as they push and pop the traversal state before and after traversal of its children
oCSoSeparatorKitTypical set of nodes to influence a shape subgraph.Node kit structure (new entries versus parent class marked with arrow prefix):
oCSoSFBitMaskContainer for a set of bit flags.This field is used where nodes, engines or other field containers needs to store one particular set of bit flags from an enumerated set
oCSoSFBoolContainer for an SbBool value.This field is used where nodes, engines or other field containers needs to store a boolean on/off or TRUE/FALSE value, like for instance as the "on" field of the SoPointLight, SoSpotLight and SoDirectionalLight node classes
oCSoSFBox2dContainer for an SbBox2d vector.This field is used where nodes, engines or other field containers needs to store a box
oCSoSFBox2fContainer for an SbBox2f vector.This field is used where nodes, engines or other field containers needs to store a box
oCSoSFBox2i32Container for an SbBox2i32 vector.This field is used where nodes, engines or other field containers needs to store a box
oCSoSFBox2sContainer for an SbBox2s vector.This field is used where nodes, engines or other field containers needs to store a box
oCSoSFBox3dContainer for an SbBox3d vector.This field is used where nodes, engines or other field containers needs to store a box
oCSoSFBox3fContainer for an SbBox3f vector.This field is used where nodes, engines or other field containers needs to store a box
oCSoSFBox3i32Container for an SbBox3i32 vector.This field is used where nodes, engines or other field containers needs to store a box
oCSoSFBox3sContainer for an SbBox3s vector.This field is used where nodes, engines or other field containers needs to store a box
oCSoSFColorContainer for an SbColor value.This field is used where nodes, engines or other field containers needs to store a single color value (i.e. Red + Green + Blue)
oCSoSFColorRGBAContainer for an SbColor4f value.This field is used where nodes, engines or other field containers needs to store a single color value (i.e. Red + Green + Blue + Alpha)
oCSoSFDoubleContainer for a double precision floating point value.This field is used where nodes, engines or other field containers needs to store a single floating point value
oCSoSFEngineContainer for a single engine.This field container stores a pointer to a Coin engine. It takes care of the necessary functionality for handling copy, import and export operations
oCSoSFEnumContainer for an enum value.This field is used where nodes, engines or other field containers needs to store one particular value out of an enumerated set
oCSoSFFloatContainer for a floating point value.This field is used where nodes, engines or other field containers needs to store a single floating point value
oCSoSFieldBase class for fields which contains only a single value.All field types which should always contain only a single member value inherits this class. SoSField is an abstract class
oCSoSFImageUsed to store pixel images.The SoSFImage class provides storage for inline 2D image maps. Images in Coin are mainly used for texture mapping support
oCSoSFImage3Used to store 3D (volume) images.The SoSFImage3 class provides storage for inline 3D image maps. 3D images in Coin are mainly used for 3D texture mapping support
oCSoSFInt32Container for a 32-bit integer value.This field is used where nodes, engines or other field containers needs to store a single 32-bit integer value
oCSoSFMatrixContainer for an SbMatrix.This field is used where nodes, engines or other field containers needs to store a 4x4 matrix
oCSoSFNameContainer for an SbName.This field is used where nodes, engines or other field containers needs to store a single name string
oCSoSFNodeContainer for a single node.This field container stores a pointer to a Coin node. It takes care of the necessary functionality for handling copy, import and export operations
oCSoSFPathContainer for a single path.This field container stores a pointer to a Coin path. It takes care of the necessary functionality for handling copy, import and export operations
oCSoSFPlaneContainer for an SbPlane value.This field is used where nodes, engines or other field containers needs to store a single definition of a 3D plane
oCSoSFRotationContainer for an SbRotation.This field is used where nodes, engines or other field containers needs to store a single rotation definition
oCSoSFShortContainer for a short integer value.This field is used where nodes, engines or other field containers needs to store a single short integer value
oCSoSFStringContainer for an SbString.This field is used where nodes, engines or other field containers needs to store a single string
oCSoSFTimeContainer for an SbTime value.This field is used where nodes, engines or other field containers needs to store a single time representation
oCSoSFTrigger"void" class used for detecting field changes.Connect this field to a master field (or engine output) to detect when the master field changes its value
oCSoSFUInt32Container for a 32-bit unsigned integer value.This field is used where nodes, engines or other field containers needs to store a single 32-bit unsigned integer value
oCSoSFUShortContainer for a unsigned short integer value.This field is used where nodes, engines or other field containers needs to store a single short unsigned integer value
oCSoSFVec2bContainer for an SbVec2b vector.This field is used where nodes, engines or other field containers needs to store a single vector with two elements
oCSoSFVec2dContainer for an SbVec2d vector.This field is used where nodes, engines or other field containers needs to store a single vector with two elements
oCSoSFVec2fContainer for an SbVec2f vector.This field is used where nodes, engines or other field containers needs to store a single vector with two elements
oCSoSFVec2i32Container for an SbVec2i32 vector.This field is used where nodes, engines or other field containers needs to store a single vector with two elements
oCSoSFVec2sContainer for an SbVec2s vector.This field is used where nodes, engines or other field containers needs to store a single vector with two elements
oCSoSFVec3bContainer for an SbVec3b vector.This field is used where nodes, engines or other field containers needs to store a single vector with three elements
oCSoSFVec3dContainer for an SbVec3d vector.This field is used where nodes, engines or other field containers needs to store a single vector with three elements
oCSoSFVec3fContainer for an SbVec3f vector.This field is used where nodes, engines or other field containers needs to store a single vector with three elements
oCSoSFVec3i32Container for an SbVec3i32 vector.This field is used where nodes, engines or other field containers needs to store a single vector with three elements
oCSoSFVec3sContainer for an SbVec3s vector.This field is used where nodes, engines or other field containers needs to store a single vector with three elements
oCSoSFVec4bContainer for an SbVec4b vector.This field is used where nodes, engines or other field containers needs to store a single vector with four elements
oCSoSFVec4dContainer for an SbVec4d vector.This field is used where nodes, engines or other field containers needs to store a single vector with four elements
oCSoSFVec4fContainer for an SbVec4f vector.This field is used where nodes, engines or other field containers needs to store a single vector with four elements
oCSoSFVec4i32Container for an SbVec4i32 vector.This field is used where nodes, engines or other field containers needs to store a single vector with four elements
oCSoSFVec4sContainer for an SbVec4s vector.This field is used where nodes, engines or other field containers needs to store a single vector with four elements
oCSoSFVec4ubContainer for an SbVec4ub vector.This field is used where nodes, engines or other field containers needs to store a single vector with four elements
oCSoSFVec4ui32Container for an SbVec4ui32 vector.This field is used where nodes, engines or other field containers needs to store a single vector with four elements
oCSoSFVec4usContainer for an SbVec4us vector.This field is used where nodes, engines or other field containers needs to store a single vector with four elements
oCSoShaderObject
oCSoShaderParameter
oCSoShaderProgramUsed to specify a set of vertex/geometry/fragment objects
oCSoShadowCullingNode for setting the shadow style on nodes
oCSoShadowGroupThe SoShadowGroup node is a group node used for shadow rendering.Children of this node can recieve shadows, and cast shadows on other children. Use the SoShadowStyle node to control shadow casters and shadow receivers
oCSoShadowSpotLightNode for setting up a spot light which casts shadows
oCSoShadowStyleNode for setting the shadow style on nodes
oCSoShadowStyleElementYet to be documented.FIXME: write doc
oCSoShapeSuperclass for geometry shapes.The node types which have actual geometry to render inherits this class. For convenience, the SoShape class contains various common code used by the subclasses
oCSoShapeHintsNode containing hints about how to render geometry.The SoShapeHints node is used to set up clues to the rendering subsystem about how particular aspects of the subsequent geometry in the scene graph should be drawn
oCSoShapeKitTemplates to insert what is usually needed for shape nodes.Node kit structure (new entries versus parent class marked with arrow prefix):
oCSoShapeSimplifyActionReplaces complex primitives with simplified polygon representations
oCSoShapeStyleElementYet to be documented.FIXME: write doc
oCSoShininessElementYet to be documented.FIXME: write doc
oCSoShuttleUsed to oscillate between two translations.A smooth transition between translation0 and translation1 is created using a cosine function. In the beginning of the cycle, translation0 is used. Halfway through the cycle, the resulting translation equals translation1, and at the end of the cycle, we're at translation0 again
oCSoSimplifyActionBase class for the simplify action classes
oCSoSoundElementThe SoSoundElement is used for optimizing audio rendering and for turning off inactive SoVRMLSound nodes
oCSoSpaceballButtonEventInformation about spaceball button interaction.When the user presses any buttons on a spaceball device, these will be translated from a system specific event into a Coin event and sent to the scenegraph by using instances of this class
oCSoSpecularColorElementThe SoSpecularColorElement is yet to be documented.FIXME: write doc
oCSoSphereFor rendering sphere shapes.Renders a sphere with the size given by the SoSphere::radius field. The sphere is rendered with the current material, texture and drawstyle settings (if any, otherwise the default settings are used)
oCSoSpotLightNode type for light sources with a cone shaped lightvolume.Spotlights are light sources with a position and a direction. They can be thought of as a pointlight with a lampshade
oCSoSpotLightDraggerInteractive geometry for manipulating a spotlight.Here's how the dragger looks with its default geometry in the inactive state:
oCSoSpotLightManipUsed to manipulate spot light nodes.
oCSoStateManages the Coin scenegraph traversal state data.The SoState class is used by actions derived from the SoAction class. It manages the scenegraph state as stacks of elements (ie instances of classes derived from SoElement)
oCSoSTLFileKitSoSTLFileKit is a class for using STL files with Coin
oCSoSurroundScaleUsed to automatically scale geometry to surround other geometry.This node calculates a transformation (a translation and a scale) which will, when the node is traversed, be appended to the current model matrix, making a default cube placed directly to the right of this node in the graph surround geometry to the right of the container branch this node is on. The container is specified by the field SoSurroundScale::numNodesUpToContainer
oCSoSwitchGroup node which selects one child subgraph for traversal.Which child to traverse is controlled by the application programmer by using the SoSwitch::whichChild field. In addition to picking out a single child for traversal, it is also possible to flip all children on or off for traversal
oCSoSwitchElementYet to be documented.FIXME: write doc
oCSoTabBoxDraggerThe SoTabBoxDragger wraps a box around geometry you can then translate and scale.Here's how the dragger looks with its default geometry in the inactive state:
oCSoTabBoxManipWraps an SoTabBoxDragger.
oCSoTabPlaneDraggerDragger you can translate and scale within a plane.Here's how the dragger looks with its default geometry in the inactive state:
oCSoTempPathUsed to store temporary paths.The path simply turns off auditing in the constructor, and leaves the user with the responsibility of keeping the path valid
oCSoText2Node type for visualizing 2D text aligned with the camera plane.SoText2 text is not scaled according to the distance from the camera, and is not influenced by rotation or scaling as 3D primitives are. If these are properties that you want the text to have, you should instead use an SoText3 or SoAsciiText node
oCSoText3Renders extruded 3D text.Render text as 3D geometry
oCSoTextDetailThe SoTextDetail stores information about a character in a string.Instances of this class are used for storing information about hit points on textual 2D or 3D geometry after pick operations, and for storing information returned to tessellation callbacks
oCSoTextOutlineEnabledElementYet to be documented.FIXME: write doc
oCSoTexture2Used to map a 2D texture onto subsequent geometry in the scenegraph.Shape nodes within the scope of SoTexture2 nodes in the scenegraph (ie below the same SoSeparator and to the righthand side of the SoTexture2) will have the texture applied according to each shape type's individual characteristics. See the documentation of the various shape types (SoFaceSet, SoCube, SoSphere, etc etc) for information about the specifics of how the textures will be applied
oCSoTexture2ConvertAbstract base class for texture filtering engines
oCSoTexture2TransformUsed to define 2D texture transformations.Textures applied to shapes in the scene can be transformed by "prefixing" in the state with instances of this node type. Translations, rotations and scaling in 2D can all be done
oCSoTexture3Used to map a 3D texture onto geometry.Shape nodes within the scope of SoTexture3 nodes in the scenegraph (ie below the same SoSeparator and to the righthand side of the SoTexture3) will have the texture applied according to each shape type's individual characteristics. See the documentation of the various shape types (SoFaceSet, SoCube, SoSphere, etc etc) for information about the specifics of how the textures will be applied. An SoTexture3 node will override any previous encountered SoTexture2 nodes and vice versa. Mixing of SoTexture3 and SoTextureCoordinate2 (or the other way around) is legal, but the third texture coordinate component will be ignored (set to 0.0)
oCSoTexture3TransformUsed to define 3D texture transformations.Textures applied to shapes in the scene can be transformed by "prefixing" in the state with instances of this node type. Translations, rotations and scaling in 3D can all be done
oCSoTextureCombineNode for setting texture combine functions.This node is more or less an exact mapping of the OpenGL ARB_texture_env_combine extension (included in OpenGL in OpenGL v1.3). See http://oss.sgi.com/projects/ogl-sample/registry/ARB/texture_env_combine.txt for more information about this extension
oCSoTextureCombineElementYet to be documented.FIXME: write doc
oCSoTextureCoordinate2Set of coordinates for the mapping of 2D textures.When encountering nodes of this type during traversal, the coordinates it contains will be put on the state stack. Some shape nodes (for instance SoIndexedFaceSet, among many others) can then use these coordinates for explicit, detailed control of how textures are mapped to it's surfaces
oCSoTextureCoordinate3Set of coordinates for the mapping of 2D textures.When encountering nodes of this type during traversal, the coordinates it contains will be put on the state stack. Some shape nodes can then use these coordinates for explicit, detailed control of how 3D textures are mapped
oCSoTextureCoordinateBindingSays how texture coordinates should be bound to shapes.SoTextureCoordinateBinding binds current coordinates to subsequent shapes by using either per vertex or per indexed vertex binding
oCSoTextureCoordinateBindingElementYet to be documented.FIXME: write doc
oCSoTextureCoordinateBundleSimplifies texture coordinate handling.It is unlikely that application programmers should need to know how to use this class, as it is mostly intended for internal use
oCSoTextureCoordinateCache
oCSoTextureCoordinateCubeAutogenerates cubemapped texture coordinated for shapes.The cube used for reference when mapping is the boundingbox for the shape
oCSoTextureCoordinateCylinderAutogenerates cylinder mapped texture coordinated for shapes.FILE FORMAT/DEFAULTS:
oCSoTextureCoordinateDefaultRemoves texture coordinates from the state.Shapes below this node in the scenegraph will have to use its default texture coordinates as SoTextureCoordinateDefault cleans out all previously defined texture coordinates and texture coordinate functions
oCSoTextureCoordinateElementYet to be documented.FIXME: write doc
oCSoTextureCoordinateEnvironmentGenerates texture coordinates by projecting onto a surrounding texture.The texture specifying the enviroment will be mapped around the scenegraph below this node using a sphere. The texture will be mapped onto the scenegraph taking camera position into account. This will lead to an object reflecting its enviroment
oCSoTextureCoordinateFunctionAbstract base class for texture coordinate generating nodesClasses reimplementing SoTextureCoordinateFunction generate texture coordinates by projecting object space surface points using some function
oCSoTextureCoordinateNormalMapGenerates texture coordinates by projecting onto a surrounding texture.The texture specifying the enviroment will be mapped around the scenegraph below this node using a sphere. The texture will be mapped onto the scenegraph taking camera position into account. This will lead to an object reflecting its enviroment
oCSoTextureCoordinateObjectGenerates texture coordinates by...FIXME: not implemented yet. pederb, 2005-04-20
oCSoTextureCoordinatePlaneGenerates texture coordinates by projecting onto a plane.SoTextureCoordinatePlane is used for generating texture coordinates by projecting the object onto a texture plane. The s, t and r texture coordinates are computed as the distance from the origin to the projected point, in the respective directions. The texture plane is specified using two direction vectors, given as SoTextureCoordinatePlane::directionS and SoTextureCoordinatePlane::directionT in object space coordinates. SoTextureCoordinatePlane::directionR is used for generating the third coordinate, and can be used for generating texture coordinate for 3D textures. For 2D textures you can just leave this field alone
oCSoTextureCoordinateReflectionMapGenerates 3D reflection texture coordinates.This node is usually used along with a SoCubeMapTexture node..
oCSoTextureCoordinateSphereAutogenerates spheremapped texture coordinated for shapes.FILE FORMAT/DEFAULTS:
oCSoTextureCubeMapUsed to map a cube map onto subsequent shape nodes.Shape nodes within the scope of SoTextureCubeMap nodes in the scenegraph (ie below the same SoSeparator and to the righthand side of the SoTextureCubeMap) will have the texture applied according to each shape type's individual characteristics. See the documentation of the various shape types (SoFaceSet, SoCube, SoSphere, etc etc) for information about the specifics of how the textures will be applied
oCSoTextureEnabledElementElement which stores whether texturing is enabled or not.Be aware that this class is an extension for Coin, and it is not available in the original SGI Open Inventor v2.1 API
oCSoTextureImageElementYet to be documented.FIXME: write doc
oCSoTextureMatrixElementUsed to manage the texture matrix stack.The texture matrix is used to transform texture coordinates before being used to map textures onto polygons
oCSoTextureMatrixTransformUsed to define a texture matrix transformation.Textures applied to shapes in the scene can be transformed by "prefixing" in the state with instances of this node type
oCSoTextureOverrideElementThe SoTextureOverrideElement makes it possible to override texture elements
oCSoTextureQualityElementThe SoTextureQualityElement is yet to be documented.FIXME: write doc
oCSoTextureScalePolicyNode for controlling the texture scale policy.If a texture map is of size != 2^n, it must be scaled before OpenGL can handle it. This node enables you to control how/if textures are scaled before it is sent to OpenGL
oCSoTextureUnitNode for setting the active texture unit.When an SoTextureUnit node is inserted into the scene graph, all subsequent texture nodes (SoTexture2, SoTextureCoordinate2, SoTextureCoordinate3, SoTexture2Transform, SoTexture3Transform, SoTextureCoordinateEnvironment, SoTextureCoordinatePlane and SoComplexity) will affect the texture unit set in the unit field
oCSoTextureUnitElementYet to be documented
oCSoTimeCounterInteger counter engine.The SoTimeCounter engine is by default connected to the realTime global field, and does stepwise updates on the SoTimeCounter::output field according to the field settings
oCSoTimerQueueSensorAbstract base class for sensors triggering on certain timer events.Timer sensors triggers upon specific points in time
oCSoTimerSensorSensor which will trigger at given intervals.Use sensors of this class when you want a job repeated at a certain interval, without explicitly needing to reschedule the sensor (i.e. SoTimerSensor automatically re-schedules itself after it has been triggered)
oCSoToVRML2ActionBuilds a new scene graph, using only VRML97/VRML2 nodes.This action is used for converting a scene graph of VRML1/Coin nodes to a new scene graph using only VRML97/VRML2 nodes
oCSoToVRMLActionBuilds a new scene graph using only VRML 1.0 nodes.This action is used for converting a scene graph of VRML2/VRML97 nodes to a new scene graph using only VRML1 compatible nodes
oCSoTrackballDraggerThe SoTrackballDragger provides the end-user with rotation and scaling interaction possibilities.Here's how the dragger looks with its default geometry in the inactive state:
oCSoTrackballManipThe SoTrackballManip wraps an SoTrackballDragger for convenience.
oCSoTransform"all-purpose" transformation node type.Like SoMatrixTransform, nodes of this type gives the application programmer maximum flexibility when specifying geometry transformations in a scene graph. If you want to set and keep the various components of the transformation matrix in separate entities, this node type is preferable, though
oCSoTransformationAbstract base class for transformation nodes.To position and orient geometry within the 3D world space, various node types for transformations are used. These nodes all inherit the SoTransformation base class
oCSoTransformBoxDraggerThe SoTransformBoxDragger provides a box which can be translated, scaled and rotated.Here's how the dragger looks with its default geometry in the inactive state:
oCSoTransformBoxManipThe SoTransformBoxManip wraps an SoTransformBoxDragger for convenience.
oCSoTransformerDraggerThe SoTransformerDragger provides geometry for translation, scaling and rotations.Here's how the dragger looks with its default geometry in the inactive state:
oCSoTransformerManipThe SoTransformerManip wraps an SoTransformerDragger for convenience.
oCSoTransformManipUsed to manipulate transformations.A manipulator is used by replacing the node you want to edit in the graph with the manipulator. Draggers are used to to manipulate the node. When manipulation is finished, the node is put back into the graph, replacing the manipulator
oCSoTransformSeparatorGroup node preserving the current transformations.This node works like the SoSeparator group node, except that it only stores and restores the current model matrix transformation. Other appearance settings, like materials, textures, cameras, lights, etc, will affect the remaining parts of the scenegraph after traversal, just like as for the SoGroup node
oCSoTransformVec3fTransforms 3D vectors by a matrix
oCSoTranslate1DraggerMechanism for the end-user to translate along an axis.Here's how the dragger looks with its default geometry in the inactive state:
oCSoTranslate2DraggerMechanism for the end-user to translate in a plane.Here's how the dragger looks with its default geometry in the inactive state:
oCSoTranslationNode type for specifying geometry translations.For simply translating some geometry in a scene graph, you can use this node type
oCSoTransparencyElementThe SoTransparencyElement is yet to be documented.FIXME: write doc
oCSoTransparencyTypeNode for setting the transparency type for shapes.In earlier versions of Coin/Open Inventor it was only possible to set the transparency mode globally for an entire scene graph, which could be inconvenient if different transparency types was wanted for different shapes
oCSoTriangleStripSetUsed to render and control non-indexed triangle strips.Triangle strips are specified using the numVertices field
oCSoTriggerAnyFan-in engine for triggers.When any one of the input triggers are "pulsed", any field connected as a slave to the engine output will be notified
oCSoTypeBasis for the run-time type system in Coin.Many of the classes in the Coin library must have their type information registered before any instances are created (including, but not limited to: engines, nodes, fields, actions, nodekits and manipulators). The use of SoType to store this information provides lots of various functionality for working with class hierarchies, comparing class types, instantiating objects from classnames, etc etc
oCSoTypeListContainer class for arrays of SoType objects
oCSoUnitsNode for setting unit types.Even though Coin doesn't care what units you are using in your scene graph per se, there's an advantage to using SoUnits nodes: you have a way to split your scene graph into different "conceptual" parts
oCSoUnitsElementYet to be documented.FIXME: write doc
oCSoVectorizeActionBase class for vectorizing Coin scene graphs.SoVectorizeAction will traverse the scene graph and convert all supported geometry into vectorized data. Subclasses can then use this data to produce vector files of different formats
oCSoVectorizePSActionUsed for rendering to a Postscript file
oCSoVectorOutputUsed for setting vector output file.SoVectorizeAction will create an SoVectorOutput which will output to stdout by default. SoVectorizeAction::getOutput() can be used to fetch this output, and the user will probably want to set a file to output to
oCSoVertexAttributeA generic node for providing GL vertex attributes of various types
oCSoVertexAttributeBindingNode for setting up how vertex attributes are mapped to shapes
oCSoVertexAttributeBindingElementYet to be documented.FIXME: write doc
oCSoVertexAttributeBundleSimplifies vertex attribute handling
oCSoVertexPropertyCollects the functionality of various appearance nodes.Instead of reading data from the current state stack of the scenegraph traversal, nodes inheriting SoVertexShape can be set up with an SoVertexProperty node in the SoVertexShape::vertexProperty field. Coordinates, normals, texture coordinates and material / color information will then be fetched from the vertexshape's SoVertexProperty node instead of from the state stack
oCSoVertexShaderUsed for setting up vertex shader programs.See Shaders in Coin for more information on how to set up a scene graph with shaders
oCSoVertexShapeSuperclass for all vertex based shapes.Basically, every polygon-, line- or point-based shape will inherit this class. It contains methods for organizing the normal cache, and also holds the SoVertexShape::vertexProperty field which can be used to set vertex data inside the node
oCSoViewingMatrixElementStores the world-to-camera transformation
oCSoViewportRegionElementYet to be documented.FIXME: write doc
oCSoViewVolumeElementYet to be documented.FIXME: write doc
oCSoVRMLAnchorUsed for linking to other URL resources.The detailed class documentation is taken verbatim from the VRML97 standard (ISO/IEC 14772-1:1997). It is copyright The Web3D Consortium, and is used by permission of the Consortium:
oCSoVRMLAppearanceVisual properties for shapes.The detailed class documentation is taken verbatim from the VRML97 standard (ISO/IEC 14772-1:1997). It is copyright The Web3D Consortium, and is used by permission of the Consortium:
oCSoVRMLAudioClipUsed to load and store audio data.Audio data is loaded using the simage library, so make sure you have built the simage library with support for the audio file formats you intend to use (libogg, libvorbis and libvorbisfile for OggVorbis, libsndfile for WAV and several other formats)
oCSoVRMLBackgroundUsed for specifying a viewer panorama.The detailed class documentation is taken verbatim from the VRML97 standard (ISO/IEC 14772-1:1997). It is copyright The Web3D Consortium, and is used by permission of the Consortium:
oCSoVRMLBillboardUsed for rotating geometry towards the viewpoint.The detailed class documentation is taken verbatim from the VRML97 standard (ISO/IEC 14772-1:1997). It is copyright The Web3D Consortium, and is used by permission of the Consortium:
oCSoVRMLBoxUsed for representing a 3D box.The detailed class documentation is taken verbatim from the VRML97 standard (ISO/IEC 14772-1:1997). It is copyright The Web3D Consortium, and is used by permission of the Consortium:
oCSoVRMLCollisionUsed for collision detection with the avatar.The detailed class documentation is taken verbatim from the VRML97 standard (ISO/IEC 14772-1:1997). It is copyright The Web3D Consortium, and is used by permission of the Consortium:
oCSoVRMLColorUsed to specify multiple colors for a single shape.The detailed class documentation is taken verbatim from the VRML97 standard (ISO/IEC 14772-1:1997). It is copyright The Web3D Consortium, and is used by permission of the Consortium:
oCSoVRMLColorInterpolatorUsed to interpolate color values.The detailed class documentation is taken verbatim from the VRML97 standard (ISO/IEC 14772-1:1997). It is copyright The Web3D Consortium, and is used by permission of the Consortium:
oCSoVRMLConeUsed to represent a Cone object.The detailed class documentation is taken verbatim from the VRML97 standard (ISO/IEC 14772-1:1997). It is copyright The Web3D Consortium, and is used by permission of the Consortium:
oCSoVRMLCoordinateUsed to define 3D coordinates for shapes.The detailed class documentation is taken verbatim from the VRML97 standard (ISO/IEC 14772-1:1997). It is copyright The Web3D Consortium, and is used by permission of the Consortium:
oCSoVRMLCoordinateInterpolatorUsed to interpolate 3D coordinates.The detailed class documentation is taken verbatim from the VRML97 standard (ISO/IEC 14772-1:1997). It is copyright The Web3D Consortium, and is used by permission of the Consortium:
oCSoVRMLCylinderUsed to represent a cylinder object.The detailed class documentation is taken verbatim from the VRML97 standard (ISO/IEC 14772-1:1997). It is copyright The Web3D Consortium, and is used by permission of the Consortium:
oCSoVRMLCylinderSensorMaps pointer motion into rotations around the Y axis.The detailed class documentation is taken verbatim from the VRML97 standard (ISO/IEC 14772-1:1997). It is copyright The Web3D Consortium, and is used by permission of the Consortium:
oCSoVRMLDirectionalLightNode type for specifying directional light sourcesThe detailed class documentation is taken verbatim from the VRML97 standard (ISO/IEC 14772-1:1997). It is copyright The Web3D Consortium, and is used by permission of the Consortium:
oCSoVRMLDragSensorSuperclass for VRML drag sensors
oCSoVRMLElevationGridUsed to represent elevation grids.The detailed class documentation is taken verbatim from the VRML97 standard (ISO/IEC 14772-1:1997). It is copyright The Web3D Consortium, and is used by permission of the Consortium:
oCSoVRMLExtrusionA geometry node for extruding a cross section along a spine.The detailed class documentation is taken verbatim from the VRML97 standard (ISO/IEC 14772-1:1997). It is copyright The Web3D Consortium, and is used by permission of the Consortium:
oCSoVRMLFogUsed to specify a global scene fog.The detailed class documentation is taken verbatim from the VRML97 standard (ISO/IEC 14772-1:1997). It is copyright The Web3D Consortium, and is used by permission of the Consortium:
oCSoVRMLFontStyleUsed to define the current font.Important note: currently, the SoVRMLText node implementation is not complete, and some of the features mentioned in the documentation below may not be working yet
oCSoVRMLGeometrySuperclass for VRML shapes
oCSoVRMLGroupUsed for grouping VRML nodes.The detailed class documentation is taken verbatim from the VRML97 standard (ISO/IEC 14772-1:1997). It is copyright The Web3D Consortium, and is used by permission of the Consortium:
oCSoVRMLImageTextureUsed for mapping a texture file onto geometry.The detailed class documentation is taken verbatim from the VRML97 standard (ISO/IEC 14772-1:1997). It is copyright The Web3D Consortium, and is used by permission of the Consortium:
oCSoVRMLIndexedFaceSetUsed for representing a generic 3D shape.The detailed class documentation is taken verbatim from the VRML97 standard (ISO/IEC 14772-1:1997). It is copyright The Web3D Consortium, and is used by permission of the Consortium:
oCSoVRMLIndexedLineAbstract superclass for lines specified with indices.This API member is considered internal to the library, as it is not likely to be of interest to the application programmer.
oCSoVRMLIndexedLineSetUsed to represent a generic 3D line shape.The detailed class documentation is taken verbatim from the VRML97 standard (ISO/IEC 14772-1:1997). It is copyright The Web3D Consortium, and is used by permission of the Consortium:
oCSoVRMLIndexedShapeSuperclass for geometry that use indexes
oCSoVRMLInlineUsed to insert VRML files into a scene.The detailed class documentation is taken verbatim from the VRML97 standard (ISO/IEC 14772-1:1997). It is copyright The Web3D Consortium, and is used by permission of the Consortium:
oCSoVRMLInterpolatorInternal abstract class
oCSoVRMLLightSuperclass for VRML light nodes
oCSoVRMLLODUsed to represent various levels of detail based on distance.The detailed class documentation is taken verbatim from the VRML97 standard (ISO/IEC 14772-1:1997). It is copyright The Web3D Consortium, and is used by permission of the Consortium:
oCSoVRMLMaterialUsed to assign a material to geometry.The detailed class documentation is taken verbatim from the VRML97 standard (ISO/IEC 14772-1:1997). It is copyright The Web3D Consortium, and is used by permission of the Consortium:
oCSoVRMLMovieTextureUsed the map movies onto geometry.The detailed class documentation is taken verbatim from the VRML97 standard (ISO/IEC 14772-1:1997). It is copyright The Web3D Consortium, and is used by permission of the Consortium:
oCSoVRMLNavigationInfoUsed to specify avatar and viewer settings.The detailed class documentation is taken verbatim from the VRML97 standard (ISO/IEC 14772-1:1997). It is copyright The Web3D Consortium, and is used by permission of the Consortium:
oCSoVRMLNormalUsed to bind normals to geometry.The detailed class documentation is taken verbatim from the VRML97 standard (ISO/IEC 14772-1:1997). It is copyright The Web3D Consortium, and is used by permission of the Consortium:
oCSoVRMLNormalInterpolatorUsed to interpolate normals.The detailed class documentation is taken verbatim from the VRML97 standard (ISO/IEC 14772-1:1997). It is copyright The Web3D Consortium, and is used by permission of the Consortium:
oCSoVRMLOrientationInterpolatorUsed to interpolate orientations.The detailed class documentation is taken verbatim from the VRML97 standard (ISO/IEC 14772-1:1997). It is copyright The Web3D Consortium, and is used by permission of the Consortium:
oCSoVRMLParentThe SoVRMLParent node is a superclass for all VRML grouping nodes
oCSoVRMLPixelTextureUsed for mapping a texture image onto geometry..The detailed class documentation is taken verbatim from the VRML97 standard (ISO/IEC 14772-1:1997). It is copyright The Web3D Consortium, and is used by permission of the Consortium:
oCSoVRMLPlaneSensorMaps pointer motion into object space translations.The detailed class documentation is taken verbatim from the VRML97 standard (ISO/IEC 14772-1:1997). It is copyright The Web3D Consortium, and is used by permission of the Consortium:
oCSoVRMLPointLightUsed to represent a point light.The detailed class documentation is taken verbatim from the VRML97 standard (ISO/IEC 14772-1:1997). It is copyright The Web3D Consortium, and is used by permission of the Consortium:
oCSoVRMLPointSetUsed to represent a set of 3D points.The detailed class documentation is taken verbatim from the VRML97 standard (ISO/IEC 14772-1:1997). It is copyright The Web3D Consortium, and is used by permission of the Consortium:
oCSoVRMLPositionInterpolatorUsed to interpolate 3D points.The detailed class documentation is taken verbatim from the VRML97 standard (ISO/IEC 14772-1:1997). It is copyright The Web3D Consortium, and is used by permission of the Consortium:
oCSoVRMLProximitySensorUsed to generate events when the viewer enters or exits a region.The detailed class documentation is taken verbatim from the VRML97 standard (ISO/IEC 14772-1:1997). It is copyright The Web3D Consortium, and is used by permission of the Consortium:
oCSoVRMLScalarInterpolatorUsed to interpolate scalar values
oCSoVRMLScriptUsed to control the scene using scripts.The detailed class documentation is taken verbatim from the VRML97 standard (ISO/IEC 14772-1:1997). It is copyright The Web3D Consortium, and is used by permission of the Consortium:
oCSoVRMLSensorAbstract superclass for VRML sensors
oCSoVRMLShapeHolds geometry and geometry appearance nodes.The detailed class documentation is taken verbatim from the VRML97 standard (ISO/IEC 14772-1:1997). It is copyright The Web3D Consortium, and is used by permission of the Consortium:
oCSoVRMLSoundUsed to represent a sound source.The detailed class documentation is taken verbatim from the VRML97 standard (ISO/IEC 14772-1:1997). It is copyright The Web3D Consortium, and is used by permission of the Consortium:
oCSoVRMLSphereUsed to represent a spherical 3D object.The detailed class documentation is taken verbatim from the VRML97 standard (ISO/IEC 14772-1:1997). It is copyright The Web3D Consortium, and is used by permission of the Consortium:
oCSoVRMLSphereSensorMaps pointer motion into rotations on a sphere.The detailed class documentation is taken verbatim from the VRML97 standard (ISO/IEC 14772-1:1997). It is copyright The Web3D Consortium, and is used by permission of the Consortium:
oCSoVRMLSpotLightDefines a spot light source.The detailed class documentation is taken verbatim from the VRML97 standard (ISO/IEC 14772-1:1997). It is copyright The Web3D Consortium, and is used by permission of the Consortium:
oCSoVRMLSwitchGroup node for traversing selected children.The detailed class documentation is taken verbatim from the VRML97 standard (ISO/IEC 14772-1:1997). It is copyright The Web3D Consortium, and is used by permission of the Consortium:
oCSoVRMLTextUsed to represent text in a scene.The detailed class documentation is taken verbatim from the VRML97 standard (ISO/IEC 14772-1:1997). It is copyright The Web3D Consortium, and is used by permission of the Consortium:
oCSoVRMLTextureSuperclass for VRML texture nodes
oCSoVRMLTextureCoordinateBinds texture coordinates to vertex-based geometry.The detailed class documentation is taken verbatim from the VRML97 standard (ISO/IEC 14772-1:1997). It is copyright The Web3D Consortium, and is used by permission of the Consortium:
oCSoVRMLTextureTransformDefines a transformation applied to texture coordinates.The detailed class documentation is taken verbatim from the VRML97 standard (ISO/IEC 14772-1:1997). It is copyright The Web3D Consortium, and is used by permission of the Consortium:
oCSoVRMLTimeSensorMulti-purpose time event generator.The detailed class documentation is taken verbatim from the VRML97 standard (ISO/IEC 14772-1:1997). It is copyright The Web3D Consortium, and is used by permission of the Consortium:
oCSoVRMLTouchSensorTracks to pointer position and sends events based on user interaction.The detailed class documentation is taken verbatim from the VRML97 standard (ISO/IEC 14772-1:1997). It is copyright The Web3D Consortium, and is used by permission of the Consortium:
oCSoVRMLTransformGrouping node that defines a transformation for its children.The detailed class documentation is taken verbatim from the VRML97 standard (ISO/IEC 14772-1:1997). It is copyright The Web3D Consortium, and is used by permission of the Consortium:
oCSoVRMLVertexLineSuperclass for line based VRML geometry
oCSoVRMLVertexPointSuperclass for point based VRML shapes
oCSoVRMLVertexShapeSuperclass for vertex based shapes
oCSoVRMLViewpointPerspective camera class.The detailed class documentation is taken verbatim from the VRML97 standard (ISO/IEC 14772-1:1997). It is copyright The Web3D Consortium, and is used by permission of the Consortium:
oCSoVRMLVisibilitySensorWill generate events based on visibility.The detailed class documentation is taken verbatim from the VRML97 standard (ISO/IEC 14772-1:1997). It is copyright The Web3D Consortium, and is used by permission of the Consortium:
oCSoVRMLWorldInfoInformation about the VRML scene.The detailed class documentation is taken verbatim from the VRML97 standard (ISO/IEC 14772-1:1997). It is copyright The Web3D Consortium, and is used by permission of the Consortium:
oCSoWindowElementUsed to store current window attributes.In Coin, this element is not API-compatible with SGI Inventor, since it contains platform specific stuff, which we want to avoid
oCSoWrapperKitSimple kit for wrapping a transform and a sub-graph
oCSoWriteActionWrites a scene graph to file.When applied to a scene, this action writes its contents to the stream contained within an SoOutput instance. This can be a file, a memory buffer or a system filehandle like stdout, for instance
oCSoWWWAnchorAdds URL callbacks to the highlighted geometry.In addition to highlighting geometry under the cursor, the application programmer can set callbacks. It is possible to set one callback for picking, the fetch callback, and one callback for highlighting
\CSoWWWInlineNode used to include data from an URL.If the URL is not a local file, the application is responsible for supplying a callback to a function which will fetch the data of the URL

Copyright © 1998-2010 by Kongsberg Oil & Gas Technologies. All rights reserved.

Generated on Fri Sep 9 2016 for Coin by Doxygen 1.8.5.