http://www.kongsberg.com/kogt/
|
|
http://www.coin3d.org/ http://www.kongsberg.com/kogt/ |
| Ccc_string | The cc_string type is a C ADT for ASCII string management.This is a Coin extension |
| CSbBox2d | 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 |
| CSbBox2f | 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 |
| CSbBox2s | 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 |
| CSbBox3d | 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 |
| CSbBox3f | 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 |
| CSbBox3s | 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 |
| CSbBSPTree | 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 |
| CSbClip | 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 |
| CSbColor | 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 |
| CSbColor4f | 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 |
| CSbCylinder | 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 |
| CSbCylinderPlaneProjector | 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 |
| CSbCylinderProjector | Abstract base class for mapping to cylindrical surfaces.The cylinder projectors map 2D points to various surface types based on cylindrical shapes |
| CSbCylinderSectionProjector | 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 |
| CSbCylinderSheetProjector | Projects 2D points to 3D points on a sheet covering a cylindrical shape |
| CSbDict | 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 |
| CSbDPLine | Line 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 |
| CSbDPMatrix | 4x4 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 |
| CSbDPPlane | Plane 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 |
| CSbDPRotation | Rotation in 3D space.SbDPRotation is used extensively throughout the Coin library |
| CSbDPViewVolume | Double 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 |
| CSbHeap | Generic heap class.FIXME: write doc |
| CSbHeapFuncs | The SbHeapFuncs struct is used to specify functions on heap elements |
| CSbImage | 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 |
| CSbIntList | Container for integer list arrays |
| CSbLine | 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 |
| CSbLineProjector | 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 |
| CSbList | 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 void* pointers. By using this template-based class instead, we can share more code and make the list handling code more typesafe |
| CSbMatrix | 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 |
| CSbName | 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) |
| CSbOctTree | Defines 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 |
| CSbOctTreeFuncs | |
| CSbPlane | 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 |
| CSbPlaneProjector | 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 |
| CSbPList | Container class for void pointers |
| CSbProfilingData | Data structure for gathering scene graph traversal profiling information |
| CSbProjector | 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 |
| CSbRotation | Rotation in 3D space.SbRotation is used extensively throughout the Coin library |
| CSbSphere | 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) |
| CSbSpherePlaneProjector | 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 |
| CSbSphereProjector | Abstract base class for mapping to spherical surfaces.The sphere projectors map 2D points to various surface types based on spherical shapes |
| CSbSphereSectionProjector | 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 |
| CSbSphereSheetProjector | 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: |
| CSbString | 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 |
| CSbStringList | 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 |
| CSbTesselator | 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 |
| CSbTime | Instances represents time values.SbTime is a convenient way of doing system independent representation and calculations on time values of high resolution |
| CSbTypeInfo | Type information library for Coin types and their relations |
| CSbVec2b | Vector class for containing two byte integers |
| CSbVec2d | 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 |
| CSbVec2f | 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 |
| CSbVec2i32 | 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 |
| CSbVec2s | 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 |
| CSbVec2ub | |
| CSbVec2ui32 | |
| CSbVec2us | |
| CSbVec3b | |
| CSbVec3d | 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 |
| CSbVec3f | 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 |
| CSbVec3fList | 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 |
| CSbVec3i32 | |
| CSbVec3s | 3 dimensional vector with short integer coordinates.This vector class provides storage for a 3 dimensional vector as well as simple integer arithmetic operations |
| CSbVec3ub | |
| CSbVec3ui32 | |
| CSbVec3us | |
| CSbVec4b | |
| CSbVec4d | 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 |
| CSbVec4f | 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 |
| CSbVec4i32 | |
| CSbVec4s | |
| CSbVec4ub | |
| CSbVec4ui32 | |
| CSbViewportRegion | 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 |
| CSbViewVolume | 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 |
| CSbXfBox3d | 3 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 |
| CSbXfBox3f | 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 |
| CScXML | Namespace for static ScXML-related functions |
| CScXMLAbstractStateElt | Abstract base class for the SCXML 'state' elements |
| CScXMLAnchorElt | Implements the <anchor> SCXML element |
| CScXMLAndOpExprDataObj | Implements the logical AND operator |
| CScXMLAssignElt | <assign> SCXML element |
| CScXMLCoinEvaluator | Implements the evaluator for the custom profile named "x-coin" |
| CScXMLConstantDataObj | Base class for immediate data values |
| CScXMLContentElt | Implements the <content> SCXML element |
| CScXMLDataElt | <data> SCXML element |
| CScXMLDataModelElt | Implements the <datamodel> SCXML element |
| CScXMLDataObj | Base class for evaluator data objects in the SCXML data module |
| CScXMLDocument | |
| CScXMLECMAScriptEvaluator | Evaluator for the ECMAScript profile |
| CScXMLElseElt | Implements the <else> SCXML element |
| CScXMLElseIfElt | Implements the <elseif> SCXML element |
| CScXMLElt | Base class for all SCXML elements |
| CScXMLEltReader | Base class for element reader objects |
| CScXMLEvaluator | Defines an interface for profile-dependent evaluators |
| CScXMLEvent | Base class for events sent to SCXML state machines |
| CScXMLEventElt | Implements the <event> SCXML element |
| CScXMLEventTarget | Base class for event targets for inter-system event communication |
| CScXMLExecutableElt | Base class for all SCXML elements with executable content |
| CScXMLFinalElt | Implements the <final> SCXML element |
| CScXMLFinalizeElt | Implements the <finalize> SCXML element |
| CScXMLHistoryElt | Implements the <history> SCXML element |
| CScXMLIfElt | Implements the <if> SCXML element |
| CScXMLInitialElt | Implements the <initial> SCXML element |
| CScXMLInvokeElt | Implements the <invoke> SCXML element |
| CScXMLLogElt | Implements the <log> SCXML element |
| CScXMLMinimumEvaluator | Implements the evaluator for the minimum profile |
| CScXMLMinimumExprDataObj | Implements the data objects for the evaluator for the minimum profile |
| CScXMLObject | Base class for all SCXML objects |
| CScXMLParallelElt | Implements the <parallel> SCXML element |
| CScXMLParamElt | Implements the <param> SCXML element |
| CScXMLReferenceDataObj | A data object representing a reference to another object in the data model |
| CScXMLScriptElt | Implements the <script> SCXML element |
| CScXMLScxmlElt | Implements the <scxml> SCXML element |
| CScXMLSendElt | < send> SCXML element |
| CScXMLStateElt | Implements the <state> SCXML element |
| CScXMLStateMachine | Manager for processing events and setting states in SCXML structures |
| CScXMLTransitionElt | <transition> SCXML element |
| CScXMLValidateElt | Implements the <validate> SCXML element |
| CScXMLXPathEvaluator | Implements the XPath evaluator |
| CSoAccumulatedElement | Abstract class for storing accumulated state.This is the superclass of elements where new element data accumulates with older data |
| CSoAction | 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 |
| CSoActionMethodList | 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 |
| CSoAlarmSensor | 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 |
| CSoAmbientColorElement | Yet to be documented |
| CSoAnnotation | 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 |
| CSoAnnoText3CharOrientElement | Yet to be documented.FIXME: write doc |
| CSoAnnoText3FontSizeHintElement | Yet to be documented.FIXME: write doc |
| CSoAnnoText3RenderPrintElement | Yet to be documented.FIXME: write doc |
| CSoAntiSquish | 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 |
| CSoAppearanceKit | Node kit catalog that collects miscellaneous appearance node types.Node kit structure (new entries versus parent class marked with arrow prefix): |
| CSoArray | 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 |
| CSoAsciiText | Renders flat 3D text.The text is rendered using 3D polygon geometry |
| CSoAudioDevice | 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 |
| CSoAudioRenderAction | 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 |
| CSoAuditorList | 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 |
| CSoBase | 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 |
| CSoBaseColor | 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 |
| CSoBaseKit | Toplevel 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 |
| CSoBaseList | 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 |
| CSoBBoxModelMatrixElement | Keeps track of the current model matrix during a scene graph traversal. It is used by amongst others the SoGetBoundingBoxAction class |
| CSoBlinker | 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 |
| CSoBoolOperation | 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 TRUE or FALSE value set on SoBoolOperation::output |
| CSoBoundingBoxCache | Used to cache bounding boxes |
| CSoBoxHighlightRenderAction | 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 |
| CSoBumpMap | 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 |
| CSoBumpMapCoordinate | 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 |
| CSoBumpMapCoordinateElement | Yet to be documented.FIXME: write doc |
| CSoBumpMapMatrixElement | Used 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 |
| CSoBumpMapTransform | 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 |
| CSoBundle | Superclass for all bundle classes |
| CSoButtonEvent | 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) |
| CSoCache | 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 |
| CSoCacheElement | Stores and manages the open caches |
| CSoCacheHint | Node 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 |
| CSoCalculator | 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 |
| CSoCallback | 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 |
| CSoCallbackAction | 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 |
| CSoCallbackList | 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 |
| CSoCamera | 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 |
| CSoCameraKit | Node kit with a transform and a camera.Node kit structure (new entries versus parent class marked with arrow prefix): |
| CSoCenterballDragger | Dragger you can rotate and translate.Here's how the dragger looks with its default geometry in the inactive state: |
| CSoCenterballManip | The SoCenterballManip wraps an SoCenterballDragger for convenience. |
| CSoChildList | Container for node children.This class does automatic notification on the parent nodes upon adding or removing children |
| CSoClipPlane | 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 |
| CSoClipPlaneElement | Used to manage the clip plane stack |
| CSoClipPlaneManip | Used to manipulate clip planes. |
| CSoColorIndex | 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 |
| CSoComplexity | 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 |
| CSoComplexityElement | Current shape complexity for a graph traverser |
| CSoComplexityTypeElement | Yet to be documented.FIXME: write doc |
| CSoComposeMatrix | Used to compose a matrix from miscellaneous transformations |
| CSoComposeRotation | Used to compose rotations from angle and axis.Simple usage example: |
| CSoComposeRotationFromTo | Used to compose rotations based on from and to vectors |
| CSoComposeVec2f | Used to compose 2D vectors from two floats |
| CSoComposeVec3f | Used to compose 3D vectors from floats |
| CSoComposeVec4f | Used to compose 4D vectors from four floats |
| CSoComputeBoundingBox | 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 |
| CSoConcatenate | 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 |
| CSoCone | 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) |
| CSoConeDetail | 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 |
| CSoContextHandler | For now to be treated as an internal class |
| CSoConvexDataCache | 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 |
| CSoCoordinate3 | 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) |
| CSoCoordinate4 | 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) |
| CSoCoordinateElement | Yet to be documented.FIXME: write doc |
| CSoCounter | Integer counter engine.The engine counts from its min value to its max value, adding the value of step each time trigger is touched |
| CSoCreaseAngleElement | Stores the crease angle during a scene graph traversal |
| CSoCube | 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) |
| CSoCubeDetail | 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 |
| CSoCullElement | Used 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 |
| CSoCylinder | 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) |
| CSoCylinderDetail | 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 |
| CSoDataSensor | 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 |
| CSoDB | Keeps track of internal global data.This class collects various methods for initializing, setting and accessing common global data from the Coin library |
| CSoDebug | |
| CSoDebugError | Internal debugging message passing mechanism.This class basically serves two purposes: |
| CSoDecimationPercentageElement | Yet to be documented.FIXME: write doc |
| CSoDecimationTypeElement | Yet to be documented.FIXME: write doc |
| CSoDecomposeMatrix | Used to decompose a matrix into simple transformations |
| CSoDecomposeRotation | Used to decompose a rotation into angle and axis |
| CSoDecomposeVec2f | Used to decompose 2D vectors into two floats |
| CSoDecomposeVec3f | Used to decompose 3D vectors into three floats |
| CSoDecomposeVec4f | Used to decompose 4D vectors into four floats |
| CSoDelayQueueSensor | 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 |
| CSoDepthBuffer | Node used to control the GL depth buffer |
| CSoDepthBufferElement | The SoDepthBufferElement controls the depth buffer settings |
| CSoDetail | 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 |
| CSoDetailList | 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 |
| CSoDiffuseColorElement | Yet to be documented.FIXME: write doc |
| CSoDirectionalLight | 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 |
| CSoDirectionalLightDragger | Interactive geometry for manipulating a directional light source.Here's how the dragger looks with its default geometry in the inactive state: |
| CSoDirectionalLightManip | Used to manipulate SoDirectionalLight nodes. |
| CSoDragger | 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) |
| CSoDragPointDragger | Mechanisms for moving a point in 3D.Here's how the dragger looks with its default geometry in the inactive state: |
| CSoDrawStyle | 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 |
| CSoDrawStyleElement | Yet to be documented.FIXME: write doc |
| CSoElapsedTime | 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 |
| CSoElement | SoElement is the abstract base class for all elements |
| CSoEmissiveColorElement | Yet to be documented.FIXME: write doc |
| CSoEnabledElementsList | Container for type info for element types that are enabled in actions.This class is probably not interesting for the application programmer |
| CSoEngine | SoEngine is the base class for Coin engines.Engines enables the application programmers to make complex connections between fields |
| CSoEngineList | Container for SoEngine objects.As this class inherits SoBaseList, referencing and dereferencing will default be done on the objects at append(), remove(), insert() etc |
| CSoEngineOutput | Output slots in SoEngine instances.SoEngineOutput has methods for convenient handling of the connections made from SoEngine objects to SoField objects |
| CSoEngineOutputData | Container 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 |
| CSoEngineOutputList | Container for SoEngineOutput objects |
| CSoEnvironment | Node for specifying global rendering parameters.This node type provides the application programmer with the ability to set global parameters influencing lighting and fog |
| CSoEnvironmentElement | Yet to be documented.FIXME: write doc |
| CSoError | 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 |
| CSoEvent | Base class for all Coin events.Coin contains its own set of event classes, independent of the underlying window system |
| CSoEventCallback | Functionality for catching events.Use SoEventCallback nodes in the scenegraph for catching user interaction events with the scenegraph's render canvas |
| CSoEventManager | Event handling for a Coin3D viewer |
| CSoExtSelection | 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 |
| CSoFaceDetail | 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 |
| CSoFaceSet | 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 |
| CSoField | 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 |
| CSoFieldContainer | 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 |
| CSoFieldConverter | 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 |
| CSoFieldData | 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 |
| CSoFieldList | Container for pointers to SoField objects |
| CSoFieldSensor | 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 |
| CSoFile | 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 |
| CSoFloatElement | 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 |
| CSoFocalDistanceElement | Yet to be documented.FIXME: write doc |
| CSoFont | 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 |
| CSoFontNameElement | Yet to be documented.FIXME: write doc |
| CSoFontSizeElement | Yet to be documented.FIXME: write doc |
| CSoFontStyle | 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 |
| CSoForeignFileKit | Abstract base class for foreign file format support in Coin |
| CSoFragmentShader | Used for setting up fragment shader programs.See Shaders in Coin for more information on how to set up a scene graph with shaders |
| CSoFrustumCamera | Defines a camera with a generic frustum. |
| CSoFullPath | 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 |
| CSoGate | 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 TRUE |
| CSoGeoCoordinate | Used to specify a list of geographical coordinates.FILE FORMAT/DEFAULTS: |
| CSoGeoElement | Yet to be documented.FIXME: write doc |
| CSoGeoLocation | Used to georeference the following nodes.FILE FORMAT/DEFAULTS: |
| CSoGeometryShader | Used for loading geometry shader programs.See Shaders in Coin for more information on how to set up a scene graph with shaders |
| CSoGeoOrigin | Used to specify an absolute geographic location against which geometry is referenced.FILE FORMAT/DEFAULTS: |
| CSoGeoSeparator | Used to georeference a scene graph.FILE FORMAT/DEFAULTS: |
| CSoGetBoundingBoxAction | 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 |
| CSoGetMatrixAction | 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 |
| CSoGetPrimitiveCountAction | 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 |
| CSoGLBigImage | Used to handle 2D OpenGL textures of any size |
| CSoGLCacheList | Used to store and manage OpenGL caches |
| CSoGLClipPlaneElement | Yet to be documented.FIXME: write doc |
| CSoGLColorIndexElement | 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 |
| CSoGLCoordinateElement | Yet to be documented.FIXME: write doc |
| CSoGLCubeMapImage | Used to handle cube map textures |
| CSoGLDepthBufferElement | The SoGLDepthBufferElement controls the OpenGL depth buffer |
| CSoGLDisplayList | Stores 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 |
| CSoGLDrawStyleElement | The SoGLDrawStyleElement updates the current draw style in OpenGL |
| CSoGLDriverDatabase | Used for looking up broken/slow features in OpenGL drivers |
| CSoGLEnvironmentElement | For setting GL fog etc |
| CSoGLImage | Used to handle OpenGL 2D/3D textures |
| CSoGLLazyElement | Meant 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 |
| CSoGLLightIdElement | Yet to be documented.FIXME: write doc |
| CSoGLLinePatternElement | Yet to be documented.FIXME: write doc |
| CSoGLLineWidthElement | 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 |
| CSoGLModelMatrixElement | Yet to be documented.FIXME: write doc |
| CSoGLMultiTextureCoordinateElement | Stores the current gltexture coordinates for several units |
| CSoGLMultiTextureImageElement | The SoGLMultiTextureImageElement is used to control the current GL texture for texture units |
| CSoGLMultiTextureMatrixElement | Used 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 |
| CSoGLNormalElement | Yet to be documented.FIXME: write doc |
| CSoGlobalSimplifyAction | For globally simplifying the geometry of a scene graph, globally |
| CSoGLPointSizeElement | 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 |
| CSoGLPolygonOffsetElement | Yet to be documented.FIXME: write doc |
| CSoGLProjectionMatrixElement | Yet to be documented.FIXME: write doc |
| CSoGLRenderAction | 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 |
| CSoGLRenderCache | Used to cache OpenGL calls |
| CSoGLRenderPassElement | Yet to be documented.FIXME: write doc |
| CSoGLShadowCullingElement | Yet to be documented.FIXME: write doc |
| CSoGLShapeHintsElement | Yet to be documented.FIXME: write doc |
| CSoGLUpdateAreaElement | Yet to be documented.FIXME: write doc |
| CSoGLVBOElement | Used to store VBO state.FIXME: write doc |
| CSoGLViewingMatrixElement | Used 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 |
| CSoGLViewportRegionElement | Yet to be documented.FIXME: write doc |
| CSoGlyph | Used to generate and reuse font glyph bitmaps and outlines |
| CSoGroup | 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 |
| CSoHandleBoxDragger | Support for interactive scaling and translation.Here's how the dragger looks with its default geometry in the inactive state: |
| CSoHandleBoxManip | Wraps an SoHandleBoxDragger for manipulating a transformation. |
| CSoHandleEventAction | 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 |
| CSoHeightMapToNormalMap | Engine for computing a normal map from a height map |
| CSoIdleSensor | 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 |
| CSoImage | 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 |
| CSoIndexedFaceSet | 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 |
| CSoIndexedLineSet | 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 |
| CSoIndexedMarkerSet | Used 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 |
| CSoIndexedNurbsCurve | 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 |
| CSoIndexedNurbsSurface | Can be used to render NURBS surfaces.It is very similar to the SoNurbsSurface class, but controlpoints can be specified using indices |
| CSoIndexedPointSet | 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 |
| CSoIndexedShape | 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 |
| CSoIndexedTriangleStripSet | 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 |
| CSoInfo | 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 |
| CSoInput | 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 |
| CSoInt32Element | 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 |
| CSoInteraction | 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 |
| CSoInteractionKit | 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 |
| CSoInterpolate | Base class for all interpolator engines.Interpolators are used to linearly interpolate between two values |
| CSoInterpolateFloat | Used to interpolate two floating point values |
| CSoInterpolateRotation | Used to interpolate between two rotations |
| CSoInterpolateVec2f | Used to interpolate between pairs of 2D vectors |
| CSoInterpolateVec3f | Used to interpolate between pairs of 3D vectors |
| CSoInterpolateVec4f | Used to interpolate between pairs of 4D vectors |
| CSoIntersectingPrimitive | Struct with collision information |
| CSoIntersectionDetectionAction | For detecting intersecting primitives in a scene |
| CSoJackDragger | Dragger you can translate, rotate and scale.Here's how the dragger looks with its default geometry in the inactive state: |
| CSoJackManip | The SoJackManip wraps an SoJackDragger for convenience. |
| CSoKeyboardEvent | 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 |
| CSoLabel | 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 |
| CSoLazyElement | Used to handle material and shape properties.So[GL]LazyElement is, as the name implies, an element that is lazy about sending things to OpenGL. The changes are not sent to OpenGL until SoGLLazyElement::send() is called. This means that you can change the state of certain attributes several times, but the state will only be sent to OpenGL once |
| CSoLevelOfDetail | 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 |
| CSoLight | 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 |
| CSoLightAttenuationElement | Yet to be documented.FIXME: write doc |
| CSoLightElement | Manages the currently active light sources |
| CSoLightKit | Kit with a transform, a light and a shape or subgraph.Node kit structure (new entries versus parent class marked with arrow prefix): |
| CSoLightModel | 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 |
| CSoLightModelElement | Yet to be documented.FIXME: write doc |
| CSoLightPath | Light 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) |
| CSoLinearProfile | 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 |
| CSoLineDetail | 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 |
| CSoLineHighlightRenderAction | Renders selections with line highlighting.See the documentation of SoBoxHighlightRenderAction |
| CSoLinePatternElement | Yet to be documented.FIXME: write doc |
| CSoLineSet | 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 |
| CSoLineWidthElement | 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 |
| CSoListener | 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 |
| CSoListenerDopplerElement | 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 |
| CSoListenerGainElement | 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 |
| CSoListenerOrientationElement | 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 |
| CSoListenerPositionElement | 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 |
| CSoLocalBBoxMatrixElement | Yet to be documented.FIXME: write doc |
| CSoLocateHighlight | 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 |
| CSoLocation2Event | 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 |
| CSoLOD | 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 |
| CSoMarkerSet | 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 |
| CSoMaterial | 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 |
| CSoMaterialBinding | 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 |
| CSoMaterialBindingElement | Yet to be documented.FIXME: write doc |
| CSoMaterialBundle | Simplifies 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 |
| CSoMatrixTransform | 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 |
| CSoMemoryError | 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 |
| CSoMFBitMask | 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 |
| CSoMFBool | 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 |
| CSoMFColor | 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) |
| CSoMFColorRGBA | 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) |
| CSoMFDouble | 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 |
| CSoMFEngine | 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 |
| CSoMFEnum | 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 |
| CSoMFFloat | 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 |
| CSoMField | 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 |
| CSoMFInt32 | 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 |
| CSoMFMatrix | Container for SbMatrix values.This field is used where nodes, engines or other field containers needs to store matrices |
| CSoMFName | Container for SbName values.This field is used where nodes, engines or other field containers needs to store arrays of names |
| CSoMFNode | 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 |
| CSoMFPath | 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 |
| CSoMFPlane | Container for SbPlane values.This field is used where nodes, engines or other field containers needs to store multiple 3D plane definitions |
| CSoMFRotation | Container for SbRotation values.This field is used where nodes, engines or other field containers needs to store multiple rotation definitions |
| CSoMFShort | 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 |
| CSoMFString | Container for SbString values.This field is used where nodes, engines or other field containers needs to store arrays of strings |
| CSoMFTime | Container for SbTime values.This field is used where nodes, engines or other field containers needs to store multiple time representations |
| CSoMFUInt32 | 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 |
| CSoMFUShort | 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 |
| CSoMFVec2b | 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 |
| CSoMFVec2d | 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 |
| CSoMFVec2f | 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 |
| CSoMFVec2i32 | 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 |
| CSoMFVec2s | 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 |
| CSoMFVec3b | 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 |
| CSoMFVec3d | 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 |
| CSoMFVec3f | 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 |
| CSoMFVec3i32 | 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 |
| CSoMFVec3s | 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 |
| CSoMFVec4b | 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 |
| CSoMFVec4d | 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 |
| CSoMFVec4f | 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 |
| CSoMFVec4i32 | 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 |
| CSoMFVec4s | 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 |
| CSoMFVec4ub | 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 |
| CSoMFVec4ui32 | 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 |
| CSoMFVec4us | 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 |
| CSoModelMatrixElement | Used to manage the current transformation.SoModelMatrixElement contains the object-to-world matrix |
| CSoMotion3Event | 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 |
| CSoMouseButtonEvent | 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 |
| CSoMultipleCopy | Redraws it's children multiple times at different transformations.The SoMultipleCopy group node duplicates it's children nodes / subgraphs without using additional memory resources |
| CSoMultiTextureEnabledElement | Element 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 |
| CSoMultiTextureImageElement | Yet to be documented.FIXME: write doc |
| CSoMultiTextureMatrixElement | Used 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 |
| CSoNode | 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 |
| CSoNodeEngine | 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 |
| CSoNodeKit | 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 |
| CSoNodekitCatalog | Container for nodekit layouts.Nodekits store all their hierarchical layout information and part information in instances of this class |
| CSoNodeKitDetail | 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 |
| CSoNodeKitListPart | Container node.This node is basically just a container node with these differences versus the other group nodes: |
| CSoNodeKitPath | Path that contains only nodekit nodes.All other nodes are hidden from the user |
| CSoNodeList | Container for pointers to SoNode objects |
| CSoNodeSensor | 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 |
| CSoNonIndexedShape | Superclass for all non-indexed vertex based shapes.It contains the (now obsoleted) startIndex field and a convenience method for calculating the bounding box |
| CSoNormal | 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 |
| CSoNormalBinding | 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 |
| CSoNormalBindingElement | The SoNormalBindingElement is yet to be documented.FIXME: write doc |
| CSoNormalBundle | Simplifies normal handling.This class is currently not used in Coin but is provided for API compatibility |
| CSoNormalCache | 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 |
| CSoNormalElement | Yet to be documented.FIXME: write doc |
| CSoNormalGenerator | Used to generate normals.FIXME: document properly |
| CSoNotList | List of SoNotRec notification records |
| CSoNotRec | Records for notification lists |
| CSoNurbsCurve | 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" |
| CSoNurbsProfile | Node for specifying smooth profile curves.Use nodes of this type if you want to set up profiles that are smooth curves |
| CSoNurbsSurface | 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" |
| CSoOffscreenRenderer | 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) |
| CSoOneShot | Timer that runs for a configurable time and then stops |
| CSoOneShotSensor | 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()) |
| CSoOnOff | The SoOnOff engine is a simple on/off switch |
| CSoOrthographicCamera | 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 |
| CSoOutput | 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 |
| CSoOverrideElement | The SoOverrideElement maintains a list of overridable elements and a list over which elements should be overridden.Only certain elements can be overridden |
| CSoPackedColor | 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 |
| CSoPath | 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 |
| CSoPathList | 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 |
| CSoPathSensor | 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 |
| CSoPathSwitch | Traverses only when current path matches a configurable path.FILE FORMAT/DEFAULTS: |
| CSoPendulum | 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 |
| CSoPerspectiveCamera | 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 |
| CSoPickAction | 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 |
| CSoPickedPoint | 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 |
| CSoPickedPointList | 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 |
| CSoPickRayElement | Yet to be documented.FIXME: write doc |
| CSoPickStyle | 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 |
| CSoPickStyleElement | The SoPickStyleElement is yet to be documented.FIXME: write doc |
| CSoPointDetail | 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 |
| CSoPointLight | Node type for light sources.Pointlights emits light equally in all directions from a specified 3D location |
| CSoPointLightDragger | Interactive geometry for manipulating a point light source.Here's how the dragger looks with its default geometry in the inactive state: |
| CSoPointLightManip | Used to manipulate point light nodes. |
| CSoPointSet | 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 |
| CSoPointSizeElement | 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 |
| CSoPolygonOffset | 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 |
| CSoPolygonOffsetElement | Yet to be documented.FIXME: write doc |
| CSoPrimitiveVertex | 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 |
| CSoPrimitiveVertexCache | |
| CSoProfile | Abstract superclass for profile definitions.Node subclasses of SoProfile specifies profiles for extruded 3D text and nurbs surface data |
| CSoProfileCoordinate2 | Node specifying a set of 2D coordinates for profiles.Use nodes of this type to provide coordinates to profiles |
| CSoProfileCoordinate3 | Node specifying a set of 3D coordinates for profiles.Use nodes of this type to provide coordinates to profiles |
| CSoProfileCoordinateElement | Yet to be documented.FIXME: write doc |
| CSoProfileElement | Yet to be documented.FIXME: write doc |
| CSoProfiler | Main static class for initializing the scene graph profiling subsystem |
| CSoProfilerElement | The SoProfilerElement element class is for registering statistics during scene graph traversals |
| CSoProfilerStats | Node for exposing profiling results gathered by SoProfilerElement |
| CSoProfilingReportGenerator | Convenience report generator functionality |
| CSoProto | Handles PROTO definitions |
| CSoProtoInstance | Handles PROTO instances |
| CSoQuadMesh | 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 |
| CSoRayPickAction | 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 |
| CSoReadError | Used during model import operations.During model file import, this class will be used to output any error or warning messages |
| CSoRenderManager | Used for controlling the rendering of a scene graph |
| CSoReorganizeAction | Reorganizes your scene graph to optimize traversal/rendering |
| CSoReplacedElement | 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 |
| CSoResetTransform | 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 |
| CSoRotateCylindricalDragger | For rotating geometry around a single axis.Here's how the dragger looks with its default geometry in the inactive state: |
| CSoRotateDiscDragger | For rotating geometry around a single axis.Here's how the dragger looks with its default geometry in the inactive state: |
| CSoRotateSphericalDragger | For rotating geometry in any direction.Here's how the dragger looks with its default geometry in the inactive state: |
| CSoRotation | Rotation transformation.Use nodes of this class type to re-orient geometry data within the scene graph |
| CSoRotationXYZ | 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 |
| CSoRotor | 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 |
| CSoScale | 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 |
| CSoScale1Dragger | Mechanism for the end-user to scale in one dimension.Here's how the dragger looks with its default geometry in the inactive state: |
| CSoScale2Dragger | Mechanism for the end-user to scale in two dimensions.Here's how the dragger looks with its default geometry in the inactive state: |
| CSoScale2UniformDragger | Mechanism for the end-user to scale in two dimensions.Here's how the dragger looks with its default geometry in the inactive state: |
| CSoScaleUniformDragger | Mechanism for the end-user to scale in three dimensions.Here's how the dragger looks with its default geometry in the inactive state: |
| CSoSceneKit | 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): |
| CSoSceneManager | 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 |
| CSoSceneTexture2 | 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 |
| CSoSceneTextureCubeMap | Renders a scene into a texture cube map |
| CSoScXMLDollyTarget | SCXML event target service for zoom-behaviour |
| CSoScXMLEvent | Adds an SoEvent holder to the ScXMLEvent base |
| CSoScXMLFlightControlTarget | SCXML navigation service for typical flight motions |
| CSoScXMLMiscTarget | Some misc navigation utility functions |
| CSoScXMLMotionTarget | To be used in parallel with other non-moving targets when parallel states are implemented |
| CSoScXMLNavigation | Static class for some static init/cleanup/synchronization functions |
| CSoScXMLNavigationTarget | Base class for navigation system SCXML event target services |
| CSoScXMLPanTarget | Navigation system event target for panning operations |
| CSoScXMLRotateTarget | Navigation system event target for rotating operations |
| CSoScXMLSeekTarget | Navigation system event target for seekmotion operations |
| CSoScXMLSpinTarget | Navigation system event target for spinning operations |
| CSoScXMLStateMachine | Integration level for using Coin events with SCXML-based state machines |
| CSoScXMLZoomTarget | SCXML event target service for zoom-behaviour |
| CSoSearchAction | 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) |
| CSoSelection | 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 |
| CSoSelectOne | Used to select one value from a set of values.The output field will be the index'th value of the input multivalue field |
| CSoSensor | 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 |
| CSoSensorManager | Handles the sensor queues.There are two major sensor types in Coin, "delay" sensors and "timer" sensors: |
| CSoSeparator | 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 |
| CSoSeparatorKit | Typical set of nodes to influence a shape subgraph.Node kit structure (new entries versus parent class marked with arrow prefix): |
| CSoSFBitMask | 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 |
| CSoSFBool | 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 |
| CSoSFBox2d | Container for an SbBox2d vector.This field is used where nodes, engines or other field containers needs to store a box |
| CSoSFBox2f | Container for an SbBox2f vector.This field is used where nodes, engines or other field containers needs to store a box |
| CSoSFBox2i32 | Container for an SbBox2i32 vector.This field is used where nodes, engines or other field containers needs to store a box |
| CSoSFBox2s | Container for an SbBox2s vector.This field is used where nodes, engines or other field containers needs to store a box |
| CSoSFBox3d | Container for an SbBox3d vector.This field is used where nodes, engines or other field containers needs to store a box |
| CSoSFBox3f | Container for an SbBox3f vector.This field is used where nodes, engines or other field containers needs to store a box |
| CSoSFBox3i32 | Container for an SbBox3i32 vector.This field is used where nodes, engines or other field containers needs to store a box |
| CSoSFBox3s | Container for an SbBox3s vector.This field is used where nodes, engines or other field containers needs to store a box |
| CSoSFColor | 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) |
| CSoSFColorRGBA | 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) |
| CSoSFDouble | 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 |
| CSoSFEngine | 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 |
| CSoSFEnum | 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 |
| CSoSFFloat | 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 |
| CSoSField | Base 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 |
| CSoSFImage | Used to store pixel images.The SoSFImage class provides storage for inline 2D image maps. Images in Coin are mainly used for texture mapping support |
| CSoSFImage3 | Used 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 |
| CSoSFInt32 | Container 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 |
| CSoSFMatrix | Container for an SbMatrix.This field is used where nodes, engines or other field containers needs to store a 4x4 matrix |
| CSoSFName | Container for an SbName.This field is used where nodes, engines or other field containers needs to store a single name string |
| CSoSFNode | Container 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 |
| CSoSFPath | Container 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 |
| CSoSFPlane | Container 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 |
| CSoSFRotation | Container for an SbRotation.This field is used where nodes, engines or other field containers needs to store a single rotation definition |
| CSoSFShort | Container for a short integer value.This field is used where nodes, engines or other field containers needs to store a single short integer value |
| CSoSFString | Container for an SbString.This field is used where nodes, engines or other field containers needs to store a single string |
| CSoSFTime | Container for an SbTime value.This field is used where nodes, engines or other field containers needs to store a single time representation |
| CSoSFTrigger | "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 |
| CSoSFUInt32 | Container 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 |
| CSoSFUShort | Container 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 |
| CSoSFVec2b | Container for an SbVec2b vector.This field is used where nodes, engines or other field containers needs to store a single vector with two elements |
| CSoSFVec2d | Container for an SbVec2d vector.This field is used where nodes, engines or other field containers needs to store a single vector with two elements |
| CSoSFVec2f | Container for an SbVec2f vector.This field is used where nodes, engines or other field containers needs to store a single vector with two elements |
| CSoSFVec2i32 | Container for an SbVec2i32 vector.This field is used where nodes, engines or other field containers needs to store a single vector with two elements |
| CSoSFVec2s | Container for an SbVec2s vector.This field is used where nodes, engines or other field containers needs to store a single vector with two elements |
| CSoSFVec3b | Container for an SbVec3b vector.This field is used where nodes, engines or other field containers needs to store a single vector with three elements |
| CSoSFVec3d | Container for an SbVec3d vector.This field is used where nodes, engines or other field containers needs to store a single vector with three elements |
| CSoSFVec3f | Container for an SbVec3f vector.This field is used where nodes, engines or other field containers needs to store a single vector with three elements |
| CSoSFVec3i32 | Container for an SbVec3i32 vector.This field is used where nodes, engines or other field containers needs to store a single vector with three elements |
| CSoSFVec3s | Container for an SbVec3s vector.This field is used where nodes, engines or other field containers needs to store a single vector with three elements |
| CSoSFVec4b | Container for an SbVec4b vector.This field is used where nodes, engines or other field containers needs to store a single vector with four elements |
| CSoSFVec4d | Container for an SbVec4d vector.This field is used where nodes, engines or other field containers needs to store a single vector with four elements |
| CSoSFVec4f | Container for an SbVec4f vector.This field is used where nodes, engines or other field containers needs to store a single vector with four elements |
| CSoSFVec4i32 | Container for an SbVec4i32 vector.This field is used where nodes, engines or other field containers needs to store a single vector with four elements |
| CSoSFVec4s | Container for an SbVec4s vector.This field is used where nodes, engines or other field containers needs to store a single vector with four elements |
| CSoSFVec4ub | Container for an SbVec4ub vector.This field is used where nodes, engines or other field containers needs to store a single vector with four elements |
| CSoSFVec4ui32 | Container for an SbVec4ui32 vector.This field is used where nodes, engines or other field containers needs to store a single vector with four elements |
| CSoSFVec4us | Container for an SbVec4us vector.This field is used where nodes, engines or other field containers needs to store a single vector with four elements |
| CSoShaderObject | |
| CSoShaderParameter | |
| CSoShaderProgram | Used to specify a set of vertex/geometry/fragment objects |
| CSoShadowCulling | Node for setting the shadow style on nodes |
| CSoShadowDirectionalLight | Node for setting up a directional light which casts shadows |
| CSoShadowGroup | The 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 |
| CSoShadowSpotLight | Node for setting up a spot light which casts shadows |
| CSoShadowStyle | Node for setting the shadow style on nodes |
| CSoShadowStyleElement | Yet to be documented.FIXME: write doc |
| CSoShape | Superclass 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 |
| CSoShapeHints | Node 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 |
| CSoShapeKit | Templates to insert what is usually needed for shape nodes.Node kit structure (new entries versus parent class marked with arrow prefix): |
| CSoShapeSimplifyAction | Replaces complex primitives with simplified polygon representations |
| CSoShapeStyleElement | Yet to be documented.FIXME: write doc |
| CSoShininessElement | Yet to be documented.FIXME: write doc |
| CSoShuttle | Used 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 |
| CSoSimplifyAction | Base class for the simplify action classes |
| CSoSoundElement | The SoSoundElement is used for optimizing audio rendering and for turning off inactive SoVRMLSound nodes |
| CSoSpaceballButtonEvent | Information 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 |
| CSoSpecularColorElement | The SoSpecularColorElement is yet to be documented.FIXME: write doc |
| CSoSphere | For 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) |
| CSoSpotLight | Node 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 |
| CSoSpotLightDragger | Interactive geometry for manipulating a spotlight.Here's how the dragger looks with its default geometry in the inactive state: |
| CSoSpotLightManip | Used to manipulate spot light nodes. |
| CSoState | Manages 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) |
| CSoSTLFileKit | SoSTLFileKit is a class for using STL files with Coin |
| CSoSurroundScale | Used 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 |
| CSoSwitch | Group 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 |
| CSoSwitchElement | Yet to be documented.FIXME: write doc |
| CSoTabBoxDragger | The 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: |
| CSoTabBoxManip | Wraps an SoTabBoxDragger. |
| CSoTabPlaneDragger | Dragger you can translate and scale within a plane.Here's how the dragger looks with its default geometry in the inactive state: |
| CSoTempPath | Used 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 |
| CSoText2 | Node 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 |
| CSoText3 | Renders extruded 3D text.Render text as 3D geometry |
| CSoTextDetail | The 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 |
| CSoTextOutlineEnabledElement | Yet to be documented.FIXME: write doc |
| CSoTexture2 | Used 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 |
| CSoTexture2Convert | Abstract base class for texture filtering engines |
| CSoTexture2Transform | Used 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 |
| CSoTexture3 | Used 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) |
| CSoTexture3Transform | Used 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 |
| CSoTextureCombine | Node 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 |
| CSoTextureCombineElement | Yet to be documented.FIXME: write doc |
| CSoTextureCoordinate2 | Set 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 |
| CSoTextureCoordinate3 | Set 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 |
| CSoTextureCoordinateBinding | Says 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 |
| CSoTextureCoordinateBindingElement | Yet to be documented.FIXME: write doc |
| CSoTextureCoordinateBundle | Simplifies 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 |
| CSoTextureCoordinateCache | |
| CSoTextureCoordinateCube | Autogenerates cubemapped texture coordinated for shapes.The cube used for reference when mapping is the boundingbox for the shape |
| CSoTextureCoordinateCylinder | Autogenerates cylinder mapped texture coordinated for shapes.FILE FORMAT/DEFAULTS: |
| CSoTextureCoordinateDefault | Removes 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 |
| CSoTextureCoordinateEnvironment | Generates 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 |
| CSoTextureCoordinateFunction | Abstract base class for texture coordinate generating nodesClasses reimplementing SoTextureCoordinateFunction generate texture coordinates by projecting object space surface points using some function |
| CSoTextureCoordinateNormalMap | Generates 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 |
| CSoTextureCoordinateObject | Generates texture coordinates by...FIXME: not implemented yet. pederb, 2005-04-20 |
| CSoTextureCoordinatePlane | Generates 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 |
| CSoTextureCoordinateReflectionMap | Generates 3D reflection texture coordinates.This node is usually used along with a SoCubeMapTexture node.. |
| CSoTextureCoordinateSphere | Autogenerates spheremapped texture coordinated for shapes.FILE FORMAT/DEFAULTS: |
| CSoTextureCubeMap | Used 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 |
| CSoTextureMatrixTransform | Used 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 |
| CSoTextureOverrideElement | The SoTextureOverrideElement makes it possible to override texture elements |
| CSoTextureQualityElement | The SoTextureQualityElement is yet to be documented.FIXME: write doc |
| CSoTextureScalePolicy | Node 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 |
| CSoTextureUnit | Node 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 |
| CSoTextureUnitElement | Yet to be documented |
| CSoTimeCounter | Integer 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 |
| CSoTimerQueueSensor | Abstract base class for sensors triggering on certain timer events.Timer sensors triggers upon specific points in time |
| CSoTimerSensor | Sensor 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) |
| CSoToVRML2Action | Builds 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 |
| CSoToVRMLAction | Builds 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 |
| CSoTrackballDragger | The 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: |
| CSoTrackballManip | The SoTrackballManip wraps an SoTrackballDragger for convenience. |
| CSoTransform | "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 |
| CSoTransformation | Abstract 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 |
| CSoTransformBoxDragger | The 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: |
| CSoTransformBoxManip | The SoTransformBoxManip wraps an SoTransformBoxDragger for convenience. |
| CSoTransformerDragger | The SoTransformerDragger provides geometry for translation, scaling and rotations.Here's how the dragger looks with its default geometry in the inactive state: |
| CSoTransformerManip | The SoTransformerManip wraps an SoTransformerDragger for convenience. |
| CSoTransformManip | Used 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 |
| CSoTransformSeparator | Group 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 |
| CSoTransformVec3f | Transforms 3D vectors by a matrix |
| CSoTranslate1Dragger | Mechanism for the end-user to translate along an axis.Here's how the dragger looks with its default geometry in the inactive state: |
| CSoTranslate2Dragger | Mechanism for the end-user to translate in a plane.Here's how the dragger looks with its default geometry in the inactive state: |
| CSoTranslation | Node type for specifying geometry translations.For simply translating some geometry in a scene graph, you can use this node type |
| CSoTransparencyElement | The SoTransparencyElement is yet to be documented.FIXME: write doc |
| CSoTransparencyType | Node 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 |
| CSoTriangleStripSet | Used to render and control non-indexed triangle strips.Triangle strips are specified using the numVertices field |
| CSoTriggerAny | Fan-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 |
| CSoType | Basis 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 |
| CSoTypeList | Container class for arrays of SoType objects |
| CSoUnits | Node 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 |
| CSoUnitsElement | Yet to be documented.FIXME: write doc |
| CSoVertexAttribute | A generic node for providing GL vertex attributes of various types |
| CSoVertexAttributeBinding | Node for setting up how vertex attributes are mapped to shapes |
| CSoVertexAttributeBindingElement | Yet to be documented.FIXME: write doc |
| CSoVertexAttributeBundle | Simplifies vertex attribute handling |
| CSoVertexProperty | Collects 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 |
| CSoVertexShader | Used for setting up vertex shader programs.See Shaders in Coin for more information on how to set up a scene graph with shaders |
| CSoVertexShape | Superclass 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 |
| CSoViewingMatrixElement | Stores the world-to-camera transformation |
| CSoViewportRegionElement | Yet to be documented.FIXME: write doc |
| CSoViewVolumeElement | Yet to be documented.FIXME: write doc |
| CSoVRMLAnchor | Used 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: |
| CSoVRMLAppearance | Visual 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: |
| CSoVRMLAudioClip | Used 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) |
| CSoVRMLBackground | Used 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: |
| CSoVRMLBillboard | Used 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: |
| CSoVRMLBox | Used 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: |
| CSoVRMLCollision | Used 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: |
| CSoVRMLColor | Used 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: |
| CSoVRMLColorInterpolator | Used 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: |
| CSoVRMLCone | Used 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: |
| CSoVRMLCoordinate | Used 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: |
| CSoVRMLCoordinateInterpolator | Used 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: |
| CSoVRMLCylinder | Used 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: |
| CSoVRMLCylinderSensor | Maps 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: |
| CSoVRMLDirectionalLight | Node 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: |
| CSoVRMLDragSensor | Superclass for VRML drag sensors |
| CSoVRMLElevationGrid | Used 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: |
| CSoVRMLExtrusion | A 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: |
| CSoVRMLFog | Used 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: |
| CSoVRMLFontStyle | Used 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 |
| CSoVRMLGeometry | Superclass for VRML shapes |
| CSoVRMLGroup | Used 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: |
| CSoVRMLImageTexture | Used 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: |
| CSoVRMLIndexedFaceSet | Used 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: |
| CSoVRMLIndexedLine | Abstract 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. |
| CSoVRMLIndexedLineSet | Used 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: |
| CSoVRMLIndexedShape | Superclass for geometry that use indexes |
| CSoVRMLInline | Used 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: |
| CSoVRMLInterpolator | Internal abstract class |
| CSoVRMLLight | Superclass for VRML light nodes |
| CSoVRMLLOD | Used 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: |
| CSoVRMLMaterial | Used 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: |
| CSoVRMLMovieTexture | Used 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: |
| CSoVRMLNavigationInfo | Used 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: |
| CSoVRMLNormal | Used 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: |
| CSoVRMLNormalInterpolator | Used 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: |
| CSoVRMLOrientationInterpolator | Used 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: |
| CSoVRMLParent | The SoVRMLParent node is a superclass for all VRML grouping nodes |
| CSoVRMLPixelTexture | Used 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: |
| CSoVRMLPlaneSensor | Maps 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: |
| CSoVRMLPointLight | Used 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: |
| CSoVRMLPointSet | Used 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: |
| CSoVRMLPositionInterpolator | Used 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: |
| CSoVRMLProximitySensor | Used 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: |
| CSoVRMLScalarInterpolator | Used to interpolate scalar values |
| CSoVRMLScript | Used 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: |
| CSoVRMLSensor | Abstract superclass for VRML sensors |
| CSoVRMLShape | Holds 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: |
| CSoVRMLSound | Used 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: |
| CSoVRMLSphere | Used 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: |
| CSoVRMLSphereSensor | Maps 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: |
| CSoVRMLSpotLight | Defines 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: |
| CSoVRMLSwitch | Group 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: |
| CSoVRMLText | Used 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: |
| CSoVRMLTexture | Superclass for VRML texture nodes |
| CSoVRMLTextureCoordinate | Binds 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: |
| CSoVRMLTextureTransform | Defines 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: |
| CSoVRMLTimeSensor | Multi-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: |
| CSoVRMLTouchSensor | Tracks 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: |
| CSoVRMLTransform | Grouping 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: |
| CSoVRMLVertexLine | Superclass for line based VRML geometry |
| CSoVRMLVertexPoint | Superclass for point based VRML shapes |
| CSoVRMLVertexShape | Superclass for vertex based shapes |
| CSoVRMLViewpoint | Perspective 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: |
| CSoVRMLVisibilitySensor | Will 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: |
| CSoVRMLWorldInfo | Information 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: |
| CSoWindowElement | Used 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 |
| CSoWrapperKit | Simple kit for wrapping a transform and a sub-graph |
| CSoWriteAction | Writes 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 |
| CSoWWWAnchor | Adds 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 |
| CSoWWWInline | Node 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 © by Kongsberg Oil & Gas Technologies. All rights reserved.
Generated for Coin by Doxygen