Class Hierarchy

Go to the graphical class hierarchy

This inheritance list is sorted roughly, but not completely, alphabetically:

[detail level 12345678]

CH3D::TypedFieldTypeCheck::Any< H3D_ANY_TEMPLATE_SPEC >	The Any template can be used in the RequiredArgTypes or OptionalArgTypes arguments of a TypedField template instantiation
CH3D::TypedFieldTypeCheck::AnyNumber< Type >	The AnyNumber template can be used in the OptionalArgTypes argument of a TypedField template instantiation
CH3D::H3DGeneratedShaderNode::Attribute	Struct used to define an attribute in the shader
►CH3D::AutoUpdate< BaseFieldType >	The AutoUpdate field is a template to force the BaseField to update itself as soon as an event is received
►CH3D::OnNewValueSField< AutoUpdate< SFFloat > >
CH3D::PlaybackDevice::OnPlaybackSpeed	A field used to adjust the playback speed
CH3D::Image3DTexture::SFImage::CBData	Struct for storing input needed for the callback function
CH3D::ImageTexture::SFImage::CBData	Struct for storing input needed for the callback function
CH3D::SAI::ComponentInfo	The ComponentInfo object stores information about a particular X3D component
CH3D::H3DVideoClipDecoderNode::DecoderRegistration	Class used to register a class to the registered file readers
►CH3D::X3D::DEFNodesBase	Base class that adds functionallity needed for reference count debugging
CH3D::X3D::DEFNodes	Provides a mapping between defined DEF names in X3D and the nodes they refer to
►CH3D::DependentMFNode< NodeType, FieldRefs, DynamicCast >	DependentMFNode are modified TypedMFNode fields where the field dirty status is dependent on fields in the nodes it contains
►CH3D::TypedField< DependentMFNode< Group, FieldRef< H3DDisplayListObject, H3DDisplayListObject::DisplayList, &H3DDisplayListObject::displayList >, true >, Types< SFBool, MFString > >
CH3D::Inline::LoadedScene	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
CH3D::ComposedShader::MFShaderPart	MFShaderPart is specialized to transfer a pointer from itself to the ShaderPart instances contained in the field
►CH3D::DependentMFNode< ShaderProgram, FieldRef< H3DDisplayListObject, H3DDisplayListObject::DisplayList, &H3DDisplayListObject::displayList >, true >
CH3D::ProgramShader::MFShaderProgram	Sets the profile for each ShaderProgram node that is added to it
►CH3D::DependentMFNode< X3DChildNode, FieldRef< H3DDisplayListObject, H3DDisplayListObject::DisplayList, &H3DDisplayListObject::displayList >, true >
CH3D::X3DGroupingNode::MFChild	MFChild sets up a routes from the Nodes that are added and removed from the field to the owner of the field
CH3D::DependentMFNode< X3DGeometryNode, FieldRef< H3DDisplayListObject, H3DDisplayListObject::DisplayList, &H3DDisplayListObject::displayList >, true >
►CH3D::DependentMFNode< X3DVertexAttributeNode, FieldRef< X3DGeometricPropertyNode, Field, &X3DVertexAttributeNode::propertyChanged > >
CH3D::IndexedLineSet::MFVertexAttributeNode	The MFVertexAttributeNode is dependent on the propertyChanged field of the contained X3DVertexAttributeNode
CH3D::LineSet::MFVertexAttributeNode	The MFVertexAttributeNode is dependent on the propertyChanged field of the contained X3DVertexAttributeNode
CH3D::PointSet::MFVertexAttributeNode	The MFVertexAttributeNode is dependent on the propertyChanged field of the contained X3DVertexAttributeNode
CH3D::X3DComposedGeometryNode::MFVertexAttributeNode	The MFVertexAttributeNode is dependent on the propertyChanged field of the contained X3DVertexAttributeNode
CH3D::DependentMFNodeObject< NodeType, FieldRefs, DynamicCast >	DependentMFNodeObject is similar to DependentMFNode but uses TypedMFNodeObject instead of TypedMFNode
►CH3D::DependentSFNode< NodeType, FieldRefs, DynamicCast >	DependentSFNode are modified TypedSFNode fields where the field dirty status is dependent on fields in the node it contains
►CH3D::TypedField< DependentSFNode< X3DCoordinateNode, FieldRef< X3DGeometricPropertyNode, Field, &X3DCoordinateNode::propertyChanged > >, Types< SFFloat, SFFloat, SFFloat, SFFloat, SFFloat, SFFloat, SFFloat, SFFloat, SFFloat, SFFloat, SFFloat, SFFloat, SFInt32 > >
CH3D::SuperShape::SFCoordinateNode	The SFCoordinateNode is a class that contain a X3DCoordinateNode
CH3D::X3DNurbsSurfaceGeometryNode::TexCoordOrNurbsTex	This field class takes as input SFNode field and checks whether this is one of the allowed textureNodes or not
►CH3D::DependentSFNode< X3DGeometryNode, FieldRef< H3DDisplayListObject, H3DDisplayListObject::DisplayList, &H3DDisplayListObject::displayList >, true >
CH3D::PlanarReflector::SFGeometryNode	SFGeometryNode is dependent on the displayList field of its encapsulated X3DGeometryNode node, i.e
CH3D::TexGenGeometry::SFGeometryNode	The SFGeometryNode keeps a route between the contained X3DGeometryNode's bound field and the bound field ot the TexGenGeometry
►CH3D::X3DShapeNode::SFGeometryNode	SFGeometryNode is dependent on the displayList field of its encapsulated X3DGeometryNode node, i.e
CH3D::DeformableShape::SFGeometryNode	The SFGeometryNode is extended to only accept X3DComposedGeometryNode nodes
►CH3D::DependentSFNode< X3DTexture2DNode, FieldRef< H3DDisplayListObject, H3DDisplayListObject::DisplayList, &H3DDisplayListObject::displayList >, true >
CH3D::DepthMapSurface::SFTexture2DNode	Field that contains an X3DTexture2DNode
CH3D::DependentSFNodeObject< NodeType, FieldRefs, DynamicCast >	DependentSFNodeObject is similar to DependentSFNode but uses TypedSFNodeObject instead of TypedSFNode
►CH3D::DependentSFNodeObject< H3DImageObject, FieldRef< H3DImageObject, H3DImageObject::SFImage, &H3DImageObject::image >, true >
CH3D::HapticTexturesSurface::SFImageObjectNode	An SFNode where we make sure the type of the nodes contained is a subclass of H3DImageObject
CH3D::ImageObjectInfo::SFImageObjectNode	An SFNode where we make sure the type of the nodes contained is a subclass of H3DImageObject
CH3D::Field::Event	The Event struct encapsulates an event in the field network
►CH3D::EventCollectingField< FieldType >	The EventCollection field collects all fields routed to it that generates event between calls to the update function of the field
►CH3D::TypedField< EventCollectingField< SFString >, Types< MFString, SFBool >, AnyNumber< Field > >
CH3D::ShaderPart::SFShaderString	Update the string to use as shader depending from the urls given
►CH3D::Field	The Field class
►CH3D::AutoUpdate< Field >
CH3D::ComposedShader::SetupDynamicRoutes	Class used to set up routes from nodes in SFNode and MFNode fields to correctly break cache
CH3D::X3DProgrammableShaderObject::UpdateTextures	For bindless textures handle the updating of the textures list of all shader fields that contain the texture
►CH3D::EventCollectingField< Field >
►CH3D::PeriodicUpdate< EventCollectingField< Field > >
CH3D::SpiderMonkeySAI::CallbackFunctionDispatcher	Handles the calls of the ecmascript callback functions for the fields
CH3D::ComposedShader::UpdateUniforms	A field used to update any uniforms from their corresponding fields
►CH3D::PeriodicUpdate< Field >
CH3D::PlaybackDevice::OnDefaultValuesChanged	A field used to update default playback values
CH3D::Sound::ALSoundSetup	Field that calls ALrender() when a field routed to it has generated an event
CH3D::X3DSoundSourceNode::ALSoundBuffer	Field that calls ALrender() when a field routed to it has generated an event
►CH3D::RefCountSField< Bound >
►CH3D::H3DBoundedObject::SFBound	The Bound object is reference counted by the field
►CH3D::TypedField< H3DBoundedObject::SFBound, TypedSFNode< X3DCoordinateNode > >
CH3D::CoordBoundField	The CoordBoundField is specialized update itself from a X3DCoordinateNode
►CH3D::RefCountSField< HAPI::Collision::BinaryBoundTree >
CH3D::X3DGeometryNode::SFBoundTree	The SFBoundTree constructs a BinaryBoundTree that can be used for collision detection as well as fast collection of haptic primitives (triangles, points, lines)
►CH3D::TypedField< Field, void, AnyNumber< SFNode > >
►CH3D::RefCountSField< Node, TypedField< Field, void, AnyNumber< SFNode > > >
►CH3D::SFNode	SFNode is almost like any SField but it encapsulates a pointer to a Node
►CH3D::TypedSFNode< CyberGloveSensor >
CH3D::HumanHand::SFCyberGloveSensor	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
►CH3D::TypedSFNode< X3DSoundSourceNode >
CH3D::Sound::SFSoundSourceNode	The SFSoundSourceNode registers the Sound node in the X3DSoundSourceNode that is put into the field
►CH3D::TypedSFNode< H3DHapticsRendererNode >
CH3D::H3DHapticsDevice::SFHapticsRendererNode	SFHapticsRendererNode extends TypedSFNode< H3DHapticsRendererNode > in order to change the haptics renderer for the used HAPIHapticsDevice when changing H3DHapticsRendererNode
►CH3D::TypedSFNode< X3DGeometryNode >
CH3D::ShadowGeometry::SFGeometryNode	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
CH3D::TypedSFNode< NodeType >	Template to make sure that the Node that is set in a SFNode is of a specified Node type
►CH3D::TypedSFNodeObject< Type >	Template to make sure that the Node that is set in a SFNode is of a specified type
►CH3D::AutoUpdate< TypedSFNodeObject< H3DImageObject > >
CH3D::ImageObjectTexture::SFImageObject	H3DImageObject and maintains a route from the contained object's image field to the image field of the ImageObjectTexture it resides in
CH3D::TypedField< Field, SFFloat >
►CH3D::H3DDisplayListObject::DisplayList	We use the Field's lazy evaluation mechanisms to manage the GL display lists for rendering, giving automatic cache breaking when dependencies are modified
►CH3D::X3DGeometryNode::BugWorkaroundDisplayList	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
►CH3D::X3DGeometryNode::DisplayList	Display list is extended in order to set front sidedness of triangles outside the display list
CH3D::Arc2D::DisplayList	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
CH3D::Circle2D::DisplayList	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
CH3D::ElevationGrid::DisplayList	Display list is extended in order to set front sidedness of triangles outside the display list
CH3D::IndexedLineSet::DisplayList	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
CH3D::LineSet::DisplayList	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
CH3D::NurbsCurve::DisplayList	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
CH3D::PointSet::DisplayList	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
CH3D::Polyline2D::DisplayList	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
CH3D::Polypoint2D::DisplayList	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
CH3D::Text::DisplayList	We extend the DisplayList to build the fonts of the X3DFontStyleNode in the fontStyle field of the Text node this DisplayList resides in
CH3D::X3DComposedGeometryNode::DisplayList	Display list is extended in order to set front sidedness of triangles outside the display list
►CH3D::X3DShapeNode::BugWorkaroundDisplayList	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
CH3D::X3DShapeNode::DisplayList	Display list is extended in
CH3D::X3DTextureTransformNode::DisplayList	The rendering of texture transformation requires the specifiation of which texture units to render the transformation for
CH3D::MFNodeSplitter::UpdateSelection	Specialized field class used to update which node is selected
►CH3D::ParsableField	This is a field which value can be set by a string from the X3D parser
►CH3D::RefCountSField< Image, ParsableField >
►CH3D::H3DImageObject::SFImage	The SFImage field is a field containing an Image pointer
►CH3D::X3DTexture2DNode::SFImage	A SFNode encapsulating an Image class
►CH3D::TypedField< H3D::X3DTexture2DNode::SFImage, H3D::Types< SFFunctionNode, SFFunctionNode, SFFunctionNode, SFFunctionNode > >
CH3D::TransferFunctionTexture::SFImage	SFImage is overridden to update the value from the functions
►CH3D::TypedField< X3DTexture2DNode::SFImage, Types< SFFloat, SFFloat, SFInt32, SFFloat, SFInt32, SFInt32, SFInt32, SFString, SFBool > >
CH3D::NoiseTexture::SFImage	SFImage is overridden to update the value from the url and imageLoader fields of the ImageTexture
►CH3D::TypedField< X3DTexture2DNode::SFImage, Types< SFFunctionNode, SFColorRGBA, SFColorRGBA, SFVec2f, SFVec2f, SFInt32, SFInt32 > >
CH3D::FunctionPlotTexture::SFImage	SFImage is overridden to update the image from the field values
►CH3D::TypedField< X3DTexture2DNode::SFImage, Types< MFString, MFImageLoader > >
CH3D::ImageTexture::SFImage	SFImage is overridden to update the value from the url and imageLoader fields of the ImageTexture
►CH3D::X3DTexture3DNode::SFImage	A SFNode encapsulating an Image class
►CH3D::TypedField< X3DTexture3DNode::SFImage, Types< MFString, MFImageLoader > >
CH3D::Image3DTexture::SFImage	SFImage is overridden to update the value from the url and imageLoader fields of the Image3DTexture
CH3D::TypedField< X3DTexture3DNode::SFImage, MFTexture2DNode >
►CH3D::TypedField< X3DTexture3DNode::SFImage, Types< SFFloat, SFFloat, SFInt32, SFFloat, SFInt32, SFInt32, SFInt32, SFInt32, SFString, SFBool > >
CH3D::NoiseTexture3D::SFImage	SFImage is overridden to update the value from the url and imageLoader fields of the ImageTexture
►CH3D::TypedField< ParsableField, void, AnyNumber< SField< Type > > >
►CH3D::SField< Type >	Template class that adds the Field mechanisms to an encapsulated value of specified type
►CH3D::TypedField< SField< HAPI::ParsedFunction * >, Types< SFString, SFString > >
CH3D::GeneralFunction::SFFunctionObject	Class for updating an HAPI::ParsedFunction depending on field input value
►CH3D::ParsableMField	This is a field which value can be set by a string from the X3D parser
►CH3D::TypedField< ParsableMField, void, AnyNumber< MFieldBase< Type, std::vector< Type >, ParsableMField > > >
►CH3D::MFieldBase< Type, std::vector< Type >, ParsableMField >
CH3D::MField< Type >	Template class that adds the Field mechanism to a vector of values
CH3D::MFieldBase< Type, VectorClass, BaseField >	The common base class for MField types and MFNode
CH3D::RefCountSField< RefClass, BaseField >	RefCountSField is almost like any SField but it encapsulates a pointer to a RefCountedClass
CH3D::Scene::EventSink	Makes all fields up-to-date what are routed to it, with the exception of PeriodicUpdateFields
CH3D::SpiderMonkey::SFMatrix3fRow	X3DMatrix3
CH3D::SpiderMonkey::SFMatrix4fRow	X3DMatrix4
CH3D::H3DNodeDatabase::FieldDBConstIterator	The FieldDBConstIterator is an iterator class used for iterating over the field instances in an H3DNodeDatabase
►CH3D::FieldDBElement	A FieldDBElement is an encapsulation of a field in a H3DNodeDatabase
CH3D::DynamicFieldDBElement	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
CH3D::FieldDBTemplate< N, F >	Template class for specifying specialized FieldDBElement instances
CH3D::ProtoDeclaration::FieldDeclaration	Class that contains information about a field that is part of the prototype declaration
CH3D::FieldRef< NodeType, FieldType, member_ptr >	Class used for specifying a field member of a node in a DependentSFNode or DependentMFNode specification
CH3D::H3DImageLoaderNode::FileReaderRegistration	Class used to register a class to the registered file readers
CH3D::H3DSoundFileNode::FileReaderRegistration	Class used to register a class to the registered file readers
CH3D::X3DLightNode::GLLightInfo	A structure representing a the OpenGL representation of the specified light source
►CH3D::GLVertexAttributeObject	This abstract interface is inherited by all nodes that could be used as vertex attributes in a glsl shader
CH3D::FogCoordinate	This node defines a set of explicit fog depths on a per-vertex basis
►CH3D::X3DColorNode	This is the base node type for color specifications in X3D
CH3D::Color	This node defines a set of RGB colours to be used in the fields of another node
CH3D::ColorRGBA	This node defines a set of RGBA colours to be used in the fields of another node
►CH3D::X3DCoordinateNode	This is the base node type for all coordinate node types in X3D
CH3D::Coordinate	This node defines a set of 3D coordinates to be used in the coord field of vertex-based geometry nodes
CH3D::CoordinateDouble	This node defines a set of 3D coordinates to be used in the coord field of vertex-based geometry nodes
►CH3D::X3DNormalNode	This is the base node type for all normal node types in X3D
CH3D::Normal	This node defines a set of 3D surface normal vectors to be used in the vector field of some geometry nodes
►CH3D::X3DTextureCoordinateNode	This abstract node type is the base type for all node types which specify texture coordinates
CH3D::MultiTextureCoordinate	MultiTextureCoordinate supplies multiple texture coordinates per vertex
CH3D::TextureCoordinate	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
CH3D::TextureCoordinate3D	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
CH3D::TextureCoordinate4D	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
CH3D::TextureCoordinateGenerator	TextureCoordinateGenerator supports the automatic generation of texture coodinates for geometric shapes
►CH3D::X3DVertexAttributeNode	This abstract node type is the base type for all node types that specify per-vertex attribute information to the shader
CH3D::FloatVertexAttribute	The FloatVertexAttribute node defines a set of per-vertex single precision floating point attributes
CH3D::Matrix3VertexAttribute	Defines a set of per-vertex 3*3 matrix attributes
CH3D::Matrix4VertexAttribute	Defines a set of per-vertex 4*4 matrix attributes
►CH3D::H3DBoundedObject	This abstract interface is the base class for all node types that include a bounding box
►CH3D::X3DBoundedObject	This X3D abstract interface type is basis for all X3D node types that have bounds specified as part of the definition
CH3D::HAnimHumanoid	The HAnimHumanoid node is a container for the entire humanoid
CH3D::Inline	The Inline node embeds an X3D scene stored at a location on the World Wide Web into the current scene
CH3D::PlanarReflector	The PlanarReflector defines a geometry which will act as a mirror in the scene
►CH3D::X3DGroupingNode	This abstract node type indicates that concrete node types derived from it contain children nodes and is the basis for all aggregation
CH3D::Anchor	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
CH3D::Collision	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
CH3D::FrameBufferTextureGenerator	The FrameBufferTextureGenerator node provides a mean to render a sub-scene into a texture instead of the normal frame buffer
CH3D::Group	A Group node contains children nodes without introducing a new transformation
CH3D::H3DRenderModeGroupNode	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
CH3D::HAnimSegment	The HAnimSegment object is a container for information about a segment of the body
CH3D::HapticLayeredGroup	HapticLayeredGroup is a grouping node that can be used to set different shapes for different layers of the haptic rendering
►CH3D::MatrixTransform	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
CH3D::Billboard	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
CH3D::DynamicTransform	The DynamicTransform node is a Shape container that has basic properties for defining rigid body motion
CH3D::FitToBoxTransform	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
CH3D::LOD	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
►CH3D::Transform	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
CH3D::HAnimJoint	The HAnimJoint object is the fundamental building block that represents body parts
CH3D::HAnimSite	An HAnimSite node serves three purposes
CH3D::RenderTargetSelectGroup	The RenderTargetSelectGroup is used in combination with the FrameBufferTextureGenerator to select which color textures to render into
CH3D::Switch	The Switch grouping node traverses zero or one of the nodes specified in the choice field
CH3D::ToggleGroup	The ToggleGroup node enables you to enable/disable haptics and graphics rendering of its children nodes
►CH3D::X3DShapeNode	This is the base node type for all Shape nodes
CH3D::DeformableShape	The DeformableShape is an X3DShapeNode which makes it possible to deform the geometry of the shape when touching it with a haptics device
CH3D::ParticleSystem	The ParticleSystem node specifies a complete particle system
CH3D::Shape	The Shape node has two fields, appearance and geometry, which are used to create rendered objects in the world
►CH3D::X3DGeometryNode	This is the base node type for all geometry in X3D
CH3D::Arc2D	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
CH3D::ArcClose2D	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
CH3D::Box	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
CH3D::Capsule	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
CH3D::Circle2D	The Circle2D node specifies a circle centred at (0,0) in the local 2D coordinate system
CH3D::Cone	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
CH3D::Cylinder	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
CH3D::Disk2D	The Disk2D node specifies a circular disk which is centred at (0, 0) in the local coordinate system
CH3D::ElevationGrid	The ElevationGrid node specifies a uniform rectangular grid of varying height in the Y=0 plane of the local coordinate system
CH3D::Extrusion	The Extrusion node specifies geometric shapes based on a two dimensional cross-section extruded along a three dimensional spine in the local coordinate system
CH3D::FullscreenRectangle	The FullscreenRectangle node draws a rectangle covering the entire screen
CH3D::GeometryGroup	The GeometryGroup node is treated by the scenegraph as one geometry but it can contain several geometries
CH3D::HumanHand	This is a X3DGeometryNode which renders a hand using the Virtual Hand SDK
CH3D::IndexedLineSet	The IndexedLineSet node represents a 3D geometry formed by constructing polylines from 3D vertices specified in the coord field
CH3D::LineSet	The LineSet node represents a 3D geometry formed by constructing polylines from 3D vertices specified in the coord field
CH3D::PointSet	The PointSet node specifies a set of 3D points, in the local coordinate system, with associated colours at each point
CH3D::Polyline2D	The Polyline2D node specifies a series of contiguous line segments in the local 2D coordinate system connecting the specified vertices
CH3D::Polypoint2D	The Polyline2D node specifies a set of vertices in the local 2D coordinate system at each of which is displayed a point
CH3D::Rectangle2D	The Rectangle2D node specifies a rectangle centred at (0, 0) in the current local 2D coordinate system and aligned with the local coordinate axes
CH3D::Sphere	The Sphere node specifies a sphere centred at (0, 0, 0) in the local coordinate system
CH3D::SuperShape	The SuperShape node implements a SuperShape!
CH3D::TexGenGeometry	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
CH3D::Text	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)
CH3D::TriangleSet2D	The TriangleSet2D node specifies a set of triangles in the local 2D coordinate system
►CH3D::X3DComposedGeometryNode	This is the base node type for all composed 3D geometry in X3D
CH3D::IndexedFaceSet	The IndexedFaceSet node represents a 3D shape formed by constructing faces (polygons) from vertices listed in the coord field
CH3D::IndexedTriangleFanSet	An IndexedTriangleFanSet represents a 3D shape composed of triangles that form a fan shape around the first vertex declared in each fan
CH3D::IndexedTriangleSet	The IndexedTriangleSet node represents a 3D shape composed of a collection of individual triangles
CH3D::IndexedTriangleStripSet	An IndexedTriangleStripSet represents a 3D shape composed of strips of triangles
CH3D::TriangleFanSet	A TriangleFanSet represents a 3D shape composed of triangles that form a fan shape around the first vertex declared in each fan
CH3D::TriangleSet	The TriangleSet node represents a 3D shape that represents a collection of individual triangles
CH3D::TriangleStripSet	A TriangleStripSet represents a 3D shape composed of strips of triangles
►CH3D::X3DParametricGeometryNode	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
CH3D::NurbsCurve	The NurbsCurve node is a geometry node defining a parametric curve in 3D space
►CH3D::X3DNurbsSurfaceGeometryNode	The X3DNurbsSurfaceGeometryNode represents the abstract geometry type for all types of NURBS surfaces
CH3D::NurbsPatchSurface	The NurbsPatchSurface node is a contiguous NURBS surface patch
CH3D::NurbsTrimmedSurface	The NurbsTrimmedSurface node defines a NURBS surface that is trimmed by a set of trimming loops
►CH3D::X3DPrototypeInstance	This abstract node type is the base type for all prototype instances in the X3D system
CH3D::PrototypeInstance	The PrototypeInstance is an instance of a prototyped node
►CH3D::H3DDisplayListObject	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
►CH3D::ClipPlane	This node defines a single plane equation that will be used to clip the geometry, i.e
CH3D::PointNormalClipPlane	This is a ClipPlane where the plane is specified with a point and a normal
CH3D::HAnimHumanoid	The HAnimHumanoid node is a container for the entire humanoid
CH3D::Inline	The Inline node embeds an X3D scene stored at a location on the World Wide Web into the current scene
CH3D::PlanarReflector	The PlanarReflector defines a geometry which will act as a mirror in the scene
►CH3D::ShaderChildNode	This is the base node type for the child nodes of the ComposedShader node
CH3D::ShaderAtomicCounter	A ShaderAtomicCounter is a atomic counter can be used in GLSL shader
CH3D::ShaderStorageBuffer	This node provide a buffer object for OpenGL shader program to write into and read from
CH3D::ShaderConstants	The ShaderConstants node is a node will be used to gather all static shader inputs to be used in the shader
CH3D::ShaderProgram	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
CH3D::ShadowCaster	The ShadowCaster node uses shadow volumes using stencil buffer to cast shadows from objects in a scene
CH3D::TransformInfo	The TransformInfo node provides information about the coordinate space it resides in in the scene graph
►CH3D::X3DAppearanceChildNode	This is the base node type for the child nodes of the X3DAppearanceNode type
CH3D::FillProperties	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
CH3D::LineProperties	The LineProperties node specifies additional properties to be applied to all line geometry
CH3D::RenderProperties	The RenderProperties node specifies additional rendering options that cannot be specified with the X3D Appearance node
►CH3D::X3DMaterialNode	This is the base node type for all Material nodes
CH3D::Material	The Material node specifies surface material properties for associated geometry nodes and is used by the X3D lighting equations during rendering
CH3D::TwoSidedMaterial	This node defines material properties that can effect both the front and back side of a polygon individually
►CH3D::X3DShaderNode	This abstract node type is the base type for all node types which specify a programmable shader
►CH3D::ComposedShader	The ComposedShader node defines a shader where the individual source files are not individually programmable
►CH3D::H3DGeneratedShaderNode	The H3DGeneratedShaderNode node is the base class for nodes that generates GLSL shaders for use in place of a ComposedShader in the Appearance field
CH3D::ComposedGeneratedShader	The ComposedGeneratedShader node composes vertex shader manipulator shaders with fragment shaders
►CH3D::H3DGeneratedFragmentShaderNode	The H3DGeneratedFragmentShaderNode node is the base class for shader generator nodes that specify a fragment shader values
►CH3D::ConvolutionFilterShader	The ConvolutionFilterShader node generates a shader that applies a convolution filter kernel to the input texture
CH3D::GaussianFilterShader	The GaussianFilterShader is a ConvolutionFilterShader node where the weights are automatically calculated from a gaussian function
CH3D::EnvironmentMapShader	The EnvironmentMapShader node defines a shader for environment mapping of shiny objects
CH3D::NormalShader	The NormalShader node generates a shader that renders the normal in view space of the geometry as color
CH3D::PhongShader	The PhongShader node defines a shader for using the Phong illumination model
CH3D::ShaderCombiner	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
CH3D::H3DGeneratedVertexShaderNode	The H3DGeneratedVertexShaderNode node is the base class for shader generator nodes that only modify the vertex shader values and ignores the fragment shader
CH3D::MultiRenderTargetShader	The MultiRenderTargetShader node defines a way to use different shaders for different render targets in one pass
CH3D::PackagedShader	A PackagedShader node describes a single file that may contain a number of shaders and combined effects
CH3D::ProgramShader	He ProgramShader node defines a shader that can consist of one or more individually programmable, self contained pieces
►CH3D::X3DTextureNode	This abstract node type is the base type for all node types which specify sources for texture images
►CH3D::H3DSingleTextureNode	This abstract node type is the base type for all texture nodes that is defined by a single texture
CH3D::RenderTargetTexture	The RenderTargetTexture is a wrapper node to use one of the render targets(color textures) from a FrameBufferTextureGenerator directly as a texture
►CH3D::ShaderImageNode	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
CH3D::ShaderImage2D	ShaderImage2D is a 2D image which can allow openGL to read from and write to
CH3D::ShaderImage3D	ShaderImage2D is a 3D image which can allow openGL to read from and write to
►CH3D::X3DEnvironmentTextureNode	This abstract node type is the base type for all node types that specify cubic environment map sources for texture images
CH3D::ComposedCubeMapTexture	The ComposedCubeMapTexture node defines a cubic environment map source as an explicit set of images drawn from individual 2D texture descriptions
CH3D::GeneratedCubeMapTexture	The GeneratedCubeMapTexture node defines a cubic environment map that sources its data from internally generated images
►CH3D::X3DTexture2DNode	This abstract node type is the base type for all node types which specify 2D sources for texture images
CH3D::FunctionPlotTexture	Texture showing a plot of a function
CH3D::GeneratedTexture	The GeneratedTexture node is a 2d-texture node that are automatically generated from nodes like FrameBufferTextureGenerator
►CH3D::H3DVideoTextureNode	H3DVideoTextureNode is a virtual base class for classes using video as a texture
CH3D::MovieTexture	MovieTexture is a class that is not implemented in H3DAPI yet
CH3D::SimpleMovieTexture	SimpleMovieTexture is a node for showing movies as textures with a simpler interface than the movie texture node
CH3D::ImageTexture	The ImageTexture node defines a texture map by specifying an image file and general parameters for mapping to geometry
CH3D::NoiseTexture	The NoiseTexture node creates a texture with Perlin noise
CH3D::PixelTexture	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
CH3D::TransferFunctionTexture	Texture for defining a transfer function from a single value to RGBA values using H3DFunctionNode instances
►CH3D::X3DTexture3DNode	This abstract node type is the base type for all node types which specify 3D sources for texture images
CH3D::Composed3DTexture	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
CH3D::GeneratedTexture3D	The GeneratedTexture3D node is a 3d-texture node that are automatically generated from nodes like FrameBufferTextureGenerator
CH3D::Image3DTexture	The Image3DTexture node defines a texture map by specifying a single file that contains complete 3D data and general parameters for mapping to geometry
CH3D::ImageObjectTexture	The ImageObjectTexture node uses the image data from any node that implements the H3DImageObject interface as texture data
CH3D::NoiseTexture3D	The NoiseTexture3D node creates a texture with Perlin noise
CH3D::Pixel3DTexture	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
CH3D::MultiTexture	MultiTexture enables the application of several individual textures to a 3D object to achieve a more complex visual effect
►CH3D::X3DTextureTransformNode	This abstract node type is the base type for all node types which specify a transformation of texture coordinates
CH3D::MultiTextureTransform	MultiTextureTransform supplies multiple texture transforms per appearance
CH3D::TextureMatrixTransform	The matrix field specifies a generalized, unfiltered 4×4 transformation matrix that can be used to modify the texture
CH3D::TextureTransform3D	The TextureTransform3D node defines a 3D transformation that is applied to texture coordinates (see TextureCoordinate)
►CH3D::X3DTextureTransform2DNode	<>
CH3D::TextureTransform	The TextureTransform node defines a 2D transformation that is applied to texture coordinates (see TextureCoordinate)
►CH3D::X3DAppearanceNode	This is the base node type for all Appearance nodes
CH3D::Appearance	The Appearance node specifies the visual properties of geometry
CH3D::X3DGeometryNode	This is the base node type for all geometry in X3D
CH3D::X3DGroupingNode	This abstract node type indicates that concrete node types derived from it contain children nodes and is the basis for all aggregation
►CH3D::X3DLightNode	The X3DLightNode abstract node type is the base type from which all node types that serve as light sources are derived
►CH3D::DirectionalLight	The DirectionalLight node defines a directional light source that illuminates along rays parallel to a given 3-dimensional vector
CH3D::GeneralDirectionalLight	The GeneralDirectionalLight node defines a directional light source that illuminates along rays parallel to a given 3-dimensional vector
►CH3D::PointLight	The PointLight node specifies a point light source at a 3D location in the local coordinate system
CH3D::GeneralPointLight	The GeneralPointLight node specifies a point light source at a 3D location in the local coordinate system
►CH3D::SpotLight	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
CH3D::GeneralSpotLight	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
CH3D::X3DShapeNode	This is the base node type for all Shape nodes
►CH3D::H3DDynamicFieldsObject	This abstract interface class is the base class for all classes that specify arbitrary fields
CH3D::MFNodeSplitter	MFNodeSplitter node is used to split MFNode into certain SFNodes yet
CH3D::Script	No scripting is supported with the Script node yet
CH3D::ShaderConstants	The ShaderConstants node is a node will be used to gather all static shader inputs to be used in the shader
►CH3D::X3DProgrammableShaderObject	This abstract node type is the base type for all node types that specify arbitrary fields for interfacing with per-object attribute values
CH3D::ComposedShader	The ComposedShader node defines a shader where the individual source files are not individually programmable
CH3D::PackagedShader	A PackagedShader node describes a single file that may contain a number of shaders and combined effects
CH3D::ShaderProgram	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
CH3D::X3DPrototypeInstance	This abstract node type is the base type for all prototype instances in the X3D system
►CH3DUtil::Exception::H3DException [external]
CH3D::SAI::SAIError	This section defines the error types that may be generated in response to service requests
►CH3DUtil::Exception::H3DAPIException [external]
►CH3DUtil::Exception::ValueException< BaseMField::size_type > [external]
CH3D::MField< Type >::InvalidIndex	Thrown if the index given to getValueByIndex() is outside the boundaries
►CH3DUtil::Exception::ValueException< std::string > [external]
CH3D::FontStyle::InvalidFontStyleJustify	Thrown when the strings in the justify field are invalid values
CH3D::FontStyle::InvalidFontStyleRenderType	Thrown when the strings in the renderType field are invalid values
CH3D::FontStyle::InvalidFontStyleStyle	Thrown when the string in the style field is an invalid value
►CH3DUtil::Exception::ValueException< int > [external]
CH3D::IndexedLineSet::InvalidColorIndex	Thrown when the colorIndex field does not match the coordIndex field properly
CH3D::IndexedLineSet::InvalidColorIndexSize	Thrown when the colorIndex field's size does not match the coordIndex field properly
CH3D::IndexedTriangleFanSet::NotEnoughColors	Thrown if the number of colors in the color field is less than
CH3D::IndexedTriangleFanSet::NotEnoughTextureCoordinates	Thrown if the number of texture coordinates in the color field is less than the number coordinates in the coord field
CH3D::IndexedTriangleSet::NotEnoughColors	Thrown if the number of colors in the color field is less than the number coordinates in the coord field
CH3D::IndexedTriangleSet::NotEnoughTextureCoordinates	Thrown if the number of texture coordinates in the color field is less than the number coordinates in the coord field
CH3D::IndexedTriangleStripSet::NotEnoughColors	Thrown if the number of colors in the color field is less than the number coordinates in the coord field
CH3D::IndexedTriangleStripSet::NotEnoughTextureCoordinates	Thrown if the number of texture coordinates in the color field is less than the number coordinates in the coord field
CH3D::LineSet::InvalidVertexCountValue	Thrown then vertexCount value is < 2
CH3D::TraverseInfo::InvalidHapticsDeviceIndex	Thrown when trying to get hold of a H3DHapticsDevice using an invalid device index
CH3D::TriangleFanSet::InvalidFanCount	Thrown when fanCount value is < 3
CH3D::TriangleFanSet::NotEnoughColors	Thrown if the number of colors in the color field is less than the number coordinates in the coord field
CH3D::TriangleFanSet::NotEnoughTextureCoordinates	Thrown if the number of texture coordinates in the color field is less than the number coordinates in the coord field
CH3D::TriangleSet::NotEnoughColors	Thrown if the number of colors in the color field is less than the number coordinates in the coord field
CH3D::TriangleSet::NotEnoughTextureCoordinates	Thrown if the number of texture coordinates in the color field is less than the number coordinates in the coord field
CH3D::TriangleStripSet::InvalidStripCount	Thrown when stripCount value is < 3
CH3D::TriangleStripSet::NotEnoughColors	Thrown if the number of colors in the color field is less than the number coordinates in the coord field
CH3D::TriangleStripSet::NotEnoughTextureCoordinates	Thrown if the number of texture coordinates in the color field is less than the number coordinates in the coord field
►CH3DUtil::Exception::ValueException< unsigned int > [external]
CH3D::PointSet::NotEnoughColors	Thrown when the number of colors in the color field are less than the number of points in the coord field
►CH3DUtil::Exception::ValueException< string > [external]
CH3D::H3DWindowNode::RenderMode::InvalidRenderMode	Thrown when the value of RenderMode is an invalid mode
CH3D::PythonInvalidFieldType	An exception thrown when a field is of the wrong type when it is checked
►CH3DUtil::Exception::ValueException< BaseFieldType::size_type > [external]
CH3D::RefCountMField< RefClass >::InvalidIndex	Thrown if the index given to getValueByIndex() is outside the boundaries
►CH3DUtil::Exception::ValueException< const string > [external]
CH3D::X3D::Convert::UnimplementedConversionType	An exception for errors when the conversion from a string to the type that we try convert to is not implemented
CH3D::X3D::Convert::X3DFieldConversionError	An exception for errors when string to convert to a field value is invalid for the field type
CH3D::X3D::InvalidNodeType	An exception for errors when the Node type is not what was expected
CH3D::X3D::NoSuchDEFName	An exception for errors when the DEF name does not exist in the DEF nodes structure
CH3D::EaseInEaseOut::UnequalFieldValues	Thrown when number of field values in key and easeInEaseOut are not equal
CH3D::Field::FieldAccessError	Exception thrown when performing actions that conflict with the field's access type
CH3D::Image3DTexture::CouldNotLoadImage	CouldNotLoadImage is thrown when not any of the urls could be read with any of the image loaders in a Image3DTexture
CH3D::ImageTexture::CouldNotLoadImage	CouldNotLoadImage is thrown when not any of the urls could be read with any of the image loaders in a ImageTexture
CH3D::TypedFieldError	An exception thrown when the field does not conform to the type specification from a TypedField
CH3D::TypedFieldTypeCheck::InvalidTemplateArguments	InvalidTemplateArguments An exception thrown when the template argument list does not follow the rules defined in TypedField
CH3D::X3D::XMLParseError	An exception for errors occuring while parsing an X3D XML file
CH3D::X3DTextureNode::InvalidTextureDimensions	Thrown by renderImage () if the dimensions of an image are invalid, e.g
CH3D::X3DTextureNode::OpenGLTextureError	Thrown when an OpenGL error occurs while setting up the texture
CH3D::X3DTextureNode::glTexImageFunctionNotDefined	Thrown when a subclass to X3DTextureNode calls renderImage without defining the glTexImage () function
►CH3D::H3DImageObject	This abstract interface is inherited by all nodes that contains an SFImage object with an Image containing data
CH3D::X3DTexture2DNode	This abstract node type is the base type for all node types which specify 2D sources for texture images
CH3D::X3DTexture3DNode	This abstract node type is the base type for all node types which specify 3D sources for texture images
►CH3D::H3DMultiPassRenderObject	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
CH3D::GeneratedCubeMapTexture	The GeneratedCubeMapTexture node defines a cubic environment map that sources its data from internally generated images
CH3D::PlanarReflector	The PlanarReflector defines a geometry which will act as a mirror in the scene
CH3D::H3DNavigation	H3DNavigation is a class used for navigation in H3DAPI
►CH3D::H3DNavigationDevices	Base class for devices that should be used to navigate the scene
CH3D::HapticDeviceNavigation	Takes care of navigation using a haptics device
CH3D::KeyboardNavigation	Takes care of navigation using keyboard
CH3D::MouseNavigation	Take care of mouseNavigation
CH3D::SWSNavigation	Takes care of navigation with SpaceWareSensor
CH3D::H3DNodeDatabase	The H3DNodeDatabase contains a mapping between a name of a Node and the constructor for the Node with that name
►CH3D::H3DRenderStateObject	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
CH3D::ClipPlane	This node defines a single plane equation that will be used to clip the geometry, i.e
CH3D::LocalFog	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
CH3D::X3DLightNode	The X3DLightNode abstract node type is the base type from which all node types that serve as light sources are derived
CH3D::GraphicsHardwareInfo::Info	Holds information about the current graphics hardware
CH3D::X3D::IStreamInputSource	This class is a derivative of the standard Xerxes C InputSource class
CH3D::X3D::IStreamInputStream	This class implements the BinInputStream interface to read from a istream
CH3D::SpiderMonkey::JS_MField< MFieldType, ElementType >	MField template
CH3D::X3DSequencerNode::KeyValues< MType >	Each value in the keyValue field corresponds in order to the parameter value in the key field
CH3D::LibraryInfo	Structure to contain information about a shared library of extra nodes outside
CH3D::TraverseInfo::LightInfo	Class grouping X3DLightNode and its transformation matrix
Cyy::location	Abstract a location
►Cstd::map< K, T >	STL class
CH3D::X3D::DEFNodes	Provides a mapping between defined DEF names in X3D and the nodes they refer to
►CH3D::MFieldClass	Base class for all fields created with the MField template
►CH3D::MFieldBase< Vec3f, std::vector< Vec3f >, ParsableMField >
►CH3D::MField< Vec3f >
►CH3D::MFVec3f	The MFVec3f field contains a vector of Vec3f
►CH3D::TypedField< MFVec3f, Types< SFFloat, MFFloat, MFVec3f > >
CH3D::CoordinateInterpolator::MFValue	The SFValue field updates the interpolated value from the fields routed to it
CH3D::NormalInterpolator::MFValue	The SFValue field updates the interpolated value from the fields routed to it
►CH3D::TypedField< MFVec3f, MFVec3f, AnyNumber< MFVec3f > >
CH3D::GeometryGroup::MFVec3fPerIndex	Specialized field class which gets one value from each routed field and stores that at the corresponding index in its own value
►CH3D::TypedField< MFVec3f, Types< MFVec2f, MFRotation, MFVec2f, MFVec3f > >
CH3D::Extrusion::VertexVector	Specialized field vertex coordinates from the fields affecting this, the resulting vertexVector will be used both in render and in bound
►CH3D::MFieldBase< Vec3d, std::vector< Vec3d >, ParsableMField >
►CH3D::MField< Vec3d >
CH3D::MFVec3d	The MFVec3d field contains a vector of Vec3d
CH3D::MFieldBase< Type, std::vector< Type >, ParsableMField >
►CH3D::MFieldBase< string, std::vector< string >, ParsableMField >
►CH3D::MField< string >
CH3D::MFString	The MFString field conatins a vector of strings
►CH3D::MFieldBase< Quaternion, std::vector< Quaternion >, ParsableMField >
►CH3D::MField< Quaternion >
CH3D::MFQuaternion	The MFQuaternion field contains a vector of arbitrary Quaternion objects
►CH3D::MFieldBase< RGBA, std::vector< RGBA >, ParsableMField >
►CH3D::MField< RGBA >
CH3D::MFColorRGBA	The MFColorRGBA field contains a vector of RGBA (red-green-blue-alpha) colour 4-tuples
►CH3D::MFieldBase< bool, std::vector< bool >, ParsableMField >
►CH3D::MField< bool >
►CH3D::MFBool	The MFBool field contains a vector of boolean values
►CH3D::TypedField< MFBool, MFString >
CH3D::FrameBufferTextureGenerator::ResetPrintedFlags	A field to reset multiple warning printed flags
CH3D::GeometryGroup::IsTouched	Specialized field class which grabs the first true value for each index for any of the contained geometries
►CH3D::MFieldBase< Matrix4f, std::vector< Matrix4f >, ParsableMField >
►CH3D::MField< Matrix4f >
CH3D::MFMatrix4f	The MFMatrix4f field contains a vector of Matrix4f instances
►CH3D::MFieldBase< RefClass *, FieldInternals::MFNodeAutoRefVector< RefClass >, Field >
CH3D::RefCountMField< RefClass >	RefCountMField is almost like any MField but it encapsulates a vector of RefCoundtedClass pointers
►CH3D::MFieldBase< Node *, FieldInternals::MFNodeAutoRefVector< Node >, Field >
►CH3D::RefCountMField< Node >
►CH3D::MFNode	MFNode is almost like any MField but it encapsulates a vector of Node pointers
CH3D::TypedMFNode< H3DOptionNode >
►CH3D::TypedMFNode< H3DHapticsRendererNode >
CH3D::LayeredRenderer::MFHapticsRendererNode	MFHapticsRendererNode extends TypedMFNode< H3DHapticsRendererNode > in order to change the haptics renderer for the used HAPIHapticsDevice when changing H3DHapticsRendererNode
►CH3D::TypedMFNode< X3DChildNode >
CH3D::X3DGroupingNode::AddChildren	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
CH3D::X3DGroupingNode::RemoveChildren	RemoveChildren is a class that removes any node added to it from the children field of its owner (X3DGroupingNode)
CH3D::Contour2D::AddTheChildren	This field class checks whether the given node is of the right type (ContourPolyline2D or NurbsCurve2D)
CH3D::Contour2D::CheckTheChildren	This field class checks whether the given Node is of the right type (ContourPolyline2D or NurbsCurve2D) for adding or removing
CH3D::Contour2D::RemoveTheChildren	This field class checks whether the given node is of the right type (ContourPolyline2D or NurbsCurve2D)
CH3D::NurbsTrimmedSurface::AddContour	This field class checks whether the given node is of the right type (Contour2D)
CH3D::NurbsTrimmedSurface::CheckContour	This field class checks whether the given node is of the right type (Contour2D) for adding or removing
CH3D::NurbsTrimmedSurface::RemoveContour	This field class checks whether the given node is of the right type (Contour2D)
CH3D::TypedMFNode< NodeType >	Template to make sure that the Nodes that are added to a MFNode are of a specified Node type
CH3D::TypedMFNodeObject< Type >	Template to make sure that the Nodes that are set in a MFNode are of a specified type
CH3D::ViewpointGroup::MFChild	Type class of children field
►CH3D::MFieldBase< Matrix4d, std::vector< Matrix4d >, ParsableMField >
►CH3D::MField< Matrix4d >
CH3D::MFMatrix4d	The MFMatrix4d field contains a vector of Matrix4d instances
►CH3D::MFieldBase< Matrix3d, std::vector< Matrix3d >, ParsableMField >
►CH3D::MField< Matrix3d >
CH3D::MFMatrix3d	The MFMatrix3d field contains a vector of Matrix3d instances
►CH3D::MFieldBase< Vec4f, std::vector< Vec4f >, ParsableMField >
►CH3D::MField< Vec4f >
CH3D::MFVec4f	The MFVec4f field contains a vector of Vec4f
►CH3D::MFieldBase< Vec4d, std::vector< Vec4d >, ParsableMField >
►CH3D::MField< Vec4d >
CH3D::MFVec4d	The MFVec4d field contains a vector of Vec4d
►CH3D::MFieldBase< Vec2f, std::vector< Vec2f >, ParsableMField >
►CH3D::MField< Vec2f >
►CH3D::MFVec2f	The MFVec2f field contains a vector of Vec2f
►CH3D::TypedField< MFVec2f, Types< SFFloat, MFFloat, MFVec2f > >
CH3D::CoordinateInterpolator2D::MFValue	The SFValue field updates the interpolated value from the fields routed to it
►CH3D::MFieldBase< Vec2d, std::vector< Vec2d >, ParsableMField >
►CH3D::MField< Vec2d >
CH3D::MFVec2d	The MFVec2d field contains a vector of Vec2d
►CH3D::MFieldBase< Rotation, std::vector< Rotation >, ParsableMField >
►CH3D::MField< Rotation >
CH3D::MFRotation	The MFRotation field contains a vector of arbitrary Rotation objects
►CH3D::MFieldBase< RGB, std::vector< RGB >, ParsableMField >
►CH3D::MField< RGB >
CH3D::MFColor	The MFColor field contains a vector of RGB (red-green-blue) colour triples
►CH3D::MFieldBase< H3DFloat, std::vector< H3DFloat >, ParsableMField >
►CH3D::MField< H3DFloat >
►CH3D::MFFloat	The MFFloat field contains a vector of single-precision floating point numbers
►CH3D::TypedField< MFFloat, void, AnyNumber< Field > >
CH3D::GaussianFilterShader::MFWeights	Specialized field that reCalculate the kernel when it updates
►CH3D::MFieldBase< Matrix3f, std::vector< Matrix3f >, ParsableMField >
►CH3D::MField< Matrix3f >
CH3D::MFMatrix3f	The MFMatrix3f field contains a vector of Matrix3f instances
►CH3D::MFieldBase< H3DInt32, std::vector< H3DInt32 >, ParsableMField >
►CH3D::MField< H3DInt32 >
CH3D::MFInt32	The MFInt32 field contains a vector of 32-bit integers
►CH3D::MFieldBase< H3DDouble, std::vector< H3DDouble >, ParsableMField >
►CH3D::MField< H3DDouble >
►CH3D::MFDouble	The MFDouble field contains a vector of high-precision floating point numbers
►CH3D::TypedField< MFDouble, void, AnyNumber< MFTime > >
CH3D::MFTime	The MFTime field contains a vector of time values
CH3D::MFieldBase< Type, VectorClass, BaseField >	The common base class for MField types and MFNode
CH3D::X3D::X3DSAX2Handlers::NodeElement	Encapsulate a node with its XML containerField attribute
►CH3D::Node::NodeIntersectResult	Used as input to intersection functions
CH3D::Node::LineIntersectResult	Used as input to lineIntersect functions
COculusRiftHandler	Support for the Oculus Rift VR device
►CH3D::OnNewValueSField< SF >	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 )
CH3D::AutoUpdate< OnNewValueSField< SFString > >
CH3D::OnValueChangeSField< SF >	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
►CH3D::PeriodicUpdateField	Abstract base class for all Fields that will be updated without anyone asking for a value
►CH3D::PeriodicUpdate< SFImageObjectNode >
CH3D::ImageObjectInfo::UpdateFields	Field for updating the output fields when the image object changes value
►CH3D::PeriodicUpdate< SFBool >
CH3D::Anchor::GeometrySelected	Takes care of changing the scene when an object in the Anchor is selected (by clicking on it with the mouse)
►CH3D::PeriodicUpdate< TypedField< SFBool, Types< SFFloat, SFFloat > > >
CH3D::ForceDimensionDevice::ChangeVibration	EnableForce specializes SFFloat to handle vibration
►CH3D::PeriodicUpdate< BaseField >
CH3D::H3DFakeHapticsDevice::GetValueSafeField< BaseField >	A field which ensure that getValue and only getValue can be called within haptic thread with thread safety
CH3D::ThreadSafeMField< BaseField >	<>
CH3D::ThreadSafeRefSField< BaseField >	<>
CH3D::ThreadSafeSField< BaseField >	<>
►CH3D::PeriodicUpdate< TypedField< Field, Types< SFFontStyleNode, MFString > > >
CH3D::Text::OutputUpdater	Internal field class to update values of origin, textBounds, lineBounds
CH3D::PeriodicUpdate< Field >
CH3D::PeriodicUpdate< EventCollectingField< Field > >
►CH3D::PeriodicUpdate< SFTime >
CH3D::SimpleMovieTexture::FieldUpdater	The FieldUpdater field updates all output fields in the SimpleMovieTexture node that needs to be updated each frame
►CH3D::PeriodicUpdate< BaseFieldType >	The PeriodicUpdate is a template modifier that changes the way the field is updated
►CH3D::TypedField< PeriodicUpdate< SFInt32 >, Types< SFInt32, SFString > >
CH3D::HaptikDevice::SelectDevice	The SelectDevice field changes the haptics device to use depending on the values of set_selectedDevice and preferredDeviceType fields
CH3D::SpiderMonkey::PointerPrivateData< PointerType >	Class used as the private data in field JSObject classes
CH3D::Node::LineIntersectResult::PointingDeviceResultStruct	Contains a list of Nodes (X3DPointingDeviceNodes) and a transformation matrix from global space to local space of the nodes
Cyy::position	Abstract a position
CH3D::SAI::ProfileInfo	This object stores information about a particular X3D profile
►CH3D::PyType	Base class for all Python C type wrappers
►CH3D::PyTypeWrapper< RGB, &PyRGB_Type, PyRGB_Name, PyRGB_Check, PyRGB_AsRGB, PyRGB_FromRGB >
CH3D::PyRGB	Python C Type wrapper around RGB
►CH3D::PyTypeWrapper< RGBA, &PyRGBA_Type, PyRGBA_Name, PyRGBA_Check, PyRGBA_AsRGBA, PyRGBA_FromRGBA >
CH3D::PyRGBA	Python C Type wrapper around RGBA
CH3D::PyNode	Python C Type wrapper around Node*
►CH3D::PyTypeWrapper< Type, TypeObject, NameFunc, CheckFunc, ValueFunc, NewFunc >	PyTypeWrapper is a template wrapper class to create new Python types from types already existing in the H3DAPI (see PythonTypes.h) for example usage
►CH3D::PyNumberTypeWrapperBase< Type, TypeObject, NameFunc, CheckFunc, ValueFunc, NewFunc >	PyNumberTypeWrapperBase is a template wrapper class to create new Python types from types already existing in the H3DAPI (see PythonTypes.h) for example usage
►CH3D::PyNumberTypeWrapper< Matrix4d, &PyMatrix4d_Type, PyMatrix4d_Name, PythonInternals::PyMatrix4d4f_Check, PythonInternals::PyMatrix4d4f_AsMatrix4d, PyMatrix4d_FromMatrix4d >
CH3D::PyMatrix4d	Python C Type wrapper around Matrix4d
►CH3D::PyNumberTypeWrapper< Rotation, &PyRotation_Type, PyRotation_Name, PyRotation_Check, PyRotation_AsRotation, PyRotation_FromRotation >
CH3D::PyRotation	Python C Type wrapper around Rotation
►CH3D::PyNumberTypeWrapper< Matrix3f, &PyMatrix3f_Type, PyMatrix3f_Name, PyMatrix3f_Check, PyMatrix3f_AsMatrix3f, PyMatrix3f_FromMatrix3f >
CH3D::PyMatrix3f	Python C Type wrapper around Matrix3f
►CH3D::PyNumberTypeWrapper< Matrix3d, &PyMatrix3d_Type, PyMatrix3d_Name, PythonInternals::PyMatrix3d3f_Check, PythonInternals::PyMatrix3d3f_AsMatrix3d, PyMatrix3d_FromMatrix3d >
CH3D::PyMatrix3d	Python C Type wrapper around Matrix3d
►CH3D::PyNumberTypeWrapper< Matrix4f, &PyMatrix4f_Type, PyMatrix4f_Name, PyMatrix4f_Check, PyMatrix4f_AsMatrix4f, PyMatrix4f_FromMatrix4f >
CH3D::PyMatrix4f	Python C Type wrapper around Matrix4f
►CH3D::PyNumberTypeWrapper< Quaternion, &PyQuaternion_Type, PyQuaternion_Name, PyQuaternion_Check, PyQuaternion_AsQuaternion, PyQuaternion_FromQuaternion >
CH3D::PyQuaternion	Python C Type wrapper around Quaternion
►CH3D::PyVecTypeWrapper< Vec4d, &PyVec4d_Type, PyVec4d_Name, PythonInternals::PyVec4d4f_Check, PythonInternals::PyVec4d4f_AsVec4d, PyVec4d_FromVec4d >
CH3D::PyVec4d	Python C Type wrapper around Vec4d
►CH3D::PyVecTypeWrapper< Vec4f, &PyVec4f_Type, PyVec4f_Name, PyVec4f_Check, PyVec4f_AsVec4f, PyVec4f_FromVec4f >
CH3D::PyVec4f	Python C Type wrapper around Vec4f
►CH3D::PyVecTypeWrapper< Vec2d, &PyVec2d_Type, PyVec2d_Name, PythonInternals::PyVec2d2f_Check, PythonInternals::PyVec2d2f_AsVec2d, PyVec2d_FromVec2d >
CH3D::PyVec2d	Python C Type wrapper around Vec2d
►CH3D::PyVecTypeWrapper< Vec3d, &PyVec3d_Type, PyVec3d_Name, PythonInternals::PyVec3d3f_Check, PythonInternals::PyVec3d3f_AsVec3d, PyVec3d_FromVec3d >
CH3D::PyVec3d	Python C Type wrapper around Vec3d
►CH3D::PyVecTypeWrapper< Vec2f, &PyVec2f_Type, PyVec2f_Name, PyVec2f_Check, PyVec2f_AsVec2f, PyVec2f_FromVec2f >
CH3D::PyVec2f	Python C Type wrapper around Vec2f
►CH3D::PyVecTypeWrapper< Vec3f, &PyVec3f_Type, PyVec3f_Name, PyVec3f_Check, PyVec3f_AsVec3f, PyVec3f_FromVec3f >
CH3D::PyVec3f	Python C Type wrapper around Vec3f
CH3D::PyNumberTypeWrapper< Type, TypeObject, NameFunc, CheckFunc, ValueFunc, NewFunc >	PyNumberTypeWrapper is the same as PyNumberTypeWrapperBase with the difference that its mul function also specifies multiplication between two instances of the class
CH3D::PyVecTypeWrapper< Type, TypeObject, NameFunc, CheckFunc, ValueFunc, NewFunc >	PyVecTypeWrapper is the same as PyNumberTypeWrapperBase with the difference that its mul function also specifies vector dot product between two instances
►CH3DUtil::RefCountedClass [external]
►CH3D::Bound	Abstract base class for all classes specifying bounding objects
►CH3D::BoxBound	The BoxBound is a Bound class that specifies the bound using an axis-aligned bounding box
CH3D::TransformedBoxBound	A TransformedBoxBound is a wrapper around another BoxBound and its values are the values of the BoxBound transformed by a transformation matrix
CH3D::EmptyBound	An EmptyBound is a Bound that encompasses nothing
CH3D::InfiniteBound	An InfiniteBound is a Bound that encompasses everything
►CH3D::Node	Node is the base class for all classes that can be part of the H3D scene-graph
►CH3D::H3DCoordinateDeformerNode	The H3DCoordinateDeformerNode is the abstract base class for all nodes specifying deformation of coordinates based on contact of haptics devices
CH3D::CoordinateDeformer	The CoordinateDeformer uses a H3DFunctionNode to determine the deformation
►CH3D::H3DHapticsDevice	Base class for all haptic devices
CH3D::AnyDevice	AnyDevice tries to initialize all available HAPI haptics device nodes and uses the first one that succeeds
CH3D::ClutchedDevice	ClutchedDevice is a wrapper for a H3DHapticsDevice which adds clutching functionality
CH3D::EntactDevice	A EntactDevice is a node for handling communication with a haptics device from Entact
CH3D::FalconDevice	A FalconDevice is a node for handling communication with a haptics device from Novint, such as the Falcon Novint
CH3D::ForceDimensionDevice	A ForceDimensionDevice is a node for handling communication with a haptics device from ForceDimension, such as the Omega and Delta haptics devices
►CH3D::H3DFakeHapticsDevice	<>
CH3D::FakeHapticsDevice	A H3DHapticsDevice node where the position, orientation and button can be controlled via the set_devicePosition, set_deviceOrientation and set_mainButton fields
CH3D::SpaceWareHapticsDevice	A fake haptics device where the position and orientation is controlled via a SpaceWare device such as the SpaceMouse or SpaceTraveller
CH3D::HapticMasterDevice	A HapticMasterDevice is a node for handling communication with the HapticMaster haptics device from Moog/FCS
CH3D::HaptikDevice	The HaptikDevice uses the Haptik library (www.haptiklibrary.org) to access haptics devices
CH3D::MLHIDevice	A MLHIDevice is a node for handling communication with MLHI devices
CH3D::PhantomDevice	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
CH3D::PlaybackDevice	A PlaybackDevice is a fake haptics device node that can play back device values previously recorded using the DeviceLog node
CH3D::QuanserDevice	A QuanserDevice is a node for handling communication with a haptics device from Quanser, such as the 2-DOF Pantograph
CH3D::SimballDevice	A SimballDevice is a node for handling communication with a haptics device from ForceDimension, such as the Omega and Delta haptics devices
CH3D::VirtuoseDevice	A VirtuoseDevice is a node for handling communication with a haptics device from Haption, such as the Virtuose haptics device
►CH3D::H3DHapticsRendererNode	Base class for all haptic renderers, i.e
CH3D::Chai3DRenderer	Haptics renderer using Chai3D(www.chai3d.org) Uses the HAPI::Chai3DRenderer class
CH3D::GodObjectRenderer	Haptics renderer using the god object algorithm to render objects
CH3D::LayeredRenderer	Haptics renderer which may contain other haptics renderer nodes
CH3D::OpenHapticsRenderer	Haptics renderer using OpenHaptics to render objects
CH3D::RuspiniRenderer	Haptics renderer using a variant of the Ruspini algorithm allowing you to specify a radius on the proxy
►CH3D::H3DImageLoaderNode	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
CH3D::DDSImageLoader	DDSImageLoader is used to load DirectDraw Surface images (.dds)
CH3D::DicomImageLoader	DicomImageLoader uses the DCMTK library to load a DICOM image file
CH3D::FreeImageLoader	FreeImageLoader uses the FreeImage library to load the images
CH3D::NrrdImageLoader	NrrdImageLoader is a class which takes care of loading the nrrd image format
CH3D::RawImageLoader	The RawImageLoader loads a raw data file and lets the user specify the parameters for the values directly
►CH3D::H3DSoundStreamNode	This abstract node type is used to derive node types that can stream PCM sound data
►CH3D::H3DSoundFileNode	This abstract node type is used to derive node types that can stream PCM sound data from a file
CH3D::AudioFileReader	AudioFileReader uses the Audio File Library ( http://www.68k.org/~michael/audiofile/ ) to read sound data
CH3D::OggFileReader	OggFileReader uses the libVorbis (http://www.vorbis.com) decoder library to support Ogg Vorbis files
►CH3D::H3DSurfaceNode	Base class for all surfaces
►CH3D::H3DStiffnessSurfaceNode	A H3DStiffnessSurfaceNode is the base class for surfaces that have stiffness and damping
►CH3D::H3DFrictionalSurfaceNode	Base class for surfaces with friction
CH3D::DepthMapSurface	Uses a 2D texture to modify the depth of the surface
CH3D::FrictionalSurface	Surface with friction
CH3D::HapticTexturesSurface	Surface in which textures can be used to control the values of the parameters stiffness, damping, staticFriction and dynamicFriction
CH3D::SmoothSurface	A SmoothSurface has no friction at all
►CH3D::MagneticSurface	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
CH3D::OpenHapticsSurface	Surface type for setting OpenHaptics surface parameters directly
CH3D::MultiDeviceSurface	The MultiDeviceSurface allows you to specify different surface for different haptics devices in a multi device setup
►CH3D::H3DVideoClipDecoderNode	H3DVideoClipDecoderNode is a virtual base class for classes decoding video clips making new frames available to render
CH3D::DirectShowDecoder	This node uses DirectShow to decode video clips
CH3D::FFmpegDecoder	This node uses FFmpeg to decode video clips
►CH3D::H3DWindowNode	The base class for all window nodes
CH3D::GLUTWindow	H3DWindowNode implementet using GLUT
CH3D::Scene	The Scene node is topmost node that takes care of the rendering of the scene graph both haptically and graphically
CH3D::ShaderConstants	The ShaderConstants node is a node will be used to gather all static shader inputs to be used in the shader
►CH3D::X3DNode	This abstract node type is the base type for all nodes in the X3D system
CH3D::Contour2D	The Contour2D node groups a set of curve segments to a composite contour
►CH3D::H3DFunctionNode	Base class for nodes evaluating function
CH3D::GaussianFunction	The function node implements a gaussian function
CH3D::GeneralFunction	The function node implements a general function R^n -> R by specifying it by a string
►CH3D::H3DOptionNode	This abstract node type indicates that the concrete nodes which are instantiated based on it may be used in options fields
CH3D::CollisionOptions	Options related to collision in H3DAPI
CH3D::DebugOptions	Specifies parameters for if displaying debug information like bounding boxes, haptically rendered triangles etc
CH3D::DefaultAppearance	Specifies the default appearance parameters to use for graphical rendering
CH3D::GeometryBoundTreeOptions	Specifies parameters to use for the tree of bounding primitives that are built for each X3DGeometryNode for collision detection purposes
CH3D::GraphicsOptions	Specifies parameters to use for graphical rendering of nodes
CH3D::HapticsOptions	Specifies parameters to use when rendering an object with haptics
CH3D::OpenHapticsOptions	Specifies parameters to use for when rendering an object with OpenHaptics
►CH3D::H3DShadowObjectNode	The H3DShadowObjectNode is the base class for all shadow objects for use in the ShadowCaster node
CH3D::ShadowGeometry	The ShadowGeometry object specifies a X3DGeometryNode that should be used for casting a shadow when used in the ShadowCaster node
CH3D::ShadowSphere	The ShadowSphere object specifies a sphere casting a shadow for use in the ShadowCaster node
CH3D::ShadowTransform	The ShadowTransform transforms another H3DShadowObjectNode with the values from the transform field
CH3D::MetadataDouble	The metadata provided by this node is contained in the double-precision floating point numbers of the value field
CH3D::MetadataFloat	The metadata provided by this node is contained in the single-precision floating point numbers of the value field
CH3D::MetadataInteger	The metadata provided by this node is contained in the integers of the value field
CH3D::MetadataSet	The metadata provided by this node is contained in the metadata nodes of the value field
CH3D::MetadataString	The metadata provided by this node is contained in the strings of the value field
CH3D::ShaderChildNode	This is the base node type for the child nodes of the ComposedShader node
CH3D::ShaderPart	The ShaderPart node defines the source for a single object to be used by a ComposedShader node
CH3D::ShaderProgram	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
CH3D::TextureProperties	TextureProperties allows fine control over a texture's application
CH3D::X3DAppearanceChildNode	This is the base node type for the child nodes of the X3DAppearanceNode type
CH3D::X3DAppearanceNode	This is the base node type for all Appearance nodes
►CH3D::X3DChildNode	This abstract node type indicates that the concrete nodes which are instantiated based on it may be used in children, addChildren, and removeChildren fields
CH3D::BooleanFilter	BooleanFilter filters boolean events, allowing for selective routing of TRUE or FALSE values and negation
CH3D::BooleanToggle	BooleanToggle stores a boolean value for toggling on/off
CH3D::ClipPlane	This node defines a single plane equation that will be used to clip the geometry, i.e
CH3D::EaseInEaseOut	The EaseInEaseOut node supports controlled gradual transitions by specifying modifications for TimeSensor node fractions
CH3D::FBODebugger	The FBODebugger node provides a convenient way to check the result of all FrameBufferTextureGenerator nodes in the scene
CH3D::GraphicsHardwareInfo	Information about the graphics hardware the program is being run on and its capabilities
►CH3D::H3DForceEffect	The base class for scenegraph force effects
CH3D::DeviceLog	DeviceLog records haptic device data to a binary data file
CH3D::ForceField	This effect adds a constant force to all haptics devices at all times
CH3D::MagneticGeometryEffect	MagneticGeometryEffect is a localized haptic effect that tries to constrain the haptic device to the surface of the given geometry
CH3D::PositionFunctionEffect	PositionFunctionEffect takes as input three functions that controls the force in x, y and z direction
CH3D::RotationalSpringEffect	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
CH3D::SpringEffect	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
CH3D::TimeFunctionEffect	TimeFunctionEffect takes as input three functions that controls the force in x, y and z direction
CH3D::ViscosityEffect	ViscosityEffect is a localized haptic effect
►CH3D::H3DScriptNode	The base class for script nodes
CH3D::PythonScript	Interface to the dynamic Python library for executing script code as part of the API
CH3D::HAnimHumanoid	The HAnimHumanoid node is a container for the entire humanoid
CH3D::ImageObjectInfo	This node can be used to get information about dimensions, sizes pixel types etc from H3DImageObject nodes such as Image3DTexture
CH3D::ImportLibrary	The ImportLibrary node makes it possible from a X3D file to load a dynamically linked library in order to e.g
CH3D::Inline	The Inline node embeds an X3D scene stored at a location on the World Wide Web into the current scene
CH3D::LocalFog	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
CH3D::MFNodeSplitter	MFNodeSplitter node is used to split MFNode into certain SFNodes yet
CH3D::NvidiaGraphicsOptions	Specifies parameters to use for the NVIDIA graphic settings which normally can also be changed from NVIDIA control panel
CH3D::PlanarReflector	The PlanarReflector defines a geometry which will act as a mirror in the scene
CH3D::ShadowCaster	The ShadowCaster node uses shadow volumes using stencil buffer to cast shadows from objects in a scene
CH3D::TransformInfo	The TransformInfo node provides information about the coordinate space it resides in in the scene graph
CH3D::ViewpointGroup	ViewpointGroup is used to control display of viewpoints on the viewpoint list
►CH3D::X3DBindableNode	X3DBindableNode is the abstract base type for all bindable children nodes, including Background, TextureBackground, Fog, NavigationInfo, Viewpoint and DeviceInfo
CH3D::DeviceInfo	DeviceInfo is a X3DBindableNode that contains the devices that are used with the API
CH3D::Fog	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
CH3D::GlobalSettings	GlobalSettings is a X3DBindableNode that specifies default settings for use in H3D API, such as caching options, haptic rendering options etc
CH3D::NavigationInfo	The NavigationInfo node contains information describing the physical characteristics of the viewer's avatar and viewing model
CH3D::StereoInfo	The StereoInfo nis a bindable node that contains information used when rendering the scene in stereo
►CH3D::X3DBackgroundNode	X3DBackgroundNode is the abstract type from which all backgrounds inherit
CH3D::Background	A background node that uses six static images to compose the backdrop
CH3D::TextureBackground	A background node that uses six individual texture nodes to compose the backdrop
►CH3D::X3DViewpointNode	The X3DViewpointNode node defines a specific location in the local coordinate system from which the user may view the scene
CH3D::OrthoViewpoint	The OrthoViewpoint node defines a viewpoint that provides an orthographic view of the scene
CH3D::Viewpoint	The Viewpoint node defines a viewpoint that provides a perspective view of the scene
CH3D::X3DGeometryNode	This is the base node type for all geometry in X3D
CH3D::X3DGroupingNode	This abstract node type indicates that concrete node types derived from it contain children nodes and is the basis for all aggregation
►CH3D::X3DInfoNode	This is the base node type for all nodes that contain only information without visual semantics
CH3D::WorldInfo	The WorldInfo node contains information about the world
►CH3D::X3DInterpolatorNode	The abstract node X3DInterpolatorNode forms the basis for all types of interpolators specified in this clause
CH3D::ColorInterpolator	This node interpolates among a list of MFColor key values to produce an SFColor (RGB) value_changed event
CH3D::CoordinateInterpolator	This node linearly interpolates among a list of MFVec3f values to produce an MFVec3f value_changed event
CH3D::CoordinateInterpolator2D	This node linearly interpolates among a list of MFVec2f values to produce an MFVec2f value_changed event
CH3D::NormalInterpolator	The NormalInterpolator node interpolates among a list of normal vector sets specified by the keyValue field to produce an MFVec3f value_changed event
CH3D::OrientationInterpolator	The OrientationInterpolator node interpolates among a list of rotation values specified in the keyValue field to produce an SFRotation value_changed event
CH3D::PositionInterpolator	The PositionInterpolator node linearly interpolates among a list of 3D vectors to produce an SFVec3f value_changed event
CH3D::PositionInterpolator2D	The PositionInterpolator node linearly interpolates among a list of 2D vectors to produce an SFVec2f value_changed event
CH3D::ScalarInterpolator	This node linearly interpolates among a list of SFFloat values to produce an SFFloat value_changed event
CH3D::SplinePositionInterpolator	The SplinePositionInterpolator node non-linearly interpolates among a list of 3D vectors to produce an SFVec3f value_changed event
CH3D::SplinePositionInterpolator2D	The SplinePositionInterpolator2D node non-linearly interpolates among a list of 2D vectors to produce an SFVec2f value_changed event
CH3D::SplineScalarInterpolator	The SplineScalarInterpolator node non-linearly interpolates among a list of floats to produce an SFFloat value_changed event
CH3D::X3DLightNode	The X3DLightNode abstract node type is the base type from which all node types that serve as light sources are derived
►CH3D::X3DScriptNode	The base class for script nodes
CH3D::Script	No scripting is supported with the Script node yet
►CH3D::X3DSensorNode	This abstract node type is the base type for all sensors
CH3D::MouseSensor	A sensor node for reading mouse values
CH3D::OculusRiftSensor	This is a X3DSensorNode for reading values from a Oculus Rift HMD
CH3D::RazerHydraSensor	This is a X3DSensorNode for reading values from a Razer hydra sensor
CH3D::SpaceWareSensor	This is a X3DSensorNode for reading values from a 3DConnexion motion controller such as the SpaceTraveller or SpaceMouse 5000
CH3D::SpaceballSensor	A sensor node for reading GLUT Spaceball values
►CH3D::VirtualHandGloveSensor	This is the base class for all sensors that handles connection to the vhtGlove class in Virtual Hand SDK
CH3D::CyberGloveSensor	Connects to a CyberGlove through the Virtual HandSDK
►CH3D::X3DEnvironmentalSensorNode	This abstract node type is the base type for all sensors
CH3D::ProximitySensor	The ProximitySensor node generates events when the viewer enters, exits, and moves within a region in space (defined by a box)
CH3D::VisibilitySensor	The VisibilitySensor node detects visibility changes of a rectangular box as the user navigates the world
►CH3D::X3DKeyDeviceSensorNode	This abstract node type is the base type for all sensor node types which operate using key devices
CH3D::KeySensor	A KeySensor node generates events when the user presses keys on the keyboard
CH3D::StringSensor	A StringSensor node generates events as the user presses keys on the keyboard
►CH3D::X3DNetworkSensorNode	This abstract node type is the basis for all sensors that generate events based on network activity
CH3D::LoadSensor	The LoadSensor monitors the progress and success of downloading URL elements over a network
►CH3D::X3DPointingDeviceSensorNode	This abstract node type is the base type for all pointing device sensors
►CH3D::X3DDragSensorNode	This abstract node type is the base type for all drag-style pointing device sensors
CH3D::CylinderSensor	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
CH3D::PlaneSensor	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
CH3D::SphereSensor	The SphereSensor node maps pointing device motion into spherical rotation about the origin of the local coordinate system
►CH3D::X3DTouchSensorNode	This abstract node type is the base type for all touch-style pointing device sensors
CH3D::TouchSensor	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
►CH3D::X3DSequencerNode	This abstract node type is the base node type from which all Sequencers are derived
CH3D::BooleanSequencer	BooleanSequencer generates sequential SFBool events when driven from a TimeSensor clock
CH3D::IntegerSequencer	The IntegerSequencer node generates sequential discrete SFInt32 events in response to each set_fraction, next, or previous event
CH3D::X3DShapeNode	This is the base node type for all Shape nodes
►CH3D::X3DSoundNode	This abstract node type is the base for all Sound nodes
CH3D::Sound	The Sound node specifies the spatial presentation of a sound in a X3D scene
►CH3D::X3DTimeDependentNode	This abstract node type is the base node type from which all time-dependent nodes are derived
CH3D::TimeSensor	TimeSensor nodes generate events as time passes
►CH3D::X3DSoundSourceNode	This abstract node type is used to derive node types that can emit audio data
►CH3D::AudioClip	An AudioClip node specifies audio data that can be referenced by Sound nodes
CH3D::SimpleAudioClip	SimpleAudioClip is a node for playing audio with a simpler interface than the audio clip node
►CH3D::X3DTriggerNode	This abstract node type is the base node type from which all Triggers are derived
CH3D::BooleanTrigger	BooleanTrigger is a trigger node that generates boolean events upon receiving time events
CH3D::IntegerTrigger	IntegerTrigger handles single field Boolean events to set an integer value for the output event
CH3D::TimeTrigger	TimeTrigger is a trigger node that generates time events upon receiving boolean events
►CH3D::X3DFontStyleNode	This abstract node type is the base node type for all FontStyle nodes
CH3D::FontStyle	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
►CH3D::X3DGeometricPropertyNode	This is the base node type for all geometric property node types defined in X3D
CH3D::FogCoordinate	This node defines a set of explicit fog depths on a per-vertex basis
CH3D::HAnimDisplacer	Applications may need to alter the shape of individual segments
CH3D::NurbsTextureCoordinate	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
CH3D::X3DColorNode	This is the base node type for color specifications in X3D
CH3D::X3DCoordinateNode	This is the base node type for all coordinate node types in X3D
CH3D::X3DNormalNode	This is the base node type for all normal node types in X3D
CH3D::X3DTextureCoordinateNode	This abstract node type is the base type for all node types which specify texture coordinates
CH3D::X3DVertexAttributeNode	This abstract node type is the base type for all node types that specify per-vertex attribute information to the shader
►CH3D::X3DNurbsControlCurveNode	This abstract node type is the base type for all node types that provide control curve information in 2D space
CH3D::ContourPolyline2D	The ContourPolyline2D node defines a piecewise linear curve segment as a part of a trimming contour in the u,v domain of a surface
CH3D::NurbsCurve2D	The NurbsCurve2D node defines a trimming segment that is part of a trimming contour in the u,v domain of the surface
►CH3D::X3DParticleEmitterNode	The X3DParticleEmitterNode abstract type represents any node that is an emitter of particles
CH3D::ConeEmitter	The ConeEmitter node is an emitter that generates all the available particles from a specific point in space
CH3D::ExplosionEmitter	The ExplosionEmitter node is an emitter that generates all the available particles from a specific point in space at the initial time
CH3D::PointEmitter	The PointEmitter node is an emitter that generates particles from a specific point in space
CH3D::SurfaceEmitter	The SurfaceEmitter node is an emitter that generates particles from the surface of an object
►CH3D::X3DParticlePhysicsModelNode	The X3DParticlePhysicsModelNode is the abstract representation of any node that will apply a form of constraints on the particles after they have been generated
CH3D::BoundedPhysicsModel	The BoundedPhysicsModel node specifies a physics model that applies a user-defined set of geometrical bounds to the particles
CH3D::GravityPhysicsModel	The GravityPhysicsModel node specifies a physics model that applies a constant gravity value to the particles
CH3D::WindPhysicsModel	The WindPhysicsModel node specifies a physics model that applies a wind effect to the particles
CH3D::X3DPrototypeInstance	This abstract node type is the base type for all prototype instances in the X3D system
CH3D::ProtoDeclaration	Information about a PROTO node from the X3D standard
►CH3DUtil::ResourceResolver [external]
CH3D::LibCurlResolver	The LibCurlResolver uses libcurl to resolve URLs using e.g
►CH3DUtil::RGB [external]
CH3D::PyTypeWrapper< RGB, &PyRGB_Type, PyRGB_Name, PyRGB_Check, PyRGB_AsRGB, PyRGB_FromRGB >
►CH3DUtil::RGBA [external]
CH3D::PyTypeWrapper< RGBA, &PyRGBA_Type, PyRGBA_Name, PyRGBA_Check, PyRGBA_AsRGBA, PyRGBA_FromRGBA >
CH3D::Box::SFBound	SFBound is specialized update itself from the size field of the Box node
CH3D::Capsule::SFBound	SFBound is specialized update itself from the radius and heigh field of the Capsule node
CH3D::Cone::SFBound	SFBound is specialized update itself from the radius and heigh field of the Cone node
CH3D::Cylinder::SFBound	SFBound is specialized update itself from the radius and heigh field of the Cylinder node
CH3D::Rectangle2D::SFBound	SFBound is specialized update itself from the size field of the Rectangle2D node
►CH3D::SFieldClass	Base class for all fields created with the SField template
►CH3D::SField< Matrix3d >
CH3D::SFMatrix3d	The SFMatrix3d field contains a Matrix3d
►CH3D::SField< RGBA >
CH3D::SFColorRGBA	The SFColorRGBA field contains one RGBA (red-green-blue-alpha) colour 4-tuple
►CH3D::SField< RGB >
►CH3D::SFColor	The SFColor field contains one RGB (red-green-blue) colour triple
►CH3D::TypedField< SFColor, Types< SFFloat, MFFloat, MFColor > >
CH3D::ColorInterpolator::SFValue	The SFValue field updates the interpolated value from the fields routed to it
►CH3D::SField< Matrix4d >
CH3D::SFMatrix4d	The SFMatrix4d field contains a Matrix4d
►CH3D::SField< H3DFloat >
►CH3D::SFFloat	The SFFloat field contains one single-precision floating point number
►CH3D::OnValueChangeSField< SFFloat >
►CH3D::AutoUpdate< OnValueChangeSField< SFFloat > >
CH3D::H3DFrictionalSurfaceNode::UpdateDynamicFriction	Specialized field which sets the dynamic_friction variable in H3DFrictionalSurfaceNode when the dynamicFriction field of H3DFrictonalSurface is changed
CH3D::H3DFrictionalSurfaceNode::UpdateStaticFriction	Specialized field which sets the static_friction variable in H3DFrictionalSurfaceNode when the staticFriction field of H3DFrictionalSurfaceNode is changed
CH3D::H3DStiffnessSurfaceNode::UpdateDamping	Specialized field which sets the damping variable in H3DStiffnessSurfaceNode when the damping field of H3DStiffnessSurfaceNode is changed
CH3D::H3DStiffnessSurfaceNode::UpdateStiffness	Specialized field which sets the stiffness variable in H3DStiffnessSurfaceNode when the stiffness field of H3DStiffnessSurfaceNode is changed
CH3D::HapticTexturesSurface::UpdateMinMaxParamValue	Field class used to set the min and max values of the different parameters in the HAPISurfaceObject
CH3D::MagneticSurface::UpdateDamping	Specialized field which sets the damping variable in HAPI::OpenHapticsRenderer::OpenHapticsSurface when the damping field of MagneticSurface is changed
CH3D::MagneticSurface::UpdateDynamicFriction	Specialized field which sets the dynamic_friction variable in HAPI::OpenHapticsRenderer::OpenHapticsSurface when the dynamicFriction field of MagneticSurface is changed
CH3D::MagneticSurface::UpdateSnapDistance	Specialized field which sets the snap_distance variable in HAPI::OpenHapticsRenderer::OpenHapticsSurface when the snapDistance field of MagneticSurface is changed
CH3D::MagneticSurface::UpdateStaticFriction	Specialized field which sets the static_friction variable in HAPI::OpenHapticsRenderer::OpenHapticsSurface when the staticFriction field of MagneticSurface is changed
CH3D::MagneticSurface::UpdateStiffness	Specialized field which sets the stiffness variable in HAPI::OpenHapticsRenderer::OpenHapticsSurface when the stiffness field of SmoothSurface is changed
CH3D::ForceDimensionDevice::EffectorMass	EffectorMass specializes SFFloat to change the end effector mass at change of value
CH3D::RuspiniRenderer::ProxyRadius	ProxyRadius specializes SFFloat to set the proxy radius in the HAPI::RuspiniRenderer used
►CH3D::TypedField< SFFloat, Types< SFFloat, MFFloat, MFVec2f > >
CH3D::EaseInEaseOut::SFFraction	Class for modified fraction_changed field type
►CH3D::TypedField< SFFloat, Types< SFFloat, MFFloat, MFFloat, MFFloat > >
CH3D::SplineScalarInterpolator::SFValue	The SFValue field updates the interpolated value from the fields routed to it
►CH3D::TypedField< SFFloat, Types< SFFloat, MFFloat, MFFloat > >
CH3D::ScalarInterpolator::SFValue	The SFValue field updates the interpolated value from the fields routed to it
CH3D::CylinderSensor::CheckAngleLimits	The CheckAngleLimits field checks that the float is in the correct range
►CH3D::SField< string >
►CH3D::SFString	The SFString field contains a string
►CH3D::AutoUpdate< SFString >
►CH3D::OnNewValueSField< AutoUpdate< SFString > >
CH3D::X3DTextureNode::UpdateSaveToURL	A field used to execute the save to URL operation when the URL is set
CH3D::FBODebugger::UpdateSaveToURL	A field used to execute the save to URL operation when the URL is set
►CH3D::OnValueChangeSField< SFString >
CH3D::OpenHapticsRenderer::ShapeType	ShapeType specializes SFString to set the appropriate default OpenHaptics shape in the HAPI::OpenHapticsRenderer
►CH3D::TypedField< SFString, MFString >
CH3D::X3DScriptNode::SFScriptString	Update the string to use as script depending from the urls given
CH3D::H3DWindowNode::RenderMode	The mode for rendering specified as a string
►CH3D::SField< Matrix3f >
CH3D::SFMatrix3f	The SFMatrix3f field contains a Matrix3f
►CH3D::SField< Matrix4f >
►CH3D::SFMatrix4f	The SFMatrix4f field contains a Matrix4f
►CH3D::TypedField< H3D::SFMatrix4f, Types< SFVec3f, SFRotation, SFVec3f, SFRotation, SFVec3f > >
CH3D::Transform::Matrix	Specialize the SFMatrix4f to update the matrix from the fields in the Transform node
►CH3D::TypedField< H3D::SFMatrix4f, Types< SFVec3f, SFVec3f, SFVec3f > >
CH3D::Billboard::SFMatrix4f	Specialize the SFMatrix4f to update the matrix from the fields in the Billboard node
►CH3D::TypedField< MatrixTransform::SFMatrix4f, Types< SFVec3f, SFVec3f, SFBound, SFBool, SFBool > >
CH3D::FitToBoxTransform::SFMatrix4f	We specialize the SFMatrix4f field to that update itself from a SFBound field and two SFVec3f fields
►CH3D::TypedField< H3D::SFMatrix4f, Types< SFRotation, SFVec3f > >
CH3D::DynamicTransform::SFMatrix4f	Specialize the SFMatrix4f to update the matrix from the fields in the Transform node
►CH3D::SField< Vec2f >
►CH3D::SFVec2f	The SFVec2f field contains a Vec2f
►CH3D::TypedField< SFVec2f, Types< SFFloat, MFFloat, MFVec2f, MFVec2f > >
CH3D::SplinePositionInterpolator2D::SFValue	The SFValue field updates the interpolated value from the fields routed to it
►CH3D::TypedField< SFVec2f, Types< SFFloat, MFFloat, MFVec2f > >
CH3D::PositionInterpolator2D::SFValue	The SFValue field updates the interpolated value from the fields routed to it
►CH3D::SField< Vec3f >
►CH3D::SFVec3f	The SFVec3f field contains a Vec3f
►CH3D::AutoUpdate< SFVec3f >
►CH3D::OnValueChangeSField< AutoUpdate< SFVec3f > >
CH3D::PlaneSensor::SFOffset	Class used to store some information about axisRotation when offset is set, in order to set the correct offset value when mouse is clicked
CH3D::SpaceWareSensor::AccumulateTranslation	This class is an AutoUpdate class that accumulates the Vec3f values routed to it, i.e
CH3D::SpaceWareSensor::ResetAccumulatedTranslation	This class is an AutoUpdate class that sets the field accumulatedTranslation to its input value
►CH3D::TypedField< SFVec3f, Types< SFFloat, SFVec3f > >
CH3D::DynamicTransform::SFVelocity	Calculates the velocity based on the mass and momentum
►CH3D::TypedField< SFVec3f, SFBoxBound, SFMatrix4f >
CH3D::TransformedBoxBound::Center	The Center field updates itself from the boxBound and matrix fields
CH3D::TransformedBoxBound::Size	The Size field updates itself from the boxBound and matrix fields
►CH3D::TypedField< SFVec3f, Types< SFMatrix3f, SFVec3f > >
CH3D::DynamicTransform::SFAngularVelocity	Calculates the angular velocity based on the inertia tensor and angular momentum
►CH3D::TypedField< SFVec3f, Types< SFMatrix4f, SFVec3f > >
CH3D::H3DHapticsDevice::TrackerPosition	The TrackerPosition field updates itself from the devicePosition and positionCalibration fields
CH3D::H3DHapticsDevice::TrackerVelocity	The TrackerVelocity field updates itself from the deviceVelocity and positionCalibration fields
►CH3D::TypedField< SFVec3f, Types< SFPosition, SFVec3f > >
CH3D::X3DViewpointNode::SFSumVec3f	This field sums the value of the two SFVec3f routed to it
►CH3D::TypedField< SFVec3f, Types< SFVec3f, SFFloat > >
CH3D::SpaceWareSensor::ScaleTranslation	Updates itself to the SFVec3f routed to it scaled by the scale factor
►CH3D::TypedField< SFVec3f, Types< SFVec3f, SFVec3f, SFFloat > >
CH3D::H3DHapticsDevice::WeightedProxy	The WeightedProxy field updates to be a value between the proxy position and tracker position depending on the value of a weighting factor
►CH3D::TypedField< H3D::SFVec3f, Types< SFTime > >
CH3D::DynamicTransform::SFMotion	Time dependant field to perform the RK4 integration for determining the motion of the dynamic transform routes_in[0] time field
►CH3D::TypedField< SFVec3f, Types< SFRotation, SFVec3f > >
CH3D::H3DHapticsDevice::TrackerAngularVelocity	The TrackerAngularVelocity field updates itself from the deviceAngularVelocity and orientationCalibration fields
►CH3D::TypedField< SFVec3f, Types< SFFloat, MFFloat, MFVec3f > >
CH3D::PositionInterpolator::SFValue	The SFValue field updates the interpolated value from the fields routed to it
►CH3D::TypedField< SFVec3f, Types< SFFloat, MFFloat, MFVec3f, MFVec3f > >
CH3D::SplinePositionInterpolator::SFValue	The SFValue field updates the interpolated value from the fields routed to it
CH3D::X3DViewpointNode::SFPosition	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
►CH3D::SField< Vec4f >
CH3D::SFVec4f	The SFVec4f field contains a Vec4f
►CH3D::SField< Vec2d >
CH3D::SFVec2d	The SFVec2d field contains a Vec2d
►CH3D::SField< H3DDouble >
►CH3D::SFDouble	The SFDouble field contains one high-precision floating point number
►CH3D::OnValueChangeSField< SFDouble >
CH3D::GodObjectRenderer::MinDistance	MinDistance specializes SFDouble to set the minimum distance between the surface and the proxy in GodObjectRenderer
►CH3D::TypedField< SFDouble, void, AnyNumber< SFTime > >
►CH3D::SFTime	The SFTime field contains a single time value
►CH3D::AutoUpdate< SFTime >
►CH3D::OnNewValueSField< AutoUpdate< SFTime > >
CH3D::PlaybackDevice::OnSeekToTime	A field used to move playback to a specified time
►CH3D::X3DTimeDependentNode::TimeHandler	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
CH3D::TimeSensor::TimeHandler	The TimeHandler field is specialized to include the handling of the TimeSensor specific fields
CH3D::X3DSoundSourceNode::TimeHandler	TimeHandler is extended to stream audio data to OpenAL buffers if the sound source is a streaming source
CH3D::PeriodicUpdate< SFTime >
CH3D::X3DTimeDependentNode::StartTime	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
CH3D::X3DTimeDependentNode::StopTime	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
►CH3D::TypedField< SFDouble, MFDouble >
CH3D::H3DFunctionNode::Value	Field class that calculates the function value for the given input
►CH3D::SField< bool >
►CH3D::SFBool	The SFBool field contains a single boolean value
►CH3D::AutoUpdate< SFBool >
►CH3D::OnNewValueSField< AutoUpdate< SFBool > >
CH3D::PlaybackDevice::OnPlay	A field used to start and stop playback
►CH3D::TypedField< AutoUpdate< SFBool >, Types< SFBool, SFBool, SFBool, SFBool, MFString, SFFloat, SFTime > >
CH3D::SimpleMovieTexture::DecoderManager	Manages all state changes in the decoder depending on the values of the fields in SimpleMovieTexture
CH3D::TypedField< AutoUpdate< SFBool >, Types< SFBool, SFBool, SFBool, MFString, SFBool > >
CH3D::BooleanFilter::SetBoolean	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
CH3D::BooleanToggle::SetBoolean	Specialize to negate the value of the toggle field if a true event is given
CH3D::ProximitySensor::SetTime	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
CH3D::VisibilitySensor::SetTime	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
CH3D::X3DBindableNode::SFSetBind	The SFSetBind field calls toStackTop() and removeFromStack() on the X3DBindableNode it is in depending on the value that it is set to
►CH3D::OnNewValueSField< SFBool >
►CH3D::AutoUpdate< OnNewValueSField< SFBool > >
CH3D::ClutchedDevice::ResetClutchOrientation	If True, resets the orientation offset due to clutching
CH3D::ClutchedDevice::ResetClutchPosition	If True, resets the position offset due to clutching
CH3D::OculusRiftSensor::RecenterTrackingField	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
CH3D::ForceDimensionDevice::Reset	Reset specializes SFBool to go into reset mode when a true event is received
CH3D::ForceDimensionDevice::SFAutoCalibrate	SFAutoCalibrate specializes SFBool to go into auto calibrate mode when a true event is received
CH3D::ForceDimensionDevice::WaitReset	WaitReset specializes SFBool to go into wait on reset mode when a true event is received
►CH3D::OnValueChangeSField< SFBool >
►CH3D::AutoUpdate< OnValueChangeSField< SFBool > >
CH3D::ClutchedDevice::EnableClutch	Enables/Disbles the clutching
CH3D::EntactDevice::Calibrate	Field class that calibrates the device when a true event is received or the field is set to true
CH3D::OpenHapticsSurface::UpdateMagnetic	Specialized field which sets the magnetic variable in HAPI::OpenHapticsRenderer::OpenHapticsSurface when the magnetic field of OpenHapticsSurface is changed
CH3D::PhantomDevice::Calibrate	Field class that calibrates the device when a true event is received or the field is set to true
CH3D::ComposedShader::UpdateCache	Event collection field to update when global caching is update
CH3D::ForceDimensionDevice::Brakes	Brakes specializes SFBool to toggle brakes on and off
CH3D::ForceDimensionDevice::EnableForce	EnableForce specializes SFBool to toggle forces on and off
CH3D::ForceDimensionDevice::GravityComp	GravityComp specializes SFBool to toggle gravity compensation on and off
CH3D::GodObjectRenderer::EnableSecondaryCollisions	EnableSecondaryCollisions specializes SFBool to set the value determining whether to enable secondary collisions when calculating proxy position
CH3D::H3DHapticsDevice::SetEnabled	SetEnabled specializes SFBool to go into reset mode when a true event is received
CH3D::OpenHapticsRenderer::AdaptiveViewport	AdaptiveViewport specializes SFBool to set the appropriate default values in the HAPI::OpenHapticsRenderer used
CH3D::OpenHapticsRenderer::CameraView	CameraView specializes SFBool to set the appropriate default values in the HAPI::OpenHapticsRenderer used
CH3D::PeriodicUpdate< SFBool >
CH3D::TypedField< SFBool, Types< SFBool, SFVec3f > >
►CH3D::TypedField< SFBool, SFInt32 >
CH3D::FrameBufferTextureGenerator::NeedMultiSample	Specialized field class used to check if multi sample support is needed
►CH3D::TypedField< SFBool, void, AnyNumber< Field > >
CH3D::H3DGeneratedShaderNode::RebuildShader	Specialized field that rebuilds the shader when it updates
►CH3D::TypedField< SFBool, Types< SFInt32, SFInt32 > >
CH3D::H3DWindowNode::WindowSizeChanged	Class which handles the windows resizing related operations
►CH3D::TypedField< SFBool, Types< Any< SFString, MFString > > >
CH3D::FrameBufferTextureGenerator::ResetPrintedFlag	A field used to reset the waning printed flag
►CH3D::TypedField< SFBool, SFTime >
►CH3D::AutoUpdate< TypedField< SFBool, SFTime > >
CH3D::H3DDisplayListObject::DisplayList::IsActive	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
CH3D::BooleanTrigger::SetBoolean	If a time event is given, generate a true event
CH3D::BooleanFilter::NegateSFBool	This field class takes as input SFBool fields and sets its value to the negated value of the input field
►CH3D::SField< Vec3d >
►CH3D::SFVec3d	The SFVec3d field contains a Vec3d
►CH3D::OnNewValueSField< SFVec3d >
CH3D::ForceDimensionDevice::SFReleasePosition	SFReleasePosition specializes SFVec3d to go set the release position of the contained haptics device
►CH3D::SField< Vec4d >
►CH3D::SFVec4d	The SFVec4d field contains a Vec4d
►CH3D::TypedField< SFVec4d, Types< SFVec3f, SFVec3f > >
CH3D::PointNormalClipPlane::PlaneEq	The PlaneEq updates the plane equation from the values of the point and normal fields
►CH3D::SField< Quaternion >
►CH3D::SFQuaternion	The SFQuaternion field contains a Quaternion
►CH3D::TypedField< SFQuaternion, Types< SFVec3f, SFRotation > >
CH3D::DynamicTransform::SFSpin	Calculates the spin (time derivative of the orientation)
►CH3D::SField< H3DInt32 >
►CH3D::SFInt32	The SFInt32 field contains one 32-bit integer
CH3D::OnValueChangeSField< SFInt32 >
CH3D::FrameBufferTextureGenerator::GetNrSamples	Specialized field class used to get the number of samples that can and will be used
►CH3D::SField< Rotation >
►CH3D::SFRotation	The SFRotation field contains one arbitrary Rotation
►CH3D::AutoUpdate< SFRotation >
CH3D::SpaceWareSensor::AccumulateRotation	This class is an AutoUpdate class that accumulates the rotation values routed to it, i.e
CH3D::SpaceWareSensor::ResetAccumulatedRotation	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
►CH3D::TypedField< SFRotation, Types< SFFloat, MFFloat, MFRotation > >
CH3D::OrientationInterpolator::SFValue	The SFValue field updates the interpolated value from the fields routed to it
►CH3D::TypedField< SFRotation, Types< SFRotation, SFFloat > >
CH3D::SpaceWareSensor::ScaleRotation	Updates itself to the Rotation routed to it where the angle is scaled by the scale factor
►CH3D::TypedField< SFRotation, Types< SFOrientation, SFRotation > >
CH3D::X3DViewpointNode::SFSumRotation	This field sums the value of the two SFRotation routed to it
►CH3D::TypedField< SFRotation, Types< SFRotation, SFRotation > >
CH3D::H3DHapticsDevice::TrackerOrientation	The TrackerOrientation field updates itself from the deviceOrientation and orientationCalibration fields
CH3D::X3DViewpointNode::SFOrientation	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
CH3D::SField< Type >	Template class that adds the Field mechanisms to an encapsulated value of specified type
CH3D::SFUniform< SF >	Template class to provide value change checking after update for SField
CH3D::ImageTexture::SharedImage	A shared texture
Cyy::slice< T, S >	Present a slice of the top of a stack
CH3D::SpiderMonkeySAI	Implementation of the X3D Ecmascript SAI specification using SpiderMonkey(the Javascript engine used by Firefox)
CH3D::Image3DTexture::SFImage::ThreadFuncData	Struct for storing input needed to the thread function
CH3D::ImageTexture::SFImage::ThreadFuncData	Struct for storing input needed to the thread function
Cyy::VrmlParser::token	Tokens
CH3D::TraverseInfo	TraverseInfo is a structure that is passed along when traversing the scene graph
►CH3D::TypedField< BaseField, RequiredArgTypes, OptionalArgTypes >	A template modifier class for adding type checking on the routes to any Field class
►CH3D::AutoUpdate< TypedField< SFTime, SFBool > >
CH3D::TimeTrigger::SetTriggerTime	Specialize to set the vaule of the triggerTime field to the current time
CH3D::AutoUpdate< TypedField< SFBool, Types< SFVec3f, SFRotation, SFRotation > > >
►CH3D::AutoUpdate< TypedField< SFInt32, SFBool > >
CH3D::IntegerTrigger::SetTriggerValue	Specialize to set the vaule of the triggerValue field to the value of the field integerKey
►CH3D::AutoUpdate< TypedField< SFBool, SFBool > >
CH3D::X3DTouchSensorNode::SetTouchTime	Specialize field to generate a touchTime event
►CH3D::AutoUpdate< TypedField< SFBool, H3DImageObject::SFImage, AnyNumber< H3DImageObject::SFImage > > >
CH3D::HapticTexturesSurface::SetImagePtr	Field class used to transfer the routed image to the HAPISurfaceObject
►CH3D::AutoUpdate< TypedField< TheType, Types< SFBool, SFBool, SFFloat > > >
CH3D::X3DSequencerNode::ValueChanged< TheType, KeyValuesIn, SequencerClass >	ValueChanged is a specialized class used to evaluate and set the value_changed field depending on the input to the class
►CH3D::AutoUpdate< TypedField< SFBool, Types< X3DTexture2DNode::SFImage > > >
CH3D::DepthMapSurface::SetImagePtr	Field used to transfer the routed image to the HAPISurfaceObject
CH3D::MFieldBase< Vec3f, std::vector< Vec3f >, ParsableMField >
CH3D::MFieldBase< Vec3d, std::vector< Vec3d >, ParsableMField >
CH3D::MFieldBase< string, std::vector< string >, ParsableMField >
CH3D::MFieldBase< Quaternion, std::vector< Quaternion >, ParsableMField >
CH3D::MFieldBase< RGBA, std::vector< RGBA >, ParsableMField >
CH3D::MFieldBase< bool, std::vector< bool >, ParsableMField >
CH3D::MFieldBase< Matrix4f, std::vector< Matrix4f >, ParsableMField >
CH3D::MFieldBase< RefClass *, FieldInternals::MFNodeAutoRefVector< RefClass >, Field >
CH3D::MFieldBase< Node *, FieldInternals::MFNodeAutoRefVector< Node >, Field >
CH3D::MFieldBase< Matrix4d, std::vector< Matrix4d >, ParsableMField >
CH3D::MFieldBase< Matrix3d, std::vector< Matrix3d >, ParsableMField >
CH3D::MFieldBase< Vec4f, std::vector< Vec4f >, ParsableMField >
CH3D::MFieldBase< Vec4d, std::vector< Vec4d >, ParsableMField >
CH3D::MFieldBase< Vec2f, std::vector< Vec2f >, ParsableMField >
CH3D::MFieldBase< Vec2d, std::vector< Vec2d >, ParsableMField >
CH3D::MFieldBase< Rotation, std::vector< Rotation >, ParsableMField >
CH3D::MFieldBase< RGB, std::vector< RGB >, ParsableMField >
CH3D::MFieldBase< H3DFloat, std::vector< H3DFloat >, ParsableMField >
CH3D::MFieldBase< Matrix3f, std::vector< Matrix3f >, ParsableMField >
CH3D::MFieldBase< H3DInt32, std::vector< H3DInt32 >, ParsableMField >
CH3D::MFieldBase< H3DDouble, std::vector< H3DDouble >, ParsableMField >
CH3D::PeriodicUpdate< TypedField< SFBool, Types< SFFloat, SFFloat > > >
CH3D::PeriodicUpdate< TypedField< Field, Types< SFFontStyleNode, MFString > > >
CH3D::SField< Matrix3d >
CH3D::SField< RGBA >
CH3D::SField< RGB >
CH3D::SField< Matrix4d >
CH3D::SField< H3DFloat >
CH3D::SField< string >
CH3D::SField< Matrix3f >
CH3D::SField< Matrix4f >
CH3D::SField< Vec2f >
CH3D::SField< Vec3f >
CH3D::SField< Vec4f >
CH3D::SField< Vec2d >
CH3D::SField< H3DDouble >
CH3D::SField< bool >
CH3D::SField< Vec3d >
CH3D::SField< Vec4d >
CH3D::SField< Quaternion >
CH3D::SField< H3DInt32 >
CH3D::SField< Rotation >
►CH3D::TypedField< GetValueSafeField< SFBool >, Types< SFInt32 > >
CH3D::SpaceWareHapticsDevice::SetMainButton	SetMainButton is set to true if any of the buttons on the SpaceWare device is pressed
►CH3D::TypedField< MFVertexAttributeNode, Types< SFBool, SFCoordinateNode, MFInt32, SFTextureCoordinateNode > >
CH3D::IndexedTriangleSet::AutoTangent	Specialized field for automatically generating two FloatVertexAttribute nodes representing the tangent and binormal of each vertex(or face if normalPerVertex is false)
►CH3D::TypedField< MFVertexAttributeNode, Types< SFBool, SFCoordinateNode, MFInt32, SFTextureCoordinateNode, MFInt32, SFFloat, SFBool > >
CH3D::IndexedFaceSet::AutoTangent	Specialized field for automatically generating two FloatVertexAttribute nodes representing the tangent and binormal of each vertex(or face if normalPerVertex is false)
►CH3D::TypedField< SFBound, Types< SFMatrix4f, SFBound > >
CH3D::MatrixTransform::SFTransformedBound	SFTransformedBound maintains the routes from the owner Node's bound and matrix field to the contained TransformedBoxBound instance's boxBound and matrix field
►CH3D::TypedField< SFNormalNode, Types< SFBool, SFCoordinateNode, MFInt32, SFBool > >
CH3D::IndexedTriangleFanSet::AutoNormal	Specialized field for automatically generating normals from coordinates
CH3D::IndexedTriangleSet::AutoNormal	Specialized field for automatically generating normals from coordinates
CH3D::IndexedTriangleStripSet::AutoNormal	Specialized field for automatically generating normals from coordinates
CH3D::TriangleFanSet::AutoNormal	Specialized field for automatically generating normals from coordinates
CH3D::TriangleStripSet::AutoNormal	Specialized field for automatically generating normals from coordinates
►CH3D::TypedField< SFNormalNode, Types< SFBool, SFCoordinateNode, MFInt32, SFBool, SFFloat > >
CH3D::IndexedFaceSet::AutoNormal	Specialized field for automatically generating normals from coordinates
►CH3D::TypedField< SFNormalNode, Types< SFBool, SFCoordinateNode, SFBool > >
CH3D::TriangleSet::AutoNormal	Specialized field for automatically generating normals from coordinates
►CH3D::TypedField< SFNormalNode, Types< SFBool, SFInt32, SFInt32, SFFloat, SFFloat, MFFloat, SFBool, SFFloat > >
CH3D::ElevationGrid::AutoNormal	Specialized field for automatically generating normals from coordinates
►CH3D::TypedField< SFNormalNode, Types< VertexVector, SFFloat, SFBool, SFBool > >
CH3D::Extrusion::AutoNormal	Specialized field for automatically generating normals from coordinates
►CH3D::TypedField< X3DBoundedObject::SFBound, SFCoordinateNode >
CH3D::NurbsCurve::SFBound	SFBound is specialized to update from the SFBound fields routed to it
►CH3D::TypedField< X3DBoundedObject::SFBound, void, AnyNumber< X3DBoundedObject::SFBound > >
CH3D::GeometryGroup::SFBound	SFBound is specialized to update from the SFBound fields routed to it
CH3D::Inline::SFBound	SFBound is specialized to update from the SFBound fields routed to it
►CH3D::X3DGroupingNode::SFBound	SFBound is specialized to update from the SFBound fields routed to it
►CH3D::TypedField< X3DGroupingNode::SFBound, SFInt32, AnyNumber< X3DBoundedObject::SFBound > >
CH3D::Switch::SFBound	SFBound is specialized to update from the SFBound fields routed to it
►CH3D::TypedField< X3DGeometryNode::SFBound, MFVec2f >
CH3D::Polyline2D::SFBound	SFBound is specialized update itself from the lineSegments field of the Polyline2D node
CH3D::Polypoint2D::SFBound	SFBound is specialized update itself from the point field of the Polypoint2D node
CH3D::TriangleSet2D::SFBound	SFBound is specialized update itself from the vertices field of the TriangleSet2D node
►CH3D::TypedField< X3DGeometryNode::SFBound, SFFloat >
CH3D::Arc2D::SFBound	SFBound is specialized update itself from the radius field of the Box node
CH3D::ArcClose2D::SFBound	SFBound is specialized update itself from the radius field of the Box node
CH3D::Circle2D::SFBound	SFBound is specialized update itself from the radius field of the Circle2D node
CH3D::Disk2D::SFBound	SFBound is specialized update itself from the radius field of the Box node
CH3D::Sphere::SFBound	SFBound is specialized update itself from the radius field of the Sphere node
►CH3D::TypedField< X3DGeometryNode::SFBound, Types< MFVec3f > >
CH3D::Extrusion::SFBound	SFBound is specialized update itself from the fields of the Extrusion
►CH3D::TypedField< X3DGeometryNode::SFBound, Types< SFCyberGloveSensor, SFFloat, SFVec3f > >
CH3D::HumanHand::SFBound	Update geometric bounds of the HumanHand
►CH3D::TypedField< X3DGeometryNode::SFBound, Types< SFFontStyleNode, MFFloat, SFFloat, MFString > >
CH3D::Text::SFBound	The SFBound field is specialized to update itself from the values in the fields of the Text node
►CH3D::TypedField< X3DGeometryNode::SFBound, Types< SFInt32, SFInt32, SFFloat, SFFloat, MFFloat > >
CH3D::ElevationGrid::SFBound	SFBound is specialized update itself from the fields of the ElevationGrid
CH3D::TypedRefCountField< RefCountedType, BaseRefCountType >	Template to make sure that the Node that is set in a SFNode is of a specified Node type
CH3D::H3DNodeDatabase::TypeInfoWrapper	Wrapper class to be able to put type_info as a key in a map
CH3D::TypedFieldTypeCheck::Types< H3D_TYPES_TEMPLATE_SPEC >	The Types template can be used in the RequiredArgTypes or OptionalArgTypes arguments of a TypedField template instantiation
CH3D::H3DGeneratedShaderNode::VaryingVariable	Struct used to define a varying variable in the shader
Cyy::VrmlParser	A Bison parser
►CH3D::X3DFogObject	X3DFogObject is the abstract type that describes a node that influences the lighting equation through the use of fog semantics
CH3D::Fog	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
CH3D::LocalFog	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
►CH3D::X3DMetadataObject	This abstract interface is the basis for all metadata nodes
CH3D::MetadataDouble	The metadata provided by this node is contained in the double-precision floating point numbers of the value field
CH3D::MetadataFloat	The metadata provided by this node is contained in the single-precision floating point numbers of the value field
CH3D::MetadataInteger	The metadata provided by this node is contained in the integers of the value field
CH3D::MetadataSet	The metadata provided by this node is contained in the metadata nodes of the value field
CH3D::MetadataString	The metadata provided by this node is contained in the strings of the value field
CH3D::X3D::X3DSAX2Handlers	This class implements the SAX2 ContentHandler and ErrorHandler interface in order to build an H3D scenegraph from a X3D XML file
►CH3D::X3DUrlObject	This abstract interface is inherited by all nodes that contain data located on the World Wide Web, such as AudioClip, ImageTexture and Inline
CH3D::AudioClip	An AudioClip node specifies audio data that can be referenced by Sound nodes
CH3D::DeviceLog	DeviceLog records haptic device data to a binary data file
CH3D::H3DScriptNode	The base class for script nodes
CH3D::Image3DTexture	The Image3DTexture node defines a texture map by specifying a single file that contains complete 3D data and general parameters for mapping to geometry
CH3D::ImageTexture	The ImageTexture node defines a texture map by specifying an image file and general parameters for mapping to geometry
CH3D::ImportLibrary	The ImportLibrary node makes it possible from a X3D file to load a dynamically linked library in order to e.g
CH3D::Inline	The Inline node embeds an X3D scene stored at a location on the World Wide Web into the current scene
CH3D::PackagedShader	A PackagedShader node describes a single file that may contain a number of shaders and combined effects
CH3D::PlaybackDevice	A PlaybackDevice is a fake haptics device node that can play back device values previously recorded using the DeviceLog node
CH3D::ShaderPart	The ShaderPart node defines the source for a single object to be used by a ComposedShader node
CH3D::ShaderProgram	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
CH3D::SimpleMovieTexture	SimpleMovieTexture is a node for showing movies as textures with a simpler interface than the movie texture node
CH3D::X3DScriptNode	The base class for script nodes