Class List

Here are the classes, structs, unions and interfaces with brief descriptions:

[detail level 1234]

►NH3D	H3D API namespace
►NSAI
CSAIError	This section defines the error types that may be generated in response to service requests
CComponentInfo	The ComponentInfo object stores information about a particular X3D component
CProfileInfo	This object stores information about a particular X3D profile
►NSpiderMonkey
CPointerPrivateData	Class used as the private data in field JSObject classes
CSFMatrix3fRow	X3DMatrix3
CSFMatrix4fRow	X3DMatrix4
CJS_MField	MField template
►NTypedFieldTypeCheck	Contains template classes for doing the type checking for the TypedField template class
CAny	The Any template can be used in the RequiredArgTypes or OptionalArgTypes arguments of a TypedField template instantiation
CInvalidTemplateArguments	InvalidTemplateArguments An exception thrown when the template argument list does not follow the rules defined in TypedField
CAnyNumber	The AnyNumber template can be used in the OptionalArgTypes argument of a TypedField template instantiation
CTypes	The Types template can be used in the RequiredArgTypes or OptionalArgTypes arguments of a TypedField template instantiation
►NX3D	X3D namespace
►NConvert	The Convert namespace contains help functions for parsing a string and converting it to a X3D field value
CX3DFieldConversionError	An exception for errors when string to convert to a field value is invalid for the field type
CUnimplementedConversionType	An exception for errors when the conversion from a string to the type that we try convert to is not implemented
CDEFNodesBase	Base class that adds functionallity needed for reference count debugging
CInvalidNodeType	An exception for errors when the Node type is not what was expected
CNoSuchDEFName	An exception for errors when the DEF name does not exist in the DEF nodes structure
CDEFNodes	Provides a mapping between defined DEF names in X3D and the nodes they refer to
CIStreamInputSource	This class is a derivative of the standard Xerxes C InputSource class
CIStreamInputStream	This class implements the BinInputStream interface to read from a istream
CXMLParseError	An exception for errors occuring while parsing an X3D XML file
►CX3DSAX2Handlers	This class implements the SAX2 ContentHandler and ErrorHandler interface in order to build an H3D scenegraph from a X3D XML file
CNodeElement	Encapsulate a node with its XML containerField attribute
►CAnchor	The Anchor grouping node retrieves the content of a URL when the user activates (e.g., clicks) some geometry contained within the Anchor node's children
CGeometrySelected	Takes care of changing the scene when an object in the Anchor is selected (by clicking on it with the mouse)
CAnyDevice	AnyDevice tries to initialize all available HAPI haptics device nodes and uses the first one that succeeds
CAppearance	The Appearance node specifies the visual properties of geometry
►CArc2D	The Arc node specifies a linear circular arc whose center is at (0,0) and whose angles are measured starting at the positive x-axis and sweeping towards the positive y-axis
CDisplayList	Display list is extended in order to set color to emissive color from material outside of display list, since we have to do a glGet to get the value
CSFBound	SFBound is specialized update itself from the radius field of the Box node
►CArcClose2D	The ArcClose node specifies a portion of a circle whose center is at (0,0) and whose angles are measured starting at the positive x-axis and sweeping towards the positive y-axis
CSFBound	SFBound is specialized update itself from the radius field of the Box node
CAudioClip	An AudioClip node specifies audio data that can be referenced by Sound nodes
CAudioFileReader	AudioFileReader uses the Audio File Library ( http://www.68k.org/~michael/audiofile/ ) to read sound data
CBackground	A background node that uses six static images to compose the backdrop
►CBillboard	The Billboard node is a grouping node which modifies its coordinate system so that the Billboard node's local Z-axis turns to point at the viewer
CSFMatrix4f	Specialize the SFMatrix4f to update the matrix from the fields in the Billboard node
►CBooleanFilter	BooleanFilter filters boolean events, allowing for selective routing of TRUE or FALSE values and negation
CNegateSFBool	This field class takes as input SFBool fields and sets its value to the negated value of the input field
CSetBoolean	Specialize to set the value of either the inputTrue or inputFalse field in the BooleanFilter node it resides in, depending on the value that is is given
CBooleanSequencer	BooleanSequencer generates sequential SFBool events when driven from a TimeSensor clock
►CBooleanToggle	BooleanToggle stores a boolean value for toggling on/off
CSetBoolean	Specialize to negate the value of the toggle field if a true event is given
►CBooleanTrigger	BooleanTrigger is a trigger node that generates boolean events upon receiving time events
CSetBoolean	If a time event is given, generate a true event
CBound	Abstract base class for all classes specifying bounding objects
CInfiniteBound	An InfiniteBound is a Bound that encompasses everything
CEmptyBound	An EmptyBound is a Bound that encompasses nothing
CBoxBound	The BoxBound is a Bound class that specifies the bound using an axis-aligned bounding box
►CTransformedBoxBound	A TransformedBoxBound is a wrapper around another BoxBound and its values are the values of the BoxBound transformed by a transformation matrix
CCenter	The Center field updates itself from the boxBound and matrix fields
CSize	The Size field updates itself from the boxBound and matrix fields
CBoundedPhysicsModel	The BoundedPhysicsModel node specifies a physics model that applies a user-defined set of geometrical bounds to the particles
►CBox	The Box node specifies a rectangular parallelepiped box centred at (0, 0, 0) in the local coordinate system and aligned with the local coordinate axes
CSFBound	SFBound is specialized update itself from the size field of the Box node
►CCapsule	The Capsule node specifies a cylinder, with half-sphere as end caps, centred at (0,0,0) in the local coordinate system and with a central axis oriented along the local Y-axis
CSFBound	SFBound is specialized update itself from the radius and heigh field of the Capsule node
►CCircle2D	The Circle2D node specifies a circle centred at (0,0) in the local 2D coordinate system
CDisplayList	Display list is extended in order to set color to emissive color from material outside of display list, since we have to do a glGet to get the value
CSFBound	SFBound is specialized update itself from the radius field of the Circle2D node
CClipPlane	This node defines a single plane equation that will be used to clip the geometry, i.e
►CClutchedDevice	ClutchedDevice is a wrapper for a H3DHapticsDevice which adds clutching functionality
CEnableClutch	Enables/Disbles the clutching
CResetClutchOrientation	If True, resets the orientation offset due to clutching
CResetClutchPosition	If True, resets the position offset due to clutching
CCollision	The Collision node is a grouping node that specifies the collision detection properties for its children (and their descendants), specifies surrogate objects that replace its children during collision detection, and sends events signalling that a collision has occurred between the avatar and the Collision node's geometry or surrogate
CCollisionOptions	Options related to collision in H3DAPI
CColor	This node defines a set of RGB colours to be used in the fields of another node
►CColorInterpolator	This node interpolates among a list of MFColor key values to produce an SFColor (RGB) value_changed event
CSFValue	The SFValue field updates the interpolated value from the fields routed to it
CColorRGBA	This node defines a set of RGBA colours to be used in the fields of another node
CComposed3DTexture	The Composed3DTexture node defines a 3D image-based texture map as a collection of 2D texture sources at various depths and parameters controlling tiling repetition of the texture onto geometry
CComposedCubeMapTexture	The ComposedCubeMapTexture node defines a cubic environment map source as an explicit set of images drawn from individual 2D texture descriptions
CComposedGeneratedShader	The ComposedGeneratedShader node composes vertex shader manipulator shaders with fragment shaders
►CComposedShader	The ComposedShader node defines a shader where the individual source files are not individually programmable
CMFShaderPart	MFShaderPart is specialized to transfer a pointer from itself to the ShaderPart instances contained in the field
CSetupDynamicRoutes	Class used to set up routes from nodes in SFNode and MFNode fields to correctly break cache
CUpdateCache	Event collection field to update when global caching is update
CUpdateUniforms	A field used to update any uniforms from their corresponding fields
►CCone	The Cone node specifies a cone which is centred in the local coordinate system and whose central axis is aligned with the local Y-axis
CSFBound	SFBound is specialized update itself from the radius and heigh field of the Cone node
CConeEmitter	The ConeEmitter node is an emitter that generates all the available particles from a specific point in space
►CContour2D	The Contour2D node groups a set of curve segments to a composite contour
CAddTheChildren	This field class checks whether the given node is of the right type (ContourPolyline2D or NurbsCurve2D)
CCheckTheChildren	This field class checks whether the given Node is of the right type (ContourPolyline2D or NurbsCurve2D) for adding or removing
CRemoveTheChildren	This field class checks whether the given node is of the right type (ContourPolyline2D or NurbsCurve2D)
CContourPolyline2D	The ContourPolyline2D node defines a piecewise linear curve segment as a part of a trimming contour in the u,v domain of a surface
CConvolutionFilterShader	The ConvolutionFilterShader node generates a shader that applies a convolution filter kernel to the input texture
CCoordBoundField	The CoordBoundField is specialized update itself from a X3DCoordinateNode
CCoordinate	This node defines a set of 3D coordinates to be used in the coord field of vertex-based geometry nodes
CCoordinateDeformer	The CoordinateDeformer uses a H3DFunctionNode to determine the deformation
CCoordinateDouble	This node defines a set of 3D coordinates to be used in the coord field of vertex-based geometry nodes
►CCoordinateInterpolator	This node linearly interpolates among a list of MFVec3f values to produce an MFVec3f value_changed event
CMFValue	The SFValue field updates the interpolated value from the fields routed to it
►CCoordinateInterpolator2D	This node linearly interpolates among a list of MFVec2f values to produce an MFVec2f value_changed event
CMFValue	The SFValue field updates the interpolated value from the fields routed to it
CCyberGloveSensor	Connects to a CyberGlove through the Virtual HandSDK
►CCylinder	The Cylinder node specifies a capped cylinder centred at (0,0,0) in the local coordinate system and with a central axis oriented along the local Y-axis
CSFBound	SFBound is specialized update itself from the radius and heigh field of the Cylinder node
►CCylinderSensor	The CylinderSensor node maps pointer motion (e.g., a mouse or wand) into a rotation on an invisible cylinder that is aligned with the Y-axis of the local sensor coordinate system
CCheckAngleLimits	The CheckAngleLimits field checks that the float is in the correct range
CDDSImageLoader	DDSImageLoader is used to load DirectDraw Surface images (.dds)
CDebugOptions	Specifies parameters for if displaying debug information like bounding boxes, haptically rendered triangles etc
CDefaultAppearance	Specifies the default appearance parameters to use for graphical rendering
►CDeformableShape	The DeformableShape is an X3DShapeNode which makes it possible to deform the geometry of the shape when touching it with a haptics device
CSFGeometryNode	The SFGeometryNode is extended to only accept X3DComposedGeometryNode nodes
CFieldRef	Class used for specifying a field member of a node in a DependentSFNode or DependentMFNode specification
CDependentSFNode	DependentSFNode are modified TypedSFNode fields where the field dirty status is dependent on fields in the node it contains
CDependentMFNode	DependentMFNode are modified TypedMFNode fields where the field dirty status is dependent on fields in the nodes it contains
CDependentSFNodeObject	DependentSFNodeObject is similar to DependentSFNode but uses TypedSFNodeObject instead of TypedSFNode
CDependentMFNodeObject	DependentMFNodeObject is similar to DependentMFNode but uses TypedMFNodeObject instead of TypedMFNode
►CDepthMapSurface	Uses a 2D texture to modify the depth of the surface
CSetImagePtr	Field used to transfer the routed image to the HAPISurfaceObject
CSFTexture2DNode	Field that contains an X3DTexture2DNode
CDeviceInfo	DeviceInfo is a X3DBindableNode that contains the devices that are used with the API
CDeviceLog	DeviceLog records haptic device data to a binary data file
CDicomImageLoader	DicomImageLoader uses the DCMTK library to load a DICOM image file
CDirectionalLight	The DirectionalLight node defines a directional light source that illuminates along rays parallel to a given 3-dimensional vector
CDirectShowDecoder	This node uses DirectShow to decode video clips
►CDisk2D	The Disk2D node specifies a circular disk which is centred at (0, 0) in the local coordinate system
CSFBound	SFBound is specialized update itself from the radius field of the Box node
►CDynamicTransform	The DynamicTransform node is a Shape container that has basic properties for defining rigid body motion
CSFAngularVelocity	Calculates the angular velocity based on the inertia tensor and angular momentum
CSFMatrix4f	Specialize the SFMatrix4f to update the matrix from the fields in the Transform node
CSFMotion	Time dependant field to perform the RK4 integration for determining the motion of the dynamic transform routes_in[0] time field
CSFSpin	Calculates the spin (time derivative of the orientation)
CSFVelocity	Calculates the velocity based on the mass and momentum
►CEaseInEaseOut	The EaseInEaseOut node supports controlled gradual transitions by specifying modifications for TimeSensor node fractions
CSFFraction	Class for modified fraction_changed field type
CUnequalFieldValues	Thrown when number of field values in key and easeInEaseOut are not equal
►CElevationGrid	The ElevationGrid node specifies a uniform rectangular grid of varying height in the Y=0 plane of the local coordinate system
CAutoNormal	Specialized field for automatically generating normals from coordinates
CDisplayList	Display list is extended in order to set front sidedness of triangles outside the display list
CSFBound	SFBound is specialized update itself from the fields of the ElevationGrid
►CEntactDevice	A EntactDevice is a node for handling communication with a haptics device from Entact
CCalibrate	Field class that calibrates the device when a true event is received or the field is set to true
CEnvironmentMapShader	The EnvironmentMapShader node defines a shader for environment mapping of shiny objects
CExplosionEmitter	The ExplosionEmitter node is an emitter that generates all the available particles from a specific point in space at the initial time
►CExtrusion	The Extrusion node specifies geometric shapes based on a two dimensional cross-section extruded along a three dimensional spine in the local coordinate system
CAutoNormal	Specialized field for automatically generating normals from coordinates
CSFBound	SFBound is specialized update itself from the fields of the Extrusion
CVertexVector	Specialized field vertex coordinates from the fields affecting this, the resulting vertexVector will be used both in render and in bound
CFakeHapticsDevice	A H3DHapticsDevice node where the position, orientation and button can be controlled via the set_devicePosition, set_deviceOrientation and set_mainButton fields
CFalconDevice	A FalconDevice is a node for handling communication with a haptics device from Novint, such as the Falcon Novint
►CFBODebugger	The FBODebugger node provides a convenient way to check the result of all FrameBufferTextureGenerator nodes in the scene
CUpdateSaveToURL	A field used to execute the save to URL operation when the URL is set
CFFmpegDecoder	This node uses FFmpeg to decode video clips
►CField	The Field class
CEvent	The Event struct encapsulates an event in the field network
CFieldAccessError	Exception thrown when performing actions that conflict with the field's access type
CParsableField	This is a field which value can be set by a string from the X3D parser
CParsableMField	This is a field which value can be set by a string from the X3D parser
COnValueChangeSField	Template for adding the virtual function onValueChange that can be overridden in subclasses in order to perform actions when the value of the field changes in any way, i.e
COnNewValueSField	Template for adding the virtual function onNewValue that can be overridden in subclasses in order to perform actions when the value is updated in any way( setValue or update )
CTypedRefCountField	Template to make sure that the Node that is set in a SFNode is of a specified Node type
CAutoUpdate	The AutoUpdate field is a template to force the BaseField to update itself as soon as an event is received
CEventCollectingField	The EventCollection field collects all fields routed to it that generates event between calls to the update function of the field
CFillProperties	The FillProperties node specifies additional properties to be applied to all polygonal areas on top of whatever appearance is specified by the other fields of the respective Appearance node
►CFitToBoxTransform	The FitToBoxTransform node is a MatrixTransform that is used when one wants to transform a part of a scene into a specific region in the coordinate space
CSFMatrix4f	We specialize the SFMatrix4f field to that update itself from a SFBound field and two SFVec3f fields
CFloatVertexAttribute	The FloatVertexAttribute node defines a set of per-vertex single precision floating point attributes
CFog	The Fog node provides a way to simulate atmospheric effects by blending objects with the colour specified by the color field based on the distances of the various objects from the viewer
CFogCoordinate	This node defines a set of explicit fog depths on a per-vertex basis
►CFontStyle	The FontStyle node defines the size, family, and style used for Text nodes, as well as the direction of the text strings and any language-specific rendering techniques used for non-English text
CInvalidFontStyleJustify	Thrown when the strings in the justify field are invalid values
CInvalidFontStyleRenderType	Thrown when the strings in the renderType field are invalid values
CInvalidFontStyleStyle	Thrown when the string in the style field is an invalid value
►CForceDimensionDevice	A ForceDimensionDevice is a node for handling communication with a haptics device from ForceDimension, such as the Omega and Delta haptics devices
CBrakes	Brakes specializes SFBool to toggle brakes on and off
CChangeVibration	EnableForce specializes SFFloat to handle vibration
CEffectorMass	EffectorMass specializes SFFloat to change the end effector mass at change of value
CEnableForce	EnableForce specializes SFBool to toggle forces on and off
CGravityComp	GravityComp specializes SFBool to toggle gravity compensation on and off
CReset	Reset specializes SFBool to go into reset mode when a true event is received
CSFAutoCalibrate	SFAutoCalibrate specializes SFBool to go into auto calibrate mode when a true event is received
CSFReleasePosition	SFReleasePosition specializes SFVec3d to go set the release position of the contained haptics device
CWaitReset	WaitReset specializes SFBool to go into wait on reset mode when a true event is received
CForceField	This effect adds a constant force to all haptics devices at all times
►CFrameBufferTextureGenerator	The FrameBufferTextureGenerator node provides a mean to render a sub-scene into a texture instead of the normal frame buffer
CGetNrSamples	Specialized field class used to get the number of samples that can and will be used
CNeedMultiSample	Specialized field class used to check if multi sample support is needed
CResetPrintedFlag	A field used to reset the waning printed flag
CResetPrintedFlags	A field to reset multiple warning printed flags
CFreeImageLoader	FreeImageLoader uses the FreeImage library to load the images
CFrictionalSurface	Surface with friction
CFullscreenRectangle	The FullscreenRectangle node draws a rectangle covering the entire screen
►CFunctionPlotTexture	Texture showing a plot of a function
CSFImage	SFImage is overridden to update the image from the field values
►CGaussianFilterShader	The GaussianFilterShader is a ConvolutionFilterShader node where the weights are automatically calculated from a gaussian function
CMFWeights	Specialized field that reCalculate the kernel when it updates
CGaussianFunction	The function node implements a gaussian function
CGeneralDirectionalLight	The GeneralDirectionalLight node defines a directional light source that illuminates along rays parallel to a given 3-dimensional vector
►CGeneralFunction	The function node implements a general function R^n -> R by specifying it by a string
CSFFunctionObject	Class for updating an HAPI::ParsedFunction depending on field input value
CGeneralPointLight	The GeneralPointLight node specifies a point light source at a 3D location in the local coordinate system
CGeneralSpotLight	The GeneralSpotLight node defines a light source that emits light from a specific point along a specific direction vector and constrained within a solid angle
CGeneratedCubeMapTexture	The GeneratedCubeMapTexture node defines a cubic environment map that sources its data from internally generated images
CGeneratedTexture	The GeneratedTexture node is a 2d-texture node that are automatically generated from nodes like FrameBufferTextureGenerator
CGeneratedTexture3D	The GeneratedTexture3D node is a 3d-texture node that are automatically generated from nodes like FrameBufferTextureGenerator
CGeometryBoundTreeOptions	Specifies parameters to use for the tree of bounding primitives that are built for each X3DGeometryNode for collision detection purposes
►CGeometryGroup	The GeometryGroup node is treated by the scenegraph as one geometry but it can contain several geometries
CIsTouched	Specialized field class which grabs the first true value for each index for any of the contained geometries
CMFVec3fPerIndex	Specialized field class which gets one value from each routed field and stores that at the corresponding index in its own value
CSFBound	SFBound is specialized to update from the SFBound fields routed to it
CGlobalSettings	GlobalSettings is a X3DBindableNode that specifies default settings for use in H3D API, such as caching options, haptic rendering options etc
CGLUTWindow	H3DWindowNode implementet using GLUT
CGLVertexAttributeObject	This abstract interface is inherited by all nodes that could be used as vertex attributes in a glsl shader
►CGraphicsHardwareInfo	Information about the graphics hardware the program is being run on and its capabilities
CInfo	Holds information about the current graphics hardware
CGraphicsOptions	Specifies parameters to use for graphical rendering of nodes
CGravityPhysicsModel	The GravityPhysicsModel node specifies a physics model that applies a constant gravity value to the particles
CGroup	A Group node contains children nodes without introducing a new transformation
►CH3DBoundedObject	This abstract interface is the base class for all node types that include a bounding box
CSFBound	The Bound object is reference counted by the field
CH3DCoordinateDeformerNode	The H3DCoordinateDeformerNode is the abstract base class for all nodes specifying deformation of coordinates based on contact of haptics devices
►CH3DDisplayListObject	This abstract interface class is the base class for all node types that wants to create an OpenGL display list for the OpenGL calls it makes in its render() function
►CDisplayList	We use the Field's lazy evaluation mechanisms to manage the GL display lists for rendering, giving automatic cache breaking when dependencies are modified
CIsActive	The IsActive field is updated each scenegraph loop, since Scene::time is routed to it to see if the callList() function was called during or since the last loop
CH3DDynamicFieldsObject	This abstract interface class is the base class for all classes that specify arbitrary fields
►CH3DFakeHapticsDevice	<>
CGetValueSafeField	A field which ensure that getValue and only getValue can be called within haptic thread with thread safety
CH3DForceEffect	The base class for scenegraph force effects
►CH3DFrictionalSurfaceNode	Base class for surfaces with friction
CUpdateDynamicFriction	Specialized field which sets the dynamic_friction variable in H3DFrictionalSurfaceNode when the dynamicFriction field of H3DFrictonalSurface is changed
CUpdateStaticFriction	Specialized field which sets the static_friction variable in H3DFrictionalSurfaceNode when the staticFriction field of H3DFrictionalSurfaceNode is changed
►CH3DFunctionNode	Base class for nodes evaluating function
CValue	Field class that calculates the function value for the given input
CH3DGeneratedFragmentShaderNode	The H3DGeneratedFragmentShaderNode node is the base class for shader generator nodes that specify a fragment shader values
►CH3DGeneratedShaderNode	The H3DGeneratedShaderNode node is the base class for nodes that generates GLSL shaders for use in place of a ComposedShader in the Appearance field
CAttribute	Struct used to define an attribute in the shader
CRebuildShader	Specialized field that rebuilds the shader when it updates
CVaryingVariable	Struct used to define a varying variable in the shader
CH3DGeneratedVertexShaderNode	The H3DGeneratedVertexShaderNode node is the base class for shader generator nodes that only modify the vertex shader values and ignores the fragment shader
►CH3DHapticsDevice	Base class for all haptic devices
CSetEnabled	SetEnabled specializes SFBool to go into reset mode when a true event is received
CSFHapticsRendererNode	SFHapticsRendererNode extends TypedSFNode< H3DHapticsRendererNode > in order to change the haptics renderer for the used HAPIHapticsDevice when changing H3DHapticsRendererNode
CTrackerAngularVelocity	The TrackerAngularVelocity field updates itself from the deviceAngularVelocity and orientationCalibration fields
CTrackerOrientation	The TrackerOrientation field updates itself from the deviceOrientation and orientationCalibration fields
CTrackerPosition	The TrackerPosition field updates itself from the devicePosition and positionCalibration fields
CTrackerVelocity	The TrackerVelocity field updates itself from the deviceVelocity and positionCalibration fields
CWeightedProxy	The WeightedProxy field updates to be a value between the proxy position and tracker position depending on the value of a weighting factor
CH3DHapticsRendererNode	Base class for all haptic renderers, i.e
►CH3DImageLoaderNode	H3DImageLoaderNode is a virtual base class for classes that read an image file format such as PNG or JPEG and construct an Image class with the data from the file
CFileReaderRegistration	Class used to register a class to the registered file readers
►CH3DImageObject	This abstract interface is inherited by all nodes that contains an SFImage object with an Image containing data
CSFImage	The SFImage field is a field containing an Image pointer
CH3DMultiPassRenderObject	This abstract interface is inherited by all nodes that needs to render the scene an extra time(or more) to perform its task, e.g
CH3DNavigation	H3DNavigation is a class used for navigation in H3DAPI
CH3DNavigationDevices	Base class for devices that should be used to navigate the scene
CMouseNavigation	Take care of mouseNavigation
CKeyboardNavigation	Takes care of navigation using keyboard
CHapticDeviceNavigation	Takes care of navigation using a haptics device
CSWSNavigation	Takes care of navigation with SpaceWareSensor
CFieldDBElement	A FieldDBElement is an encapsulation of a field in a H3DNodeDatabase
CDynamicFieldDBElement	The DynamicFieldDBElement is a FieldDBElement for fields that are not actual members of a Node class, but instead are defined and added at runtime, e.g
CFieldDBTemplate	Template class for specifying specialized FieldDBElement instances
►CH3DNodeDatabase	The H3DNodeDatabase contains a mapping between a name of a Node and the constructor for the Node with that name
CFieldDBConstIterator	The FieldDBConstIterator is an iterator class used for iterating over the field instances in an H3DNodeDatabase
CTypeInfoWrapper	Wrapper class to be able to put type_info as a key in a map
CH3DOptionNode	This abstract node type indicates that the concrete nodes which are instantiated based on it may be used in options fields
CH3DRenderModeGroupNode	The H3DRenderModeGroupNode is a base class for all nodes that wants in some way change the OpenGL state during the rendering of all X3DGeometryNode instances in the children field
CH3DRenderStateObject	This abstract class is the base class for node types that want to change the rendering state temporarily while rendering sibling nodes in a X3DGroupingNode
CH3DScriptNode	The base class for script nodes
CH3DShadowObjectNode	The H3DShadowObjectNode is the base class for all shadow objects for use in the ShadowCaster node
CH3DSingleTextureNode	This abstract node type is the base type for all texture nodes that is defined by a single texture
►CH3DSoundFileNode	This abstract node type is used to derive node types that can stream PCM sound data from a file
CFileReaderRegistration	Class used to register a class to the registered file readers
CH3DSoundStreamNode	This abstract node type is used to derive node types that can stream PCM sound data
►CH3DStiffnessSurfaceNode	A H3DStiffnessSurfaceNode is the base class for surfaces that have stiffness and damping
CUpdateDamping	Specialized field which sets the damping variable in H3DStiffnessSurfaceNode when the damping field of H3DStiffnessSurfaceNode is changed
CUpdateStiffness	Specialized field which sets the stiffness variable in H3DStiffnessSurfaceNode when the stiffness field of H3DStiffnessSurfaceNode is changed
CH3DSurfaceNode	Base class for all surfaces
►CH3DVideoClipDecoderNode	H3DVideoClipDecoderNode is a virtual base class for classes decoding video clips making new frames available to render
CDecoderRegistration	Class used to register a class to the registered file readers
CH3DVideoTextureNode	H3DVideoTextureNode is a virtual base class for classes using video as a texture
►CH3DWindowNode	The base class for all window nodes
►CRenderMode	The mode for rendering specified as a string
CInvalidRenderMode	Thrown when the value of RenderMode is an invalid mode
CWindowSizeChanged	Class which handles the windows resizing related operations
CHAnimDisplacer	Applications may need to alter the shape of individual segments
CHAnimHumanoid	The HAnimHumanoid node is a container for the entire humanoid
CHAnimJoint	The HAnimJoint object is the fundamental building block that represents body parts
CHAnimSegment	The HAnimSegment object is a container for information about a segment of the body
CHAnimSite	An HAnimSite node serves three purposes
CHapticLayeredGroup	HapticLayeredGroup is a grouping node that can be used to set different shapes for different layers of the haptic rendering
CHapticMasterDevice	A HapticMasterDevice is a node for handling communication with the HapticMaster haptics device from Moog/FCS
CHapticsOptions	Specifies parameters to use when rendering an object with haptics
►COpenHapticsRenderer	Haptics renderer using OpenHaptics to render objects
CAdaptiveViewport	AdaptiveViewport specializes SFBool to set the appropriate default values in the HAPI::OpenHapticsRenderer used
CCameraView	CameraView specializes SFBool to set the appropriate default values in the HAPI::OpenHapticsRenderer used
CShapeType	ShapeType specializes SFString to set the appropriate default OpenHaptics shape in the HAPI::OpenHapticsRenderer
►CGodObjectRenderer	Haptics renderer using the god object algorithm to render objects
CEnableSecondaryCollisions	EnableSecondaryCollisions specializes SFBool to set the value determining whether to enable secondary collisions when calculating proxy position
CMinDistance	MinDistance specializes SFDouble to set the minimum distance between the surface and the proxy in GodObjectRenderer
►CRuspiniRenderer	Haptics renderer using a variant of the Ruspini algorithm allowing you to specify a radius on the proxy
CProxyRadius	ProxyRadius specializes SFFloat to set the proxy radius in the HAPI::RuspiniRenderer used
CChai3DRenderer	Haptics renderer using Chai3D(www.chai3d.org) Uses the HAPI::Chai3DRenderer class
►CLayeredRenderer	Haptics renderer which may contain other haptics renderer nodes
CMFHapticsRendererNode	MFHapticsRendererNode extends TypedMFNode< H3DHapticsRendererNode > in order to change the haptics renderer for the used HAPIHapticsDevice when changing H3DHapticsRendererNode
►CHapticTexturesSurface	Surface in which textures can be used to control the values of the parameters stiffness, damping, staticFriction and dynamicFriction
CSetImagePtr	Field class used to transfer the routed image to the HAPISurfaceObject
CSFImageObjectNode	An SFNode where we make sure the type of the nodes contained is a subclass of H3DImageObject
CUpdateMinMaxParamValue	Field class used to set the min and max values of the different parameters in the HAPISurfaceObject
►CHaptikDevice	The HaptikDevice uses the Haptik library (www.haptiklibrary.org) to access haptics devices
CSelectDevice	The SelectDevice field changes the haptics device to use depending on the values of set_selectedDevice and preferredDeviceType fields
►CHumanHand	This is a X3DGeometryNode which renders a hand using the Virtual Hand SDK
CSFBound	Update geometric bounds of the HumanHand
CSFCyberGloveSensor	Field class used to check if a CyberGloveSensor is used and then set up routes from fields in the CyberGloveSensor to correctly redraw when hand changes
►CImage3DTexture	The Image3DTexture node defines a texture map by specifying a single file that contains complete 3D data and general parameters for mapping to geometry
CCouldNotLoadImage	CouldNotLoadImage is thrown when not any of the urls could be read with any of the image loaders in a Image3DTexture
►CSFImage	SFImage is overridden to update the value from the url and imageLoader fields of the Image3DTexture
CCBData	Struct for storing input needed for the callback function
CThreadFuncData	Struct for storing input needed to the thread function
►CImageObjectInfo	This node can be used to get information about dimensions, sizes pixel types etc from H3DImageObject nodes such as Image3DTexture
CSFImageObjectNode	An SFNode where we make sure the type of the nodes contained is a subclass of H3DImageObject
CUpdateFields	Field for updating the output fields when the image object changes value
►CImageObjectTexture	The ImageObjectTexture node uses the image data from any node that implements the H3DImageObject interface as texture data
CSFImageObject	H3DImageObject and maintains a route from the contained object's image field to the image field of the ImageObjectTexture it resides in
►CImageTexture	The ImageTexture node defines a texture map by specifying an image file and general parameters for mapping to geometry
CCouldNotLoadImage	CouldNotLoadImage is thrown when not any of the urls could be read with any of the image loaders in a ImageTexture
►CSFImage	SFImage is overridden to update the value from the url and imageLoader fields of the ImageTexture
CCBData	Struct for storing input needed for the callback function
CThreadFuncData	Struct for storing input needed to the thread function
CSharedImage	A shared texture
CImportLibrary	The ImportLibrary node makes it possible from a X3D file to load a dynamically linked library in order to e.g
►CIndexedFaceSet	The IndexedFaceSet node represents a 3D shape formed by constructing faces (polygons) from vertices listed in the coord field
CAutoNormal	Specialized field for automatically generating normals from coordinates
CAutoTangent	Specialized field for automatically generating two FloatVertexAttribute nodes representing the tangent and binormal of each vertex(or face if normalPerVertex is false)
►CIndexedLineSet	The IndexedLineSet node represents a 3D geometry formed by constructing polylines from 3D vertices specified in the coord field
CDisplayList	Display list is extended in order to set color to emissive color from material outside of display list, since we have to do a glGet to get the value
CInvalidColorIndex	Thrown when the colorIndex field does not match the coordIndex field properly
CInvalidColorIndexSize	Thrown when the colorIndex field's size does not match the coordIndex field properly
CMFVertexAttributeNode	The MFVertexAttributeNode is dependent on the propertyChanged field of the contained X3DVertexAttributeNode
►CIndexedTriangleFanSet	An IndexedTriangleFanSet represents a 3D shape composed of triangles that form a fan shape around the first vertex declared in each fan
CAutoNormal	Specialized field for automatically generating normals from coordinates
CNotEnoughColors	Thrown if the number of colors in the color field is less than
CNotEnoughTextureCoordinates	Thrown if the number of texture coordinates in the color field is less than the number coordinates in the coord field
►CIndexedTriangleSet	The IndexedTriangleSet node represents a 3D shape composed of a collection of individual triangles
CAutoNormal	Specialized field for automatically generating normals from coordinates
CAutoTangent	Specialized field for automatically generating two FloatVertexAttribute nodes representing the tangent and binormal of each vertex(or face if normalPerVertex is false)
CNotEnoughColors	Thrown if the number of colors in the color field is less than the number coordinates in the coord field
CNotEnoughTextureCoordinates	Thrown if the number of texture coordinates in the color field is less than the number coordinates in the coord field
►CIndexedTriangleStripSet	An IndexedTriangleStripSet represents a 3D shape composed of strips of triangles
CAutoNormal	Specialized field for automatically generating normals from coordinates
CNotEnoughColors	Thrown if the number of colors in the color field is less than the number coordinates in the coord field
CNotEnoughTextureCoordinates	Thrown if the number of texture coordinates in the color field is less than the number coordinates in the coord field
►CInline	The Inline node embeds an X3D scene stored at a location on the World Wide Web into the current scene
CLoadedScene	Updates itself from the load and url field and sets itself to the first url that parses successfully if the load field is true, and to NULL otherwise
CSFBound	SFBound is specialized to update from the SFBound fields routed to it
CIntegerSequencer	The IntegerSequencer node generates sequential discrete SFInt32 events in response to each set_fraction, next, or previous event
►CIntegerTrigger	IntegerTrigger handles single field Boolean events to set an integer value for the output event
CSetTriggerValue	Specialize to set the vaule of the triggerValue field to the value of the field integerKey
CKeySensor	A KeySensor node generates events when the user presses keys on the keyboard
CLibCurlResolver	The LibCurlResolver uses libcurl to resolve URLs using e.g
CLibraryInfo	Structure to contain information about a shared library of extra nodes outside
CLineProperties	The LineProperties node specifies additional properties to be applied to all line geometry
►CLineSet	The LineSet node represents a 3D geometry formed by constructing polylines from 3D vertices specified in the coord field
CDisplayList	Display list is extended in order to set color to emissive color from material outside of display list, since we have to do a glGet to get the value
CInvalidVertexCountValue	Thrown then vertexCount value is < 2
CMFVertexAttributeNode	The MFVertexAttributeNode is dependent on the propertyChanged field of the contained X3DVertexAttributeNode
CLoadSensor	The LoadSensor monitors the progress and success of downloading URL elements over a network
CLocalFog	The LocalFog node provides a way to simulate atmospheric effects by blending objects with the colour specified by the color field based on the distances of the various objects from the viewer
CLOD	The LOD node specifies various levels of detail or complexity for a given object, and provides hints allowing browsers to automatically choose the appropriate version of the object based on the distance from the user
CMagneticGeometryEffect	MagneticGeometryEffect is a localized haptic effect that tries to constrain the haptic device to the surface of the given geometry
►CMagneticSurface	The MagneticSurface is a surface where the proxy is attracted to the surface, and forces are generated in order to keep the proxy on the surface
CUpdateDamping	Specialized field which sets the damping variable in HAPI::OpenHapticsRenderer::OpenHapticsSurface when the damping field of MagneticSurface is changed
CUpdateDynamicFriction	Specialized field which sets the dynamic_friction variable in HAPI::OpenHapticsRenderer::OpenHapticsSurface when the dynamicFriction field of MagneticSurface is changed
CUpdateSnapDistance	Specialized field which sets the snap_distance variable in HAPI::OpenHapticsRenderer::OpenHapticsSurface when the snapDistance field of MagneticSurface is changed
CUpdateStaticFriction	Specialized field which sets the static_friction variable in HAPI::OpenHapticsRenderer::OpenHapticsSurface when the staticFriction field of MagneticSurface is changed
CUpdateStiffness	Specialized field which sets the stiffness variable in HAPI::OpenHapticsRenderer::OpenHapticsSurface when the stiffness field of SmoothSurface is changed
CMaterial	The Material node specifies surface material properties for associated geometry nodes and is used by the X3D lighting equations during rendering
CMatrix3VertexAttribute	Defines a set of per-vertex 3*3 matrix attributes
CMatrix4VertexAttribute	Defines a set of per-vertex 4*4 matrix attributes
►CMatrixTransform	The MatrixTransform node is a grouping node that defines a coordinate system for its children that is relative to the coordinate systems of its ancestors
CSFTransformedBound	SFTransformedBound maintains the routes from the owner Node's bound and matrix field to the contained TransformedBoxBound instance's boxBound and matrix field
CMetadataDouble	The metadata provided by this node is contained in the double-precision floating point numbers of the value field
CMetadataFloat	The metadata provided by this node is contained in the single-precision floating point numbers of the value field
CMetadataInteger	The metadata provided by this node is contained in the integers of the value field
CMetadataSet	The metadata provided by this node is contained in the metadata nodes of the value field
CMetadataString	The metadata provided by this node is contained in the strings of the value field
CMFBool	The MFBool field contains a vector of boolean values
CMFColor	The MFColor field contains a vector of RGB (red-green-blue) colour triples
CMFColorRGBA	The MFColorRGBA field contains a vector of RGBA (red-green-blue-alpha) colour 4-tuples
CMFDouble	The MFDouble field contains a vector of high-precision floating point numbers
CMFFloat	The MFFloat field contains a vector of single-precision floating point numbers
CMFieldClass	Base class for all fields created with the MField template
CMFieldBase	The common base class for MField types and MFNode
►CMField	Template class that adds the Field mechanism to a vector of values
CInvalidIndex	Thrown if the index given to getValueByIndex() is outside the boundaries
CMFInt32	The MFInt32 field contains a vector of 32-bit integers
CMFMatrix3d	The MFMatrix3d field contains a vector of Matrix3d instances
CMFMatrix3f	The MFMatrix3f field contains a vector of Matrix3f instances
CMFMatrix4d	The MFMatrix4d field contains a vector of Matrix4d instances
CMFMatrix4f	The MFMatrix4f field contains a vector of Matrix4f instances
CMFNode	MFNode is almost like any MField but it encapsulates a vector of Node pointers
CTypedMFNode	Template to make sure that the Nodes that are added to a MFNode are of a specified Node type
CTypedMFNodeObject	Template to make sure that the Nodes that are set in a MFNode are of a specified type
►CRefCountMField	RefCountMField is almost like any MField but it encapsulates a vector of RefCoundtedClass pointers
CInvalidIndex	Thrown if the index given to getValueByIndex() is outside the boundaries
►CMFNodeSplitter	MFNodeSplitter node is used to split MFNode into certain SFNodes yet
CUpdateSelection	Specialized field class used to update which node is selected
CMFQuaternion	The MFQuaternion field contains a vector of arbitrary Quaternion objects
CMFRotation	The MFRotation field contains a vector of arbitrary Rotation objects
CMFString	The MFString field conatins a vector of strings
CMFTime	The MFTime field contains a vector of time values
CMFVec2d	The MFVec2d field contains a vector of Vec2d
CMFVec2f	The MFVec2f field contains a vector of Vec2f
CMFVec3d	The MFVec3d field contains a vector of Vec3d
CMFVec3f	The MFVec3f field contains a vector of Vec3f
CMFVec4d	The MFVec4d field contains a vector of Vec4d
CMFVec4f	The MFVec4f field contains a vector of Vec4f
CMLHIDevice	A MLHIDevice is a node for handling communication with MLHI devices
CMouseSensor	A sensor node for reading mouse values
CMovieTexture	MovieTexture is a class that is not implemented in H3DAPI yet
CMultiDeviceSurface	The MultiDeviceSurface allows you to specify different surface for different haptics devices in a multi device setup
CMultiRenderTargetShader	The MultiRenderTargetShader node defines a way to use different shaders for different render targets in one pass
CMultiTexture	MultiTexture enables the application of several individual textures to a 3D object to achieve a more complex visual effect
CMultiTextureCoordinate	MultiTextureCoordinate supplies multiple texture coordinates per vertex
CMultiTextureTransform	MultiTextureTransform supplies multiple texture transforms per appearance
CNavigationInfo	The NavigationInfo node contains information describing the physical characteristics of the viewer's avatar and viewing model
►CNode	Node is the base class for all classes that can be part of the H3D scene-graph
►CLineIntersectResult	Used as input to lineIntersect functions
CPointingDeviceResultStruct	Contains a list of Nodes (X3DPointingDeviceNodes) and a transformation matrix from global space to local space of the nodes
CNodeIntersectResult	Used as input to intersection functions
►CNoiseTexture	The NoiseTexture node creates a texture with Perlin noise
CSFImage	SFImage is overridden to update the value from the url and imageLoader fields of the ImageTexture
►CNoiseTexture3D	The NoiseTexture3D node creates a texture with Perlin noise
CSFImage	SFImage is overridden to update the value from the url and imageLoader fields of the ImageTexture
CNormal	This node defines a set of 3D surface normal vectors to be used in the vector field of some geometry nodes
►CNormalInterpolator	The NormalInterpolator node interpolates among a list of normal vector sets specified by the keyValue field to produce an MFVec3f value_changed event
CMFValue	The SFValue field updates the interpolated value from the fields routed to it
CNormalShader	The NormalShader node generates a shader that renders the normal in view space of the geometry as color
CNrrdImageLoader	NrrdImageLoader is a class which takes care of loading the nrrd image format
►CNurbsCurve	The NurbsCurve node is a geometry node defining a parametric curve in 3D space
CDisplayList	Display list is extended in order to set color to emissive color from material outside of display list, since we have to do a glGet to get the value
CSFBound	SFBound is specialized to update from the SFBound fields routed to it
CNurbsCurve2D	The NurbsCurve2D node defines a trimming segment that is part of a trimming contour in the u,v domain of the surface
CNurbsPatchSurface	The NurbsPatchSurface node is a contiguous NURBS surface patch
CNurbsTextureCoordinate	The NurbsTextureCoordinate node is a NURBS surface existing in the parametric domain of its surface host specifying the mapping of the texture onto the surface
►CNurbsTrimmedSurface	The NurbsTrimmedSurface node defines a NURBS surface that is trimmed by a set of trimming loops
CAddContour	This field class checks whether the given node is of the right type (Contour2D)
CCheckContour	This field class checks whether the given node is of the right type (Contour2D) for adding or removing
CRemoveContour	This field class checks whether the given node is of the right type (Contour2D)
CNvidiaGraphicsOptions	Specifies parameters to use for the NVIDIA graphic settings which normally can also be changed from NVIDIA control panel
►COculusRiftSensor	This is a X3DSensorNode for reading values from a Oculus Rift HMD
CRecenterTrackingField	This class is an AutoUpdate class that sets the field accumulatedRotation to its input value and also sets accumulatedYaw, accumulatedPitch and accumulatedRoll to a value dependent on input value
COggFileReader	OggFileReader uses the libVorbis (http://www.vorbis.com) decoder library to support Ogg Vorbis files
COpenHapticsOptions	Specifies parameters to use for when rendering an object with OpenHaptics
►COpenHapticsSurface	Surface type for setting OpenHaptics surface parameters directly
CUpdateMagnetic	Specialized field which sets the magnetic variable in HAPI::OpenHapticsRenderer::OpenHapticsSurface when the magnetic field of OpenHapticsSurface is changed
►COrientationInterpolator	The OrientationInterpolator node interpolates among a list of rotation values specified in the keyValue field to produce an SFRotation value_changed event
CSFValue	The SFValue field updates the interpolated value from the fields routed to it
COrthoViewpoint	The OrthoViewpoint node defines a viewpoint that provides an orthographic view of the scene
CPackagedShader	A PackagedShader node describes a single file that may contain a number of shaders and combined effects
CParticleSystem	The ParticleSystem node specifies a complete particle system
CPeriodicUpdateField	Abstract base class for all Fields that will be updated without anyone asking for a value
CPeriodicUpdate	The PeriodicUpdate is a template modifier that changes the way the field is updated
►CPhantomDevice	A PhantomDevice is a node for handling communication with a haptics device from SensAble, such as the Phantom Omni and the Phantom Desktop haptics devices
CCalibrate	Field class that calibrates the device when a true event is received or the field is set to true
CPhongShader	The PhongShader node defines a shader for using the Phong illumination model
CPixel3DTexture	The Pixel3DTexture node defines a 3D image-based texture map as an explicit array of pixel values (image field) and parameters controlling tiling repetition of the texture onto geometry
CPixelTexture	The PixelTexture node defines a 2D image-based texture map as an explicit array of pixel values (image field) and parameters controlling tiling repetition of the texture onto geometry
►CPlanarReflector	The PlanarReflector defines a geometry which will act as a mirror in the scene
CSFGeometryNode	SFGeometryNode is dependent on the displayList field of its encapsulated X3DGeometryNode node, i.e
►CPlaneSensor	The PlaneSensor node maps pointing device motion into two-dimensional translation in a plane parallel to the Z=0 plane of the local sensor coordinate system
CSFOffset	Class used to store some information about axisRotation when offset is set, in order to set the correct offset value when mouse is clicked
►CPlaybackDevice	A PlaybackDevice is a fake haptics device node that can play back device values previously recorded using the DeviceLog node
COnDefaultValuesChanged	A field used to update default playback values
COnPlay	A field used to start and stop playback
COnPlaybackSpeed	A field used to adjust the playback speed
COnSeekToTime	A field used to move playback to a specified time
CPointEmitter	The PointEmitter node is an emitter that generates particles from a specific point in space
CPointLight	The PointLight node specifies a point light source at a 3D location in the local coordinate system
►CPointNormalClipPlane	This is a ClipPlane where the plane is specified with a point and a normal
CPlaneEq	The PlaneEq updates the plane equation from the values of the point and normal fields
►CPointSet	The PointSet node specifies a set of 3D points, in the local coordinate system, with associated colours at each point
CDisplayList	Display list is extended in order to set color to emissive color from material outside of display list, since we have to do a glGet to get the value
CMFVertexAttributeNode	The MFVertexAttributeNode is dependent on the propertyChanged field of the contained X3DVertexAttributeNode
CNotEnoughColors	Thrown when the number of colors in the color field are less than the number of points in the coord field
►CPolyline2D	The Polyline2D node specifies a series of contiguous line segments in the local 2D coordinate system connecting the specified vertices
CDisplayList	Display list is extended in order to set color to emissive color from material outside of display list, since we have to do a glGet to get the value
CSFBound	SFBound is specialized update itself from the lineSegments field of the Polyline2D node
►CPolypoint2D	The Polyline2D node specifies a set of vertices in the local 2D coordinate system at each of which is displayed a point
CDisplayList	Display list is extended in order to set color to emissive color from material outside of display list, since we have to do a glGet to get the value
CSFBound	SFBound is specialized update itself from the point field of the Polypoint2D node
CPositionFunctionEffect	PositionFunctionEffect takes as input three functions that controls the force in x, y and z direction
►CPositionInterpolator	The PositionInterpolator node linearly interpolates among a list of 3D vectors to produce an SFVec3f value_changed event
CSFValue	The SFValue field updates the interpolated value from the fields routed to it
►CPositionInterpolator2D	The PositionInterpolator node linearly interpolates among a list of 2D vectors to produce an SFVec2f value_changed event
CSFValue	The SFValue field updates the interpolated value from the fields routed to it
►CProgramShader	He ProgramShader node defines a shader that can consist of one or more individually programmable, self contained pieces
CMFShaderProgram	Sets the profile for each ShaderProgram node that is added to it
►CProtoDeclaration	Information about a PROTO node from the X3D standard
CFieldDeclaration	Class that contains information about a field that is part of the prototype declaration
CPrototypeInstance	The PrototypeInstance is an instance of a prototyped node
►CProximitySensor	The ProximitySensor node generates events when the viewer enters, exits, and moves within a region in space (defined by a box)
CSetTime	The SetBoolean class is specialize to set the value of either the enterTime or exitTime field in the ProximitySensor node it resides in, depending on the value that is is given
CPythonInvalidFieldType	An exception thrown when a field is of the wrong type when it is checked
CPythonScript	Interface to the dynamic Python library for executing script code as part of the API
CPyNode	Python C Type wrapper around Node*
CPyVec2f	Python C Type wrapper around Vec2f
CPyVec2d	Python C Type wrapper around Vec2d
CPyVec3f	Python C Type wrapper around Vec3f
CPyVec3d	Python C Type wrapper around Vec3d
CPyVec4f	Python C Type wrapper around Vec4f
CPyVec4d	Python C Type wrapper around Vec4d
CPyRotation	Python C Type wrapper around Rotation
CPyQuaternion	Python C Type wrapper around Quaternion
CPyMatrix3f	Python C Type wrapper around Matrix3f
CPyMatrix4f	Python C Type wrapper around Matrix4f
CPyMatrix3d	Python C Type wrapper around Matrix3d
CPyMatrix4d	Python C Type wrapper around Matrix4d
CPyRGB	Python C Type wrapper around RGB
CPyRGBA	Python C Type wrapper around RGBA
CPyType	Base class for all Python C type wrappers
CPyTypeWrapper	PyTypeWrapper is a template wrapper class to create new Python types from types already existing in the H3DAPI (see PythonTypes.h) for example usage
CPyNumberTypeWrapperBase	PyNumberTypeWrapperBase is a template wrapper class to create new Python types from types already existing in the H3DAPI (see PythonTypes.h) for example usage
CPyVecTypeWrapper	PyVecTypeWrapper is the same as PyNumberTypeWrapperBase with the difference that its mul function also specifies vector dot product between two instances
CPyNumberTypeWrapper	PyNumberTypeWrapper is the same as PyNumberTypeWrapperBase with the difference that its mul function also specifies multiplication between two instances of the class
CQuanserDevice	A QuanserDevice is a node for handling communication with a haptics device from Quanser, such as the 2-DOF Pantograph
CRawImageLoader	The RawImageLoader loads a raw data file and lets the user specify the parameters for the values directly
CRazerHydraSensor	This is a X3DSensorNode for reading values from a Razer hydra sensor
►CRectangle2D	The Rectangle2D node specifies a rectangle centred at (0, 0) in the current local 2D coordinate system and aligned with the local coordinate axes
CSFBound	SFBound is specialized update itself from the size field of the Rectangle2D node
CRefCountSField	RefCountSField is almost like any SField but it encapsulates a pointer to a RefCountedClass
CRenderProperties	The RenderProperties node specifies additional rendering options that cannot be specified with the X3D Appearance node
CRenderTargetSelectGroup	The RenderTargetSelectGroup is used in combination with the FrameBufferTextureGenerator to select which color textures to render into
CRenderTargetTexture	The RenderTargetTexture is a wrapper node to use one of the render targets(color textures) from a FrameBufferTextureGenerator directly as a texture
CRotationalSpringEffect	RotationalSpringEffect is a localized haptic effect where the haptics device is rotated towards a certain axis of rotation in a spring like manner i.e
►CScalarInterpolator	This node linearly interpolates among a list of SFFloat values to produce an SFFloat value_changed event
CSFValue	The SFValue field updates the interpolated value from the fields routed to it
►CScene	The Scene node is topmost node that takes care of the rendering of the scene graph both haptically and graphically
CEventSink	Makes all fields up-to-date what are routed to it, with the exception of PeriodicUpdateFields
CScript	No scripting is supported with the Script node yet
CSFBool	The SFBool field contains a single boolean value
CSFColor	The SFColor field contains one RGB (red-green-blue) colour triple
CSFColorRGBA	The SFColorRGBA field contains one RGBA (red-green-blue-alpha) colour 4-tuple
CSFDouble	The SFDouble field contains one high-precision floating point number
CSFFloat	The SFFloat field contains one single-precision floating point number
CSFieldClass	Base class for all fields created with the SField template
CSField	Template class that adds the Field mechanisms to an encapsulated value of specified type
CSFInt32	The SFInt32 field contains one 32-bit integer
CSFMatrix3d	The SFMatrix3d field contains a Matrix3d
CSFMatrix3f	The SFMatrix3f field contains a Matrix3f
CSFMatrix4d	The SFMatrix4d field contains a Matrix4d
CSFMatrix4f	The SFMatrix4f field contains a Matrix4f
CSFNode	SFNode is almost like any SField but it encapsulates a pointer to a Node
CTypedSFNode	Template to make sure that the Node that is set in a SFNode is of a specified Node type
CTypedSFNodeObject	Template to make sure that the Node that is set in a SFNode is of a specified type
CSFQuaternion	The SFQuaternion field contains a Quaternion
CSFRotation	The SFRotation field contains one arbitrary Rotation
CSFString	The SFString field contains a string
CSFTime	The SFTime field contains a single time value
CSFVec2d	The SFVec2d field contains a Vec2d
CSFVec2f	The SFVec2f field contains a Vec2f
CSFVec3d	The SFVec3d field contains a Vec3d
CSFVec3f	The SFVec3f field contains a Vec3f
CSFVec4d	The SFVec4d field contains a Vec4d
CSFVec4f	The SFVec4f field contains a Vec4f
CShaderAtomicCounter	A ShaderAtomicCounter is a atomic counter can be used in GLSL shader
CShaderChildNode	This is the base node type for the child nodes of the ComposedShader node
CShaderCombiner	The ShaderCombiner node combines the output of several fragment shaders in different ways to produce a final value by a combination of the output values of the shaders
CShaderConstants	The ShaderConstants node is a node will be used to gather all static shader inputs to be used in the shader
CSFUniform	Template class to provide value change checking after update for SField
CShaderImage2D	ShaderImage2D is a 2D image which can allow openGL to read from and write to
CShaderImage3D	ShaderImage2D is a 3D image which can allow openGL to read from and write to
CShaderImageNode	This is the base node type for the child nodes of the ComposedShader node which is image node type, it will a texture which will be used as texture image for opengl
►CShaderPart	The ShaderPart node defines the source for a single object to be used by a ComposedShader node
CSFShaderString	Update the string to use as shader depending from the urls given
CShaderProgram	The ShaderProgram node provides the source and interface to a self contained program that occupies one part of the rendering process: either a vertex or fragment shader
CShaderStorageBuffer	This node provide a buffer object for OpenGL shader program to write into and read from
CShadowCaster	The ShadowCaster node uses shadow volumes using stencil buffer to cast shadows from objects in a scene
►CShadowGeometry	The ShadowGeometry object specifies a X3DGeometryNode that should be used for casting a shadow when used in the ShadowCaster node
CSFGeometryNode	SFGeometryNode is specialized to route the boundTree field from the X3DGeometryNodes that are put into the field to the triangles_changed field of the ShadowGeometry that contains it
CShadowSphere	The ShadowSphere object specifies a sphere casting a shadow for use in the ShadowCaster node
CShadowTransform	The ShadowTransform transforms another H3DShadowObjectNode with the values from the transform field
CShape	The Shape node has two fields, appearance and geometry, which are used to create rendered objects in the world
CSimballDevice	A SimballDevice is a node for handling communication with a haptics device from ForceDimension, such as the Omega and Delta haptics devices
CSimpleAudioClip	SimpleAudioClip is a node for playing audio with a simpler interface than the audio clip node
►CSimpleMovieTexture	SimpleMovieTexture is a node for showing movies as textures with a simpler interface than the movie texture node
CDecoderManager	Manages all state changes in the decoder depending on the values of the fields in SimpleMovieTexture
CFieldUpdater	The FieldUpdater field updates all output fields in the SimpleMovieTexture node that needs to be updated each frame
CSmoothSurface	A SmoothSurface has no friction at all
►CSound	The Sound node specifies the spatial presentation of a sound in a X3D scene
CALSoundSetup	Field that calls ALrender() when a field routed to it has generated an event
CSFSoundSourceNode	The SFSoundSourceNode registers the Sound node in the X3DSoundSourceNode that is put into the field
CSpaceballSensor	A sensor node for reading GLUT Spaceball values
►CSpaceWareHapticsDevice	A fake haptics device where the position and orientation is controlled via a SpaceWare device such as the SpaceMouse or SpaceTraveller
CSetMainButton	SetMainButton is set to true if any of the buttons on the SpaceWare device is pressed
►CSpaceWareSensor	This is a X3DSensorNode for reading values from a 3DConnexion motion controller such as the SpaceTraveller or SpaceMouse 5000
CAccumulateRotation	This class is an AutoUpdate class that accumulates the rotation values routed to it, i.e
CAccumulateTranslation	This class is an AutoUpdate class that accumulates the Vec3f values routed to it, i.e
CResetAccumulatedRotation	This class is an AutoUpdate class that sets the field accumulatedRotation to its input value and also sets accumulatedYaw, accumulatedPitch and accumulatedRoll to a value dependent on input value
CResetAccumulatedTranslation	This class is an AutoUpdate class that sets the field accumulatedTranslation to its input value
CScaleRotation	Updates itself to the Rotation routed to it where the angle is scaled by the scale factor
CScaleTranslation	Updates itself to the SFVec3f routed to it scaled by the scale factor
►CSphere	The Sphere node specifies a sphere centred at (0, 0, 0) in the local coordinate system
CSFBound	SFBound is specialized update itself from the radius field of the Sphere node
CSphereSensor	The SphereSensor node maps pointing device motion into spherical rotation about the origin of the local coordinate system
►CSpiderMonkeySAI	Implementation of the X3D Ecmascript SAI specification using SpiderMonkey(the Javascript engine used by Firefox)
CCallbackFunctionDispatcher	Handles the calls of the ecmascript callback functions for the fields
►CSplinePositionInterpolator	The SplinePositionInterpolator node non-linearly interpolates among a list of 3D vectors to produce an SFVec3f value_changed event
CSFValue	The SFValue field updates the interpolated value from the fields routed to it
►CSplinePositionInterpolator2D	The SplinePositionInterpolator2D node non-linearly interpolates among a list of 2D vectors to produce an SFVec2f value_changed event
CSFValue	The SFValue field updates the interpolated value from the fields routed to it
►CSplineScalarInterpolator	The SplineScalarInterpolator node non-linearly interpolates among a list of floats to produce an SFFloat value_changed event
CSFValue	The SFValue field updates the interpolated value from the fields routed to it
CSpotLight	The SpotLight node defines a light source that emits light from a specific point along a specific direction vector and constrained within a solid angle
CSpringEffect	SpringEffect is a localized haptic effect where the haptics device is pulled towards to a point in space in a spring like manner, i.e
CStereoInfo	The StereoInfo nis a bindable node that contains information used when rendering the scene in stereo
CStringSensor	A StringSensor node generates events as the user presses keys on the keyboard
►CSuperShape	The SuperShape node implements a SuperShape!
CSFCoordinateNode	The SFCoordinateNode is a class that contain a X3DCoordinateNode
CSurfaceEmitter	The SurfaceEmitter node is an emitter that generates particles from the surface of an object
►CSwitch	The Switch grouping node traverses zero or one of the nodes specified in the choice field
CSFBound	SFBound is specialized to update from the SFBound fields routed to it
►CTexGenGeometry	The TexGenGeometry node is a wrapper node that lets you specify a TextureCoordinateGenerator node to generate the texture coordinates of a geometry instead of using the default ones
CSFGeometryNode	The SFGeometryNode keeps a route between the contained X3DGeometryNode's bound field and the bound field ot the TexGenGeometry
►CText	The Text node specifies a two-sided, flat text string object positioned in the Z=0 plane of the local coordinate system based on values defined in the fontStyle field (see FontStyle)
CDisplayList	We extend the DisplayList to build the fonts of the X3DFontStyleNode in the fontStyle field of the Text node this DisplayList resides in
COutputUpdater	Internal field class to update values of origin, textBounds, lineBounds
CSFBound	The SFBound field is specialized to update itself from the values in the fields of the Text node
CTextureBackground	A background node that uses six individual texture nodes to compose the backdrop
CTextureCoordinate	The TextureCoordinate node is a geometry property node that specifies a set of 2D texture coordinates used by vertex-based geometry nodes (EXAMPLE IndexedFaceSet and ElevationGrid) to map textures to vertices
CTextureCoordinate3D	The TextureCoordinate3D node is a geometry property node that specifies a set of 3D texture coordinates used by vertex-based geometry nodes (EXAMPLE IndexedFaceSet and ElevationGrid) to map textures to vertices
CTextureCoordinate4D	The TextureCoordinate4D node is a geometry property node that specifies a set of 4D (homogeneous 3D) texture coordinates used by vertex-based geometry nodes (e.g., IndexedFaceSet) to map 3D textures to vertices
CTextureCoordinateGenerator	TextureCoordinateGenerator supports the automatic generation of texture coodinates for geometric shapes
CTextureMatrixTransform	The matrix field specifies a generalized, unfiltered 4×4 transformation matrix that can be used to modify the texture
CTextureProperties	TextureProperties allows fine control over a texture's application
CTextureTransform	The TextureTransform node defines a 2D transformation that is applied to texture coordinates (see TextureCoordinate)
CTextureTransform3D	The TextureTransform3D node defines a 3D transformation that is applied to texture coordinates (see TextureCoordinate)
CThreadSafeSField	<>
CThreadSafeRefSField	<>
CThreadSafeMField	<>
CTimeFunctionEffect	TimeFunctionEffect takes as input three functions that controls the force in x, y and z direction
►CTimeSensor	TimeSensor nodes generate events as time passes
CTimeHandler	The TimeHandler field is specialized to include the handling of the TimeSensor specific fields
►CTimeTrigger	TimeTrigger is a trigger node that generates time events upon receiving boolean events
CSetTriggerTime	Specialize to set the vaule of the triggerTime field to the current time
CToggleGroup	The ToggleGroup node enables you to enable/disable haptics and graphics rendering of its children nodes
CTouchSensor	A TouchSensor node tracks the location and state of the pointing device and detects when the user points at geometry contained by the TouchSensor node's parent group
►CTransferFunctionTexture	Texture for defining a transfer function from a single value to RGBA values using H3DFunctionNode instances
CSFImage	SFImage is overridden to update the value from the functions
►CTransform	The Transform node is a grouping node that defines a coordinate system for its children that is relative to the coordinate systems of its ancestors
CMatrix	Specialize the SFMatrix4f to update the matrix from the fields in the Transform node
CTransformInfo	The TransformInfo node provides information about the coordinate space it resides in in the scene graph
►CTraverseInfo	TraverseInfo is a structure that is passed along when traversing the scene graph
CInvalidHapticsDeviceIndex	Thrown when trying to get hold of a H3DHapticsDevice using an invalid device index
CLightInfo	Class grouping X3DLightNode and its transformation matrix
►CTriangleFanSet	A TriangleFanSet represents a 3D shape composed of triangles that form a fan shape around the first vertex declared in each fan
CAutoNormal	Specialized field for automatically generating normals from coordinates
CInvalidFanCount	Thrown when fanCount value is < 3
CNotEnoughColors	Thrown if the number of colors in the color field is less than the number coordinates in the coord field
CNotEnoughTextureCoordinates	Thrown if the number of texture coordinates in the color field is less than the number coordinates in the coord field
►CTriangleSet	The TriangleSet node represents a 3D shape that represents a collection of individual triangles
CAutoNormal	Specialized field for automatically generating normals from coordinates
CNotEnoughColors	Thrown if the number of colors in the color field is less than the number coordinates in the coord field
CNotEnoughTextureCoordinates	Thrown if the number of texture coordinates in the color field is less than the number coordinates in the coord field
►CTriangleSet2D	The TriangleSet2D node specifies a set of triangles in the local 2D coordinate system
CSFBound	SFBound is specialized update itself from the vertices field of the TriangleSet2D node
►CTriangleStripSet	A TriangleStripSet represents a 3D shape composed of strips of triangles
CAutoNormal	Specialized field for automatically generating normals from coordinates
CInvalidStripCount	Thrown when stripCount value is < 3
CNotEnoughColors	Thrown if the number of colors in the color field is less than the number coordinates in the coord field
CNotEnoughTextureCoordinates	Thrown if the number of texture coordinates in the color field is less than the number coordinates in the coord field
CTwoSidedMaterial	This node defines material properties that can effect both the front and back side of a polygon individually
CTypedField	A template modifier class for adding type checking on the routes to any Field class
CTypedFieldError	An exception thrown when the field does not conform to the type specification from a TypedField
CViewpoint	The Viewpoint node defines a viewpoint that provides a perspective view of the scene
►CViewpointGroup	ViewpointGroup is used to control display of viewpoints on the viewpoint list
CMFChild	Type class of children field
CVirtualHandGloveSensor	This is the base class for all sensors that handles connection to the vhtGlove class in Virtual Hand SDK
CVirtuoseDevice	A VirtuoseDevice is a node for handling communication with a haptics device from Haption, such as the Virtuose haptics device
CViscosityEffect	ViscosityEffect is a localized haptic effect
►CVisibilitySensor	The VisibilitySensor node detects visibility changes of a rectangular box as the user navigates the world
CSetTime	Specialize to set the value of either the inputTrue or inputFalse field in the BooleanFilter node it resides in, depending on the value that is is given
CWindPhysicsModel	The WindPhysicsModel node specifies a physics model that applies a wind effect to the particles
CWorldInfo	The WorldInfo node contains information about the world
CX3DAppearanceChildNode	This is the base node type for the child nodes of the X3DAppearanceNode type
CX3DAppearanceNode	This is the base node type for all Appearance nodes
CX3DBackgroundNode	X3DBackgroundNode is the abstract type from which all backgrounds inherit
►CX3DBindableNode	X3DBindableNode is the abstract base type for all bindable children nodes, including Background, TextureBackground, Fog, NavigationInfo, Viewpoint and DeviceInfo
CSFSetBind	The SFSetBind field calls toStackTop() and removeFromStack() on the X3DBindableNode it is in depending on the value that it is set to
CX3DBoundedObject	This X3D abstract interface type is basis for all X3D node types that have bounds specified as part of the definition
CX3DChildNode	This abstract node type indicates that the concrete nodes which are instantiated based on it may be used in children, addChildren, and removeChildren fields
CX3DColorNode	This is the base node type for color specifications in X3D
►CX3DComposedGeometryNode	This is the base node type for all composed 3D geometry in X3D
CDisplayList	Display list is extended in order to set front sidedness of triangles outside the display list
CMFVertexAttributeNode	The MFVertexAttributeNode is dependent on the propertyChanged field of the contained X3DVertexAttributeNode
CX3DCoordinateNode	This is the base node type for all coordinate node types in X3D
CX3DDragSensorNode	This abstract node type is the base type for all drag-style pointing device sensors
CX3DEnvironmentalSensorNode	This abstract node type is the base type for all sensors
CX3DEnvironmentTextureNode	This abstract node type is the base type for all node types that specify cubic environment map sources for texture images
CX3DFogObject	X3DFogObject is the abstract type that describes a node that influences the lighting equation through the use of fog semantics
CX3DFontStyleNode	This abstract node type is the base node type for all FontStyle nodes
CX3DGeometricPropertyNode	This is the base node type for all geometric property node types defined in X3D
►CX3DGeometryNode	This is the base node type for all geometry in X3D
CBugWorkaroundDisplayList	This is just a dummy class to get around a bug in Visual C++ 7.1 If the X3DGeometry::DisplayList inherits directly from H3DDisplayListObject::Display list the application will crash if trying to call H3DDisplayListObject::DisplayList::callList By using an intermediate class the bug dissappears
CDisplayList	Display list is extended in order to set front sidedness of triangles outside the display list
CSFBoundTree	The SFBoundTree constructs a BinaryBoundTree that can be used for collision detection as well as fast collection of haptic primitives (triangles, points, lines)
►CX3DGroupingNode	This abstract node type indicates that concrete node types derived from it contain children nodes and is the basis for all aggregation
CAddChildren	AddChildren is a class that adds any node added to it to the children field of its owner (X3DGroupingNode) if the node is not already in the children field
CMFChild	MFChild sets up a routes from the Nodes that are added and removed from the field to the owner of the field
CRemoveChildren	RemoveChildren is a class that removes any node added to it from the children field of its owner (X3DGroupingNode)
CSFBound	SFBound is specialized to update from the SFBound fields routed to it
CX3DInfoNode	This is the base node type for all nodes that contain only information without visual semantics
CX3DInterpolatorNode	The abstract node X3DInterpolatorNode forms the basis for all types of interpolators specified in this clause
CX3DKeyDeviceSensorNode	This abstract node type is the base type for all sensor node types which operate using key devices
►CX3DLightNode	The X3DLightNode abstract node type is the base type from which all node types that serve as light sources are derived
CGLLightInfo	A structure representing a the OpenGL representation of the specified light source
CX3DMaterialNode	This is the base node type for all Material nodes
CX3DMetadataObject	This abstract interface is the basis for all metadata nodes
CX3DNetworkSensorNode	This abstract node type is the basis for all sensors that generate events based on network activity
CX3DNode	This abstract node type is the base type for all nodes in the X3D system
CX3DNormalNode	This is the base node type for all normal node types in X3D
CX3DNurbsControlCurveNode	This abstract node type is the base type for all node types that provide control curve information in 2D space
►CX3DNurbsSurfaceGeometryNode	The X3DNurbsSurfaceGeometryNode represents the abstract geometry type for all types of NURBS surfaces
CTexCoordOrNurbsTex	This field class takes as input SFNode field and checks whether this is one of the allowed textureNodes or not
CX3DParametricGeometryNode	This abstract node type is the base type for all geometry node types that are created parametrically and use control points to describe the final shape of the surface
CX3DParticleEmitterNode	The X3DParticleEmitterNode abstract type represents any node that is an emitter of particles
CX3DParticlePhysicsModelNode	The X3DParticlePhysicsModelNode is the abstract representation of any node that will apply a form of constraints on the particles after they have been generated
CX3DPointingDeviceSensorNode	This abstract node type is the base type for all pointing device sensors
►CX3DProgrammableShaderObject	This abstract node type is the base type for all node types that specify arbitrary fields for interfacing with per-object attribute values
CUpdateTextures	For bindless textures handle the updating of the textures list of all shader fields that contain the texture
CX3DPrototypeInstance	This abstract node type is the base type for all prototype instances in the X3D system
►CX3DScriptNode	The base class for script nodes
CSFScriptString	Update the string to use as script depending from the urls given
CX3DSensorNode	This abstract node type is the base type for all sensors
►CX3DSequencerNode	This abstract node type is the base node type from which all Sequencers are derived
CKeyValues	Each value in the keyValue field corresponds in order to the parameter value in the key field
CValueChanged	ValueChanged is a specialized class used to evaluate and set the value_changed field depending on the input to the class
CX3DShaderNode	This abstract node type is the base type for all node types which specify a programmable shader
►CX3DShapeNode	This is the base node type for all Shape nodes
CBugWorkaroundDisplayList	This is just a dummy class to get around a bug in Visual C++ 7.1 If the X3DGeometry::DisplayList inherits directly from H3DDisplayListObject::Display list the application will crash if trying to call H3DDisplayListObject::DisplayList::callList By using an intermediate class the bug dissappears
CDisplayList	Display list is extended in
CSFGeometryNode	SFGeometryNode is dependent on the displayList field of its encapsulated X3DGeometryNode node, i.e
CX3DSoundNode	This abstract node type is the base for all Sound nodes
►CX3DSoundSourceNode	This abstract node type is used to derive node types that can emit audio data
CALSoundBuffer	Field that calls ALrender() when a field routed to it has generated an event
CTimeHandler	TimeHandler is extended to stream audio data to OpenAL buffers if the sound source is a streaming source
►CX3DTexture2DNode	This abstract node type is the base type for all node types which specify 2D sources for texture images
CSFImage	A SFNode encapsulating an Image class
►CX3DTexture3DNode	This abstract node type is the base type for all node types which specify 3D sources for texture images
CSFImage	A SFNode encapsulating an Image class
CX3DTextureCoordinateNode	This abstract node type is the base type for all node types which specify texture coordinates
►CX3DTextureNode	This abstract node type is the base type for all node types which specify sources for texture images
CglTexImageFunctionNotDefined	Thrown when a subclass to X3DTextureNode calls renderImage without defining the glTexImage () function
CInvalidTextureDimensions	Thrown by renderImage () if the dimensions of an image are invalid, e.g
COpenGLTextureError	Thrown when an OpenGL error occurs while setting up the texture
CUpdateSaveToURL	A field used to execute the save to URL operation when the URL is set
CX3DTextureTransform2DNode	<>
►CX3DTextureTransformNode	This abstract node type is the base type for all node types which specify a transformation of texture coordinates
CDisplayList	The rendering of texture transformation requires the specifiation of which texture units to render the transformation for
►CX3DTimeDependentNode	This abstract node type is the base node type from which all time-dependent nodes are derived
CStartTime	The StartTime field is a specialization of the SFTime field so that the value cannot be changed when the isActive field of the X3DTimeDependentNode it resides in is true
CStopTime	The StopTime field is a specialization of the SFTime field so that the value is ignored if the X3DTimeDependentNode is active and stopTime <= startTime as according to the X3D spec
CTimeHandler	The TimeHandler field updates once per scene-graph loop to monitor the current time and updates the fields in the owner X3DTimeDependentNode if any state changes has to be made
►CX3DTouchSensorNode	This abstract node type is the base type for all touch-style pointing device sensors
CSetTouchTime	Specialize field to generate a touchTime event
CX3DTriggerNode	This abstract node type is the base node type from which all Triggers are derived
CX3DUrlObject	This abstract interface is inherited by all nodes that contain data located on the World Wide Web, such as AudioClip, ImageTexture and Inline
CX3DVertexAttributeNode	This abstract node type is the base type for all node types that specify per-vertex attribute information to the shader
►CX3DViewpointNode	The X3DViewpointNode node defines a specific location in the local coordinate system from which the user may view the scene
CSFOrientation	This field is used for the orientation field in order to reset the internal variables rel_pos and rel_orn used for H3DAPIs internal navigation
CSFPosition	This field is used for the position field in order to reset the internal variables rel_pos and rel_orn used for H3DAPIs internal navigation
CSFSumRotation	This field sums the value of the two SFRotation routed to it
CSFSumVec3f	This field sums the value of the two SFVec3f routed to it
►Nyy
Clocation	Abstract a location
Cposition	Abstract a position
Cslice	Present a slice of the top of a stack
►CVrmlParser	A Bison parser
Ctoken	Tokens
COculusRiftHandler	Support for the Oculus Rift VR device