http://www.coin3d.org/
|
|
http://www.sim.no/ http://www.coin3d.org/ |
| SbBarrier | Implements 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 |
| SbBox2d | 2 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 |
| SbBox2f | 2 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 |
| SbBox2s | 2 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 |
| SbBox3d | Abstraction 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 |
| SbBox3f | Abstraction 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 |
| SbBox3s | 3 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 |
| SbBSPTree | Binary space partitioning container. This class can be used to organize searches for 3D points or normals in a set in O(log(n)) time |
| SbClip | Generic 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 |
| SbColor | Red, 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 |
| SbColor4f | Red, 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 |
| SbCondVar | A class for synchronizing access to global variables. Condition variables are used to protect global variables in an environment where multiple threads are running concurrently |
| SbCylinder | Representation 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 |
| SbCylinderPlaneProjector | Projects 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 |
| SbCylinderProjector | Abstract base class for mapping to cylindrical surfaces. The cylinder projectors map 2D points to various surface types based on cylindrical shapes |
| SbCylinderSectionProjector | The 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 |
| SbCylinderSheetProjector | Projects 2D points to 3D points on a sheet covering a cylindrical shape |
| SbDict | Organizes 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 |
| SbFifo | A class for managing a pointer first-in, first-out queue |
| SbImage | Abstract 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 |
| SbIntList | Container for integer list arrays |
| SbLine | Line in 3D space. SbLine provides a way of specifying a directed line, through a 3D point (origin) and a vector direction in 3D space |
| SbLineProjector | Projects 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 |
| SbList< Type > | The 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 |
| SbMatrix | 4x4 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 |
| SbMutex | A basic class for managing a mutex. This class provides a portable framework around the mutex interface of the underlying native thread-handling toolkit |
| SbName | Stores 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) |
| SbPlane | Plane in 3D space. SbPlane 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 |
| SbPlaneProjector | Projects 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 |
| SbPList | Container class for void pointers |
| SbProfilingData | Data structure for gathering scene graph traversal profiling information |
| SbProjector | Abstract 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 |
| SbRotation | Rotation in 3D space. SbRotation is used extensively throughout the Coin library |
| SbRWMutex | |
| SbSphere | Representation 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) |
| SbSpherePlaneProjector | Projects 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 |
| SbSphereProjector | Abstract base class for mapping to spherical surfaces. The sphere projectors map 2D points to various surface types based on spherical shapes |
| SbSphereSectionProjector | The 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 |
| SbSphereSheetProjector | Projects 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: |
| SbStorage | Manages 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 |
| SbString | String 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 |
| SbStringList | Container for arrays of SbString pointers. Note that upon using the equality and inequality operators, the strings themselves are not compared, only the pointer values |
| SbTesselator | Used 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 |
| SbThread | A class for managing threads. This class provides a portable framework around the tasks of instantiating, starting, stopping and joining threads |
| SbThreadAutoLock | Simple 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 |
| SbTime | Instances represents time values. SbTime is a convenient way of doing system independent representation and calculations on time values of high resolution |
| SbTypedStorage< Type > | The 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 |
| SbVec2b | Vector class for containing two byte integers |
| SbVec2d | 2 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 |
| SbVec2f | 2 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 |
| SbVec2i32 | 2 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 |
| SbVec2s | 2 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 |
| SbVec3b | |
| SbVec3d | 3 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 |
| SbVec3f | 3 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 |
| SbVec3fList | Container 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 |
| SbVec3i32 | |
| SbVec3s | 3 dimensional vector with short integer coordinates. This vector class provides storage for a 3 dimensional vector as well as simple integer arithmetic operations |
| SbVec4b | |
| SbVec4d | 4 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 |
| SbVec4f | 4 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 |
| SbVec4i32 | |
| SbVec4s | |
| SbViewportRegion | Viewport 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 |
| SbViewVolume | Viewing 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 |
| SbXfBox3f | 3 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 |
| ScXML | Namespace for static ScXML-related functions |
| ScXMLEvent | Base class for events sent to SCXML state machines |
| ScXMLObject | Base class for all SCXML objects |
| ScXMLStateMachine | Manager for processing events and setting states in SCXML structures |
| SoAccumulatedElement | Abstract class for storing accumulated state. This is the superclass of elements where new element data accumulates with older data |
| SoAction | Base 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 |
| SoActionMethodList | Function 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 |
| SoAlarmSensor | Sensor 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 |
| SoAnnotation | The 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 |
| SoAntiSquish | Used 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 |
| SoAppearanceKit | Node kit catalog that collects miscellaneous appearance node types. Node kit structure (new entries versus parent class marked with arrow prefix): |
| SoArray | Group 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 |
| SoAsciiText | Renders flat 3D text. The text is rendered using 3D polygon geometry |
| SoAudioDevice | Used 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 |
| SoAudioRenderAction | Renders 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 |
| SoAuditorList | Used 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 |
| SoBase | Top-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 |
| SoBaseColor | Node 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 |
| SoBaseKit | Toplevel superclass for nodekits. Node kits are collections of nodes and other node kits (from here on node kits which is 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 |
| SoBaseList | Container 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 |
| SoBlinker | Cycling 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 |
| SoBoolOperation | The 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 |
| SoBoundingBoxCache | Used to cache bounding boxes |
| SoBoxHighlightRenderAction | Renders 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 |
| SoBumpMap | Used 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 |
| SoBumpMapCoordinate | Node 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 |
| SoBumpMapTransform | Used 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 |
| SoButtonEvent | Base 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) |
| SoCache | Superclass 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 |
| SoCalculator | General 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 |
| SoCallback | Node 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 |
| SoCallbackAction | Invokes 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 |
| SoCallbackList | The 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 |
| SoCamera | Abstract 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 |
| SoCameraKit | Node kit with a transform and a camera. Node kit structure (new entries versus parent class marked with arrow prefix): |
| SoCenterballDragger | Dragger you can rotate and translate. Here's how the dragger looks with its default geometry in the inactive state: |
| SoCenterballManip | The SoCenterballManip wraps an SoCenterballDragger for convenience.
|
| SoChildList | Container for node children. This class does automatic notification on the parent nodes upon adding or removing children |
| SoClipPlane | Node 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 |
| SoClipPlaneManip | Used to manipulate clip planes.
|
| SoColorIndex | Used 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 |
| SoComplexity | Node 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 |
| SoComposeMatrix | Used to compose a matrix from miscellaneous transformations |
| SoComposeRotation | Used to compose rotations from angle and axis. Simple usage example: |
| SoComposeRotationFromTo | Used to compose rotations based on from and to vectors |
| SoComposeVec2f | Used to compose 2D vectors from two floats |
| SoComposeVec3f | Used to compose 3D vectors from floats |
| SoComposeVec4f | Used to compose 4D vectors from four floats |
| SoComputeBoundingBox | Used 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 |
| SoConcatenate | Used 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 |
| SoCone | For 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) |
| SoConeDetail | Information 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 |
| SoContextHandler | For now to be treated as an internal class |
| SoConvexDataCache | Used 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 |
| SoCoordinate3 | Node 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) |
| SoCoordinate4 | Node 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) |
| SoCounter | Integer counter engine. The engine counts from its min value to its max value, adding the value of step each time trigger is touched |
| SoCube | For 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) |
| SoCubeDetail | Information 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 |
| SoCylinder | For 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) |
| SoCylinderDetail | Information 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 |
| SoDataSensor | Abstract 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 |
| SoDB | Keeps track of internal global data. This class collects various methods for initializing, setting and accessing common global data from the Coin library |
| SoDebug | |
| SoDebugError | Internal debugging message passing mechanism. This class basically serves two purposes: |
| SoDecomposeMatrix | Used to decompose a matrix into simple transformations |
| SoDecomposeRotation | Used to decompose a rotation into angle and axis |
| SoDecomposeVec2f | Used to decompose 2D vectors into two floats |
| SoDecomposeVec3f | Used to decompose 3D vectors into three floats |
| SoDecomposeVec4f | Used to decompose 4D vectors into four floats |
| SoDelayQueueSensor | Abstract 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 |
| SoDepthBuffer | Node used to control the GL depth buffer |
| SoDetail | Superclass 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 |
| SoDetailList | Container 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 |
| SoDirectionalLight | Node 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 |
| SoDirectionalLightDragger | Interactive geometry for manipulating a directional light source. Here's how the dragger looks with its default geometry in the inactive state: |
| SoDirectionalLightManip | Used to manipulate SoDirectionalLight nodes.
|
| SoDragger | Base 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) |
| SoDragPointDragger | Mechanisms for moving a point in 3D. Here's how the dragger looks with its default geometry in the inactive state: |
| SoDrawStyle | Specificies 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 |
| SoElapsedTime | Controllable 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 |
| SoElement | SoElement is the abstract base class for all elements |
| SoEnabledElementsList | Container for type info for element types that are enabled in actions. This class is probably not interesting for the application programmer |
| SoEngine | SoEngine is the base class for Coin engines. Engines enables the application programmers to make complex connections between fields |
| SoEngineList | Container for SoEngine objects. As this class inherits SoBaseList, referencing and dereferencing will default be done on the objects at append(), remove(), insert() etc |
| SoEngineOutput | Output slots in SoEngine instances. SoEngineOutput has methods for convenient handling of the connections made from SoEngine objects to SoField objects |
| SoEngineOutputList | Container for SoEngineOutput objects |
| SoEnvironment | Node for specifying global rendering parameters. This node type provides the application programmer with the ability to set global parameters influencing lighting and fog |
| SoError | Base 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 |
| SoEvent | Base class for all Coin events. Coin contains its own set of event classes, independent of the underlying window system |
| SoEventCallback | Functionality for catching events. Use SoEventCallback nodes in the scenegraph for catching user interaction events with the scenegraph's render canvas |
| SoEventManager | Manager object for event processing for a viewer |
| SoExtSelection | Can 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 |
| SoFaceDetail | For 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 |
| SoFaceSet | Used 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 |
| SoField | Top-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 |
| SoFieldContainer | Base 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 |
| SoFieldConverter | Abstract 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 |
| SoFieldData | Container 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 |
| SoFieldList | Container for pointers to SoField objects |
| SoFieldSensor | Detects 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 |
| SoFile | Node 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 |
| SoFloatElement | SoFloatElement 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 |
| SoFont | Appearance 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 |
| SoFontStyle | Changes 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 |
| SoForeignFileKit | Abstract base class for foreign file format support in Coin |
| SoFragmentShader | Used for setting up fragment shader programs. See Shaders in Coin for more information on how to set up a scene graph with shaders |
| SoFrustumCamera | Defines a camera with a generic frustum. |
| SoFullPath | Allows 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 |
| SoGate | Used 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 |
| SoGeoCoordinate | Used to specify a list of geographical coordinates. FILE FORMAT/DEFAULTS: |
| SoGeoLocation | Used to georeference the following nodes. FILE FORMAT/DEFAULTS: |
| SoGeometryShader | Used for loading geometry shader programs. See Shaders in Coin for more information on how to set up a scene graph with shaders |
| SoGeoOrigin | Used to specify an absolute geographic location against which geometry is referenced. FILE FORMAT/DEFAULTS: |
| SoGeoSeparator | Used to georeference a scene graph. FILE FORMAT/DEFAULTS: |
| SoGetBoundingBoxAction | Calculates 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 |
| SoGetMatrixAction | Action 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 |
| SoGetPrimitiveCountAction | Counts 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 |
| SoGLCacheList | Used to store and manage OpenGL caches |
| SoGLColorIndexElement | Sets 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 |
| SoGLLineWidthElement | Changes 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 |
| SoGLPointSizeElement | Changes 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 |
| SoGLRenderAction | Renders 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 |
| SoGLRenderCache | Used to cache OpenGL calls |
| SoGlyph | Used to generate and reuse font glyph bitmaps and outlines |
| SoGroup | Node 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 |
| SoHandleBoxDragger | Support for interactive scaling and translation. Here's how the dragger looks with its default geometry in the inactive state: |
| SoHandleBoxManip | Wraps an SoHandleBoxDragger for manipulating a transformation.
|
| SoHandleEventAction | Distributes 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 |
| SoHardCopy | Static class for initializing the hardcopy support |
| SoHeightMapToNormalMap | Engine for computing a normal map from a height map |
| SoIdleSensor | Sensor 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 |
| SoImage | Draws 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 |
| SoIndexedFaceSet | Used 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 |
| SoIndexedLineSet | Used to render and otherwise represent indexed lines. The indexed counterpart of SoLineSet. Lines can specified using indices for coordinates, normals, materials and texture coordinates |
| SoIndexedNurbsCurve | Node 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 |
| SoIndexedNurbsSurface | Can be used to render NURBS surfaces. It is very similar to the SoNurbsSurface class, but controlpoints can be specified using indices |
| SoIndexedShape | Superclass 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 |
| SoIndexedTriangleStripSet | Keeps data for rendering and otherwise representing triangle strips. Use nodes of this type as an effective way of drawing triangles which are strung together |
| SoInfo | Node 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 |
| SoInput | Abstraction 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 |
| SoInt32Element | Base 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 |
| SoInteraction | Takes 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 |
| SoInteractionKit | Base 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 |
| SoInterpolate | Base class for all interpolator engines. Interpolators are used to linearly interpolate between two values |
| SoInterpolateFloat | Used to interpolate two floating point values |
| SoInterpolateRotation | Used to interpolate between two rotations |
| SoInterpolateVec2f | Used to interpolate between pairs of 2D vectors |
| SoInterpolateVec3f | Used to interpolate between pairs of 3D vectors |
| SoInterpolateVec4f | Used to interpolate between pairs of 4D vectors |
| SoIntersectingPrimitive | Struct with collision information |
| SoIntersectionDetectionAction | For detecting intersecting primitives in a scene |
| SoJackDragger | Dragger you can translate, rotate and scale. Here's how the dragger looks with its default geometry in the inactive state: |
| SoJackManip | The SoJackManip wraps an SoJackDragger for convenience.
|
| SoKeyboardEvent | Information 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 |
| SoLabel | Node for holding label information in a scene graph. Use this node as a convenient way of labeling nodes or subgraphs within a scene graph |
| SoLevelOfDetail | Used 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 |
| SoLight | Base 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 |
| SoLightKit | Kit with a transform, a light and a shape or subgraph. Node kit structure (new entries versus parent class marked with arrow prefix): |
| SoLightModel | Node for specifying the model for geometry lighting. Use nodes of this type to set up how lighting should affect subsequent geometry in the scene |
| SoLinearProfile | Node 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 |
| SoLineDetail | For 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 |
| SoLineHighlightRenderAction | Renders selections with line highlighting. See the documentation of SoBoxHighlightRenderAction |
| SoLineSet | Used 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 |
| SoLineWidthElement | Changes 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 |
| SoListener | Defines 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 |
| SoListenerDopplerElement | The 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 |
| SoListenerGainElement | Stores 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 |
| SoListenerOrientationElement | The 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 |
| SoListenerPositionElement | The 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 |
| SoLocateHighlight | Highlights 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 |
| SoLocation2Event | Information 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 |
| SoLockManager | The 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 |
| SoLOD | Used 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 |
| SoMarkerSet | Displays 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 |
| SoMaterial | Node 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 |
| SoMaterialBinding | Node 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 |
| SoMatrixTransform | Transformation 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 |
| SoMemoryError | Used 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 |
| SoMFBitMask | Container 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 |
| SoMFBool | Container 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 |
| SoMFColor | Container 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) |
| SoMFColorRGBA | Container 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) |
| SoMFDouble | Container 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 |
| SoMFEngine | Container 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 |
| SoMFEnum | Container 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 |
| SoMFFloat | Container 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 |
| SoMField | Base 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 |
| SoMFInt32 | Container 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 |
| SoMFMatrix | Container for SbMatrix values. This field is used where nodes, engines or other field containers needs to store matrices |
| SoMFName | Container for SbName values. This field is used where nodes, engines or other field containers needs to store arrays of names |
| SoMFNode | Container 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 |
| SoMFPath | Container 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 |
| SoMFPlane | Container for SbPlane values. This field is used where nodes, engines or other field containers needs to store multiple 3D plane definitions |
| SoMFRotation | Container for SbRotation values. This field is used where nodes, engines or other field containers needs to store multiple rotation definitions |
| SoMFShort | Container 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 |
| SoMFString | Container for SbString values. This field is used where nodes, engines or other field containers needs to store arrays of strings |
| SoMFTime | Container for SbTime values. This field is used where nodes, engines or other field containers needs to store multiple time representations |
| SoMFUInt32 | Container 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 |
| SoMFUShort | Container 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 |
| SoMFVec2b | Container for SbVec2b vectors. This field is used where nodes, engines or other field containers needs to store an array of vectors with two elements |
| SoMFVec2d | Container for SbVec2d vectors. This field is used where nodes, engines or other field containers needs to store an array of vectors with two elements |
| SoMFVec2f | Container for SbVec2f vectors. This field is used where nodes, engines or other field containers needs to store an array of vectors with two elements |
| SoMFVec2i32 | Container for SbVec2i32 vectors. This field is used where nodes, engines or other field containers needs to store an array of vectors with two elements |
| SoMFVec2s | Container for SbVec2s vectors. This field is used where nodes, engines or other field containers needs to store an array of vectors with two elements |
| SoMFVec3b | Container for SbVec3b vectors. This field is used where nodes, engines or other field containers needs to store an array of vectors with three elements |
| SoMFVec3d | Container for SbVec3d vectors. This field is used where nodes, engines or other field containers needs to store an array of vectors with three elements |
| SoMFVec3f | Container for SbVec3f vectors. This field is used where nodes, engines or other field containers needs to store an array of vectors with three elements |
| SoMFVec3i32 | Container for SbVec3i32 vectors. This field is used where nodes, engines or other field containers needs to store an array of vectors with three elements |
| SoMFVec3s | Container for SbVec3s vectors. This field is used where nodes, engines or other field containers needs to store an array of vectors with three elements |
| SoMFVec4b | Container for SbVec4b vectors. This field is used where nodes, engines or other field containers needs to store an array of vectors with four elements |
| SoMFVec4d | Container for SbVec4d vectors. This field is used where nodes, engines or other field containers needs to store an array of vectors with four elements |
| SoMFVec4f | Container for SbVec4f vectors. This field is used where nodes, engines or other field containers needs to store an array of vectors with four elements |
| SoMFVec4i32 | Container for SbVec4i32 vectors. This field is used where nodes, engines or other field containers needs to store an array of vectors with four elements |
| SoMFVec4s | Container for SbVec4s vectors. This field is used where nodes, engines or other field containers needs to store an array of vectors with four elements |
| SoMFVec4ub | Container for SbVec4ub vectors. This field is used where nodes, engines or other field containers needs to store an array of vectors with four elements |
| SoMFVec4ui32 | Container for SbVec4ui32 vectors. This field is used where nodes, engines or other field containers needs to store an array of vectors with four elements |
| SoMFVec4us | Container for SbVec4us vectors. This field is used where nodes, engines or other field containers needs to store an array of vectors with four elements |
| SoMotion3Event | Information 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 |
| SoMouseButtonEvent | Information 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 |
| SoMultipleCopy | Redraws it's children multiple times at different transformations. The SoMultipleCopy group node duplicates it's children nodes / subgraphs without using additional memory resources |
| SoNode | Base 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 |
| SoNodeEngine | SoNodeEngine 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 |
| SoNodeKit | Used 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 |
| SoNodekitCatalog | Container for nodekit layouts. Nodekits store all their hierarchical layout information and part information in instances of this class |
| SoNodeKitDetail | Yet 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 |
| SoNodeKitListPart | Container node. This node is basically just a container node with these differences versus the other group nodes: |
| SoNodeKitPath | Path that contains only nodekit nodes. All other nodes are hidden from the user |
| SoNodeList | Container for pointers to SoNode objects |
| SoNodeSensor | Detects 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 |
| SoNonIndexedShape | Superclass for all non-indexed vertex based shapes. It contains the (now obsoleted) startIndex field and a convenience method for calculating the bounding box |
| SoNormal | Node 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 |
| SoNormalBinding | Node 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 |
| SoNormalCache | Used 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 |
| SoNotList | List of SoNotRec notification records |
| SoNotRec | Records for notification lists |
| SoNurbsCurve | Node 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" |
| SoNurbsProfile | Node for specifying smooth profile curves. Use nodes of this type if you want to set up profiles that are smooth curves |
| SoNurbsSurface | Used 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" |
| SoOffscreenRenderer | Used 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) |
| SoOneShot | Timer that runs for a configurable time and then stops |
| SoOneShotSensor | Sensor 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()) |
| SoOnOff | The SoOnOff engine is a simple on/off switch |
| SoOrthographicCamera | Defines 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 |
| SoOutput | Abstraction 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 |
| SoOverrideElement | The SoOverrideElement maintains a list of overridable elements and a list over which elements should be overridden. Only certain elements can be overridden |
| SoPackedColor | Node 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 |
| SoPath | Container 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 |
| SoPathList | Container 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 |
| SoPathSensor | Detects 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 |
| SoPathSwitch | Traverses only when current path matches a configurable path. FILE FORMAT/DEFAULTS: |
| SoPendulum | Used 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 |
| SoPerspectiveCamera | Defines 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 |
| SoPickAction | Base 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 |
| SoPickedPoint | Used 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 |
| SoPickedPointList | Container 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 |
| SoPickStyle | Node 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 |
| SoPointDetail | For 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 |
| SoPointLight | Node type for light sources. Pointlights emits light equally in all directions from a specified 3D location |
| SoPointLightDragger | Interactive geometry for manipulating a point light source. Here's how the dragger looks with its default geometry in the inactive state: |
| SoPointLightManip | Used to manipulate point light nodes.
|
| SoPointSet | Used 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 |
| SoPointSizeElement | The 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 |
| SoPolygonOffset | Node 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 |
| SoPrimitiveVertex | Single 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 |
| SoPrimitiveVertexCache | |
| SoProfile | Abstract superclass for profile definitions. Node subclasses of SoProfile specifies profiles for extruded 3D text and nurbs surface data |
| SoProfileCoordinate2 | Node specifying a set of 2D coordinates for profiles. Use nodes of this type to provide coordinates to profiles |
| SoProfileCoordinate3 | Node specifying a set of 3D coordinates for profiles. Use nodes of this type to provide coordinates to profiles |
| SoProfiler | Main static class for initializing the scene graph profiling subsystem |
| SoProfilerElement | The SoProfilerElement element class is for registering statistics during scene graph traversals |
| SoProfilerStats | Node for exposing profiling results gathered by SoProfilerElement |
| SoProfilingReportGenerator | Convenience report generator functionality |
| SoPSVectorOutput | Used for writing Postscript |
| SoQuadMesh | Used 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 |
| SoRayPickAction | Does 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 |
| SoReadError | Used during model import operations. During model file import, this class will be used to output any error or warning messages |
| SoReorganizeAction | Reorganizes your scene graph to optimize traversal/rendering |
| SoReplacedElement | Abstract 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 |
| SoResetTransform | Node 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 |
| SoRotateCylindricalDragger | For rotating geometry around a single axis. Here's how the dragger looks with its default geometry in the inactive state: |
| SoRotateDiscDragger | For rotating geometry around a single axis. Here's how the dragger looks with its default geometry in the inactive state: |
| SoRotateSphericalDragger | For rotating geometry in any direction. Here's how the dragger looks with its default geometry in the inactive state: |
| SoRotation | Rotation transformation. Use nodes of this class type to re-orient geometry data within the scene graph |
| SoRotationXYZ | Node 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 |
| SoRotor | Node 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 |
| SoScale | Node 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 |
| SoScale1Dragger | Mechanism for the end-user to scale in one dimension. Here's how the dragger looks with its default geometry in the inactive state: |
| SoScale2Dragger | Mechanism for the end-user to scale in two dimensions. Here's how the dragger looks with its default geometry in the inactive state: |
| SoScale2UniformDragger | Mechanism for the end-user to scale in two dimensions. Here's how the dragger looks with its default geometry in the inactive state: |
| SoScaleUniformDragger | Mechanism for the end-user to scale in three dimensions. Here's how the dragger looks with its default geometry in the inactive state: |
| SoSceneKit | Collects node kits needed to set up a scene: camera, light and shapes. Node kit structure (new entries versus parent class marked with arrow prefix): |
| SoSceneManager | Main 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 |
| SoSceneTexture2 | Used 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 |
| SoScXMLEvent | Adds an SoEvent holder to the ScXMLEvent base |
| SoScXMLStateMachine | Integration level for using Coin events with SCXML-based state machines |
| SoSearchAction | Methods 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) |
| SoSelection | Manages 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 |
| SoSelectOne | Used to select one value from a set of values. The output field will be the index'th value of the input multivalue field |
| SoSensor | Abstract 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 |
| SoSensorManager | Handles the sensor queues. There are two major sensor types in Coin, "delay" sensors and "timer" sensors: |
| SoSeparator | State-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 |
| SoSeparatorKit | Typical set of nodes to influence a shape subgraph. Node kit structure (new entries versus parent class marked with arrow prefix): |
| SoSFBitMask | Container 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 |
| SoSFBool | Container 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 |
| SoSFBox2d | Container for an SbBox2d vector. This field is used where nodes, engines or other field containers needs to store a box |
| SoSFBox2f | Container for an SbBox2f vector. This field is used where nodes, engines or other field containers needs to store a box |
| SoSFBox2i32 | Container for an SbBox2i32 vector. This field is used where nodes, engines or other field containers needs to store a box |
| SoSFBox2s | Container for an SbBox2s vector. This field is used where nodes, engines or other field containers needs to store a box |
| SoSFBox3d | Container for an SbBox3d vector. This field is used where nodes, engines or other field containers needs to store a box |
| SoSFBox3f | Container for an SbBox3f vector. This field is used where nodes, engines or other field containers needs to store a box |
| SoSFBox3i32 | Container for an SbBox3i32 vector. This field is used where nodes, engines or other field containers needs to store a box |
| SoSFBox3s | Container for an SbBox3s vector. This field is used where nodes, engines or other field containers needs to store a box |
| SoSFColor | Container 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) |
| SoSFColorRGBA | Container 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) |
| SoSFDouble | Container 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 |
| SoSFEngine | Container 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 |
| SoSFEnum | Container 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 |
| SoSFFloat | Container for a floating point value. This field is used where nodes, engines or other field containers needs to store a single floating point value |