| H3D::TypedFieldTypeCheck::Any<> | The Any template can be used in the RequiredArgTypes or OptionalArgTypes arguments of a TypedField template instantiation |
| H3D::TypedFieldTypeCheck::AnyNumber< Type > | The AnyNumber template can be used in the OptionalArgTypes argument of a TypedField template instantiation |
| H3D::Appearance | The Appearance node specifies the visual properties of geometry |
| H3D::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 |
| H3D::Arc2D::SFBound | SFBound is specialized update itself from the radius field of the Box node |
| H3D::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 |
| H3D::ArcClose2D::SFBound | SFBound is specialized update itself from the radius field of the Box node |
| H3D::AudioClip | An AudioClip node specifies audio data that can be referenced by Sound nodes |
| H3D::AutoPtrVector< PtrType > | This class is similar to the auto_ptr class in the vector elements are Node * or pointers to subclasses of Node |
| H3D::AutoRef< NodeType > | The AutoRef class is similar to the auto_ptr class, but it requires that the pointer to Node or a subclass of Node |
| H3D::AutoRefVector< NodeClass > | This class is similar to the AutoRef class in the vector elements are Node * or pointers to subclasses of Node |
| H3D::AutoUpdate< BaseFieldType > | The AutoUpdate field is a template to force the BaseField to update itself as soon as an event is received |
| H3D::Background | A background node that uses six static images to compose the backdrop |
| H3D::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 |
| H3D::Billboard::SFMatrix4f | Specialize the SFMatrix4f to update the matrix from the fields in the Billboard node |
| H3D::BooleanFilter | BooleanFilter filters boolean events, allowing for selective routing of TRUE or FALSE values and negation |
| H3D::BooleanFilter::NegateSFBool | This field class takes as input SFBool fields and sets its value to the negated value of the input field |
| H3D::BooleanFilter::SetBoolean | The SetBoolean class is 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 |
| H3D::BooleanSequencer | BooleanSequencer generates sequential SFBool events when driven |
| H3D::BooleanToggle | BooleanToggle stores a boolean value for toggling on/off |
| H3D::BooleanToggle::SetBoolean | Toggle field if a true event is given |
| H3D::BooleanTrigger | BooleanTrigger is a trigger node that generates boolean events |
| H3D::BooleanTrigger::SetBoolean | If a time event is given, generate a true event |
| H3D::Bound | The Bound class is the abstract base class for all classes specifying bounding objects |
| H3D::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 |
| H3D::Box::SFBound | SFBound is specialized update itself from the radius field of the Box node |
| H3D::BoxBound | The BoxBound is a Bound class that specifies the bound using an axis-aligned bounding box |
| H3D::Circle2D | The Circle2D node specifies a circle centred at (0,0) in the local 2D coordinate system |
| H3D::Circle2D::SFBound | SFBound is specialized update itself from the radius field of the Box node |
| H3D::ClipPlane | This node defines a single plane equation that will be used to clip the geometry, i.e |
| H3D::Color | This node defines a set of RGB colours to be used in the fields of another node |
| H3D::ColorInterpolator | This node interpolates among a list of MFColor key values to produce an SFColor (RGB) value_changed event |
| H3D::ColorInterpolator::SFValue | The SFValue field updates the interpolated value from the fields routed to it |
| H3D::ColorRGBA | This node defines a set of RGBA colours to be used in the fields of another node |
| H3D::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 |
| H3D::ComposedCubeMapTexture | The ComposedCubeMapTexture node defines a cubic environment map source as an explicit set of images drawn from individual 2D texture descriptions |
| H3D::ComposedShader | The ComposedShader node defines a shader where the individual source files are not individually programmable |
| H3D::ConditionLock | The ConditionLock is a little more advanced version of MutexLock in that it can wait for an arbitrary action in the other thread |
| H3D::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 |
| H3D::Cone::SFBound | SFBound is specialized update itself from the radius and heigh field of the Cone node |
| H3D::Contour2D | The Contour2D node groups a set of curve segments to a composite |
| H3D::Contour2D::AddTheChildren | This field class checks whether the given node is of the right type (ContourPolyline2D or NurbsCurve2D) |
| H3D::Contour2D::CheckTheChildren | This field class checks whether the given Node is of the right type (ContourPolyline2D or NurbsCurve2D) for adding or removing |
| H3D::Contour2D::RemoveTheChildren | This field class checks whether the given node is of the right type (ContourPolyline2D or NurbsCurve2D) |
| H3D::ContourPolyline2D | The ContourPolyline2D node defines a piecewise linear curve |
| H3D::CoordBoundField | The CoordBoundField is specialized update itself from a X3DCoordinateNode |
| H3D::Coordinate | This node defines a set of 3D coordinates to be used in the coord field of vertex-based geometry nodes |
| H3D::CoordinateDeformer | The CoordinateDeformer uses a H3DFunctionNode to determine the deformation |
| H3D::CoordinateInterpolator | This node linearly interpolates among a list of MFVec3f values to produce an MFVec3f value_changed event |
| H3D::CoordinateInterpolator2D | This node linearly interpolates among a list of MFVec2f values to produce an MFVec2f value_changed event |
| H3D::CoordinateInterpolator2D::MFValue | The SFValue field updates the interpolated value from the fields routed to it |
| H3D::CoordinateInterpolator::MFValue | The SFValue field updates the interpolated value from the fields routed to it |
| H3D::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 |
| H3D::Cylinder::SFBound | SFBound is specialized update itself from the radius and heigh field of the Cylinder node |
| H3D::DefaultAppearance | Specifies the default appearance parameters to use for graphical rendering |
| H3D::X3D::DEFNodes | Provides a mapping between defined DEF names in X3D and the nodes they refer to |
| H3D::DeformableShape | The DeformableShape is an X3DShapeNode which makes it possible to deform the geometry of the shape when touching it with a haptics device |
| H3D::DeformableShape::SFGeometryNode | The SFGeometryNode is extended to only accept X3DComposedGeometryNode nodes |
| H3D::DependentMFNode< NodeType, FieldRefs, DynamicCast > | DependentMFNode are modified TypedMFNode fields where the field dirty status is dependent on fields in the nodes it contains |
| H3D::FieldInternals::DependentNodeFieldBase< BaseField, FieldRefs >::EventField | This Field class is used to propagate all events from the fields we are dependent on to the main field |
| H3D::DependentSFNode< NodeType, FieldRefs, DynamicCast > | DependentSFNode are modified TypedSFNode fields where the field dirty status is dependent on fields in the node it contains |
| H3D::DeviceInfo | DeviceInfo is a X3DBindableNode that contains the devices that are used with the API |
| H3D::DeviceLog | DeviceLog records haptic device position and orientation to a binary data file |
| H3D::DHDHapticsDevice | A DHDHapticsDevice is a node for handling communication with a haptics device from ForceDimension, such as the Omega and Delta haptics devices |
| H3D::DirectionalLight | The DirectionalLight node defines a directional light source that illuminates along rays parallel to a given 3-dimensional vector |
| H3D::Disk2D | The Disk2D node specifies a circular disk which is centred at (0, 0) in the local coordinate system |
| H3D::Disk2D::SFBound | SFBound is specialized update itself from the radius field of the Box node |
| H3D::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 |
| H3D::DynamicTransform | The DynamicTransform node is a Shape container that has basic properties for defining rigid body motion |
| H3D::DynamicTransform::SFAngularVelocity | Calculates the angular velocity based on the inertia tensor and angular momentum |
| H3D::DynamicTransform::SFMatrix4f | Specialize the SFMatrix4f to update the matrix from the fields in the Transform node |
| H3D::DynamicTransform::SFMotion | Time dependant field to perform the RK4 integration for determining the motion of the dynamic transform routes_in[0] time field |
| H3D::DynamicTransform::SFSpin | Calculates the spin (time derivative of the orientation) |
| H3D::DynamicTransform::SFVelocity | Calculates the velocity based on the mass and momentum |
| H3D::ElevationGrid | The ElevationGrid node specifies a uniform rectangular grid of varying height in the Y=0 plane of the local coordinate system |
| H3D::ElevationGrid::AutoNormal | Specialized field for automatically generating normals from coordinates |
| H3D::ElevationGrid::DisplayList | Display list is extended in order to set front sidedness of triangles outside the display list |
| H3D::ElevationGrid::SFBound | SFBound is specialized update itself from the fields of the ElevationGrid |
| H3D::EmptyBound | An EmptyBound is a Bound that encompasses nothing |
| H3D::Extrusion | The Extrusion node specifies geometric shapes based on a two |
| H3D::Extrusion::SFBound | Extrusion |
| H3D::Extrusion::VertexVectors | Routes_in[0] is the crossSection field |
| H3D::FakeHapticsDevice | A H3DHapticsDevice node where the position, orientation and button can be controlled via the set_devicePosition, set_deviceOrientation and set_mainButton fields |
| H3D::Field | The Field class |
| H3D::Field::Event | The Event struct encapsulates an event in the field network |
| H3D::FieldDBElement | A FieldDBElement is an encapsulation of a field in a H3DNodeDatabase |
| H3D::FieldDBTemplate< N, F > | Template class for specifying specialized FieldDBElement instances |
| H3D::FieldRef< NodeType, FieldType, member_ptr > | Class used for specifying a field member of a node in a DependentSFNode or DependentMFNode specification |
| H3D::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 |
| H3D::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 |
| H3D::FitToBoxTransform::SFMatrix4f | We specialize the SFMatrix4f field to that update itself from a SFBound field and two SFVec3f fields |
| H3D::FloatVertexAttribute | The FloatVertexAttribute node defines a set of per-vertex single precision floating point attributes |
| H3D::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 |
| H3D::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 |
| H3D::ForceField | This effect adds a constant force to all haptics devices at all times |
| H3D::FrictionalSurface | Surface with friction |
| H3D::GaussianFunction | The function node implements a gaussian function |
| H3D::GeneratedCubeMapTexture | The ComposedCubeMapTexture node defines a cubic environment map that sources its data from internally generated images |
| H3D::GlobalSettings | GlobalSettings is a X3DBindableNode that specifies default settings for use in H3D API, such as caching options, haptic rendering options etc |
| H3D::GLUTWindow | H3DWindowNode implementet using GLUT |
| H3D::GraphicsCachingOptions | Specifies parameters to use for graphical rendering of nodes |
| H3D::Group | A Group node contains children nodes without introducing a new transformation |
| H3D::Exception::H3DAPIException | This is the base class for exceptions where the location in the source code is included |
| H3D::H3DBoundedObject | This abstract interface is the base class for all node types that include a bounding box |
| H3D::H3DBoundedObject::SFBound | The Bound object is reference counted by the field |
| H3D::H3DCoordinateDeformerNode | The H3DCoordinateDeformerNode is the abstract base class for all nodes specifying deformation of coordinates based on contact of haptics devices |
| H3D::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 |
| H3D::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 |
| H3D::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 |
| H3D::H3DDynamicFieldsObject | This abstract interface class is the base class for all node types that specify arbitrary fields i.e |
| H3D::Exception::H3DException | The base class for all exceptions |
| H3D::H3DFakeHapticsDevice | H3DFakeHapticsDevice is a base class for making fake haptics devices, i.e |
| H3D::H3DForceEffect | The base class for scenegraph force effects |
| H3D::H3DHapticsDevice | Base class for all haptic devices |
| H3D::H3DHapticsDevice::OrnCalibration | Saves the value of the field in a variable that can be accessed from the realtime loop |
| H3D::H3DHapticsDevice::PosCalibration | Saves the value of the field in a variable that can be accessed from the realtime loop |
| H3D::H3DHapticsDevice::TrackerOrientation | The TrackerOrientation field updates itself from the device_orientation and orientation_calibration fields |
| H3D::H3DHapticsDevice::TrackerPosition | The TrackerPosition field updates itself from the device_position and position_calibration fields |
| H3D::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 |
| H3D::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 |
| H3D::H3DImageLoaderNode::FileReaderRegistration | Class used to register a class to the registered file readers |
| H3D::H3DImageObject | This abstract interface is inherited by all nodes that contains an SFImage object with an Image containing data |
| H3D::H3DImageObject::SFImage | The SFImage field is a field containing an Image pointer |
| H3D::H3DNodeDatabase | The H3DNodeDatabase contains a mapping between a name of a Node and the constructor for the Node with that name |
| H3D::H3DNodeDatabase::FieldDBConstIterator | The FieldDBConstIterator is an iterator class used for iterating over the field instances in an H3DNodeDatabase |
| H3D::H3DOptionNode | This abstract node type indicates that the concrete nodes which are instantiated based on it may be used in children, addChildren, and removeChildren fields |
| H3D::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 |
| H3D::H3DScriptNode | The base class for script nodes |
| H3D::H3DSoundFileNode | This abstract node type is used to derive node types that can stream PCM sound data from a file |
| H3D::H3DSoundFileNode::FileReaderRegistration | Class used to register a class to the registered file readers |
| H3D::H3DSoundStreamNode | This abstract node type is used to derive node types that can stream PCM sound data |
| H3D::H3DSurfaceNode | Base class for all surfaces |
| H3D::H3DThreadedHapticsDevice | The H3DThreadedHapticsDevice provides threading and interface for easily add support for new haptics devices |
| H3D::H3DVideoClipDecoderNode | H3DVideoClipDecoderNode is a virtual base class for classes decoding video clips making new frames available to render |
| H3D::H3DVideoClipDecoderNode::DecoderRegistration | Class used to register a class to the registered file readers |
| H3D::H3DVideoTextureNode | H3DVideoTextureNode is a virtual base class for classes using video as a texture |
| H3D::H3DWindowNode | The base class for all window nodes |
| H3D::H3DWindowNode::RenderMode | The mode for rendering specified as a string |
| H3D::HapticCylinder | Class for rendering a haptic cylinder |
| H3D::HapticForceEffect | The base class for force effects |
| H3D::HapticForceEffect::EffectInput | The input to a HapticForceEffect |
| H3D::HapticForceEffect::EffectOutput | The output from a HapticForceEffect |
| H3D::HapticForceField | This is a HapticForceEffect that generates a constant force |
| H3D::HapticObject | The base class for all haptic objects |
| H3D::HapticShape | Base class for haptic shapes, i.e |
| H3D::HapticSphere | Class for rendering a haptic Sphere |
| H3D::HapticSpring | Generates a spring force, i.e |
| H3D::HapticThread | HapticThread is a thread class that should be used by haptics devices when creating threads |
| H3D::HapticThreadBase | The interface base class for all threads that are used for haptics devices |
| H3D::HaptikHapticsDevice | The HaptikHapticsDevice uses the Haptik library (www.haptiklibrary.org) to access haptics devices |
| H3D::HaptikHapticsDevice::SelectDevice | The SelectDevice field changes the haptics device to use depending on the values of set_selectedDevice and preferredDeviceType fields |
| H3D::HLCustomObject | Base class for objects that use HLAPI custom shape callbacks to render itself |
| H3D::HLDepthBufferShape | Class for using the render() function of an X3DGeometryNode for haptics rendering |
| H3D::HLFeedbackShape | Class for using the render() function of an X3DGeometryNode for haptics rendering |
| H3D::HLHapticsDevice | HLHapticsDevice is a haptics device that uses the HLAPI from SensAble to do the haptic rendering |
| H3D::HLObject | The base class for all haptic objects that uses HLAPI for haptic rendering |
| H3D::HLShape | The base class for all haptic shapes that uses HLAPI for haptic rendering |
| H3D::HLSurface | The base class for all haptic objects that uses HLAPI for haptic rendering |
| H3D::HLThread | HLThread is a singleton class providing an interface to the scheduler and thread running when using OpenHaptics and HD API |
| H3D::Image | Virtual base class for all images containing virtual functions that all Image classes must define |
| H3D::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 |
| H3D::Image3DTexture::SFImage | SFImage is overridden to update the value from the url and imageLoader fields of the Image3DTexture |
| H3D::ImageObjectTexture | The ImageObjectTexture node uses the image data from any node that implements the H3DImageObject interface as texture data |
| H3D::ImageObjectTexture::SFImageObject | The SFImageObject class contains an H3DImageObject and maintains a route from the contained object's image field to the image field of the ImageObjectTexture it resides in |
| H3D::ImageTexture | The ImageTexture node defines a texture map by specifying an image file and general parameters for mapping to geometry |
| H3D::ImageTexture::SFImage | SFImage is overridden to update the value from the url and imageLoader fields of the ImageTexture |
| H3D::ImportLibrary | The ImportLibrary node makes it possible from a X3D file to load a dynamically linked library in order to e.g |
| H3D::IndexedFaceSet | The IndexedFaceSet node represents a 3D shape formed by constructing faces (polygons) from vertices listed in the coord field |
| H3D::IndexedFaceSet::AutoNormal | Specialized field for automatically generating normals from coordinates |
| H3D::IndexedLineSet | The IndexedLineSet node represents a 3D geometry formed by constructing polylines from 3D vertices specified in the coord field |
| H3D::IndexedTriangleFanSet | An IndexedTriangleFanSet represents a 3D shape composed of triangles that form a fan shape around the first vertex declared in each fan |
| H3D::IndexedTriangleFanSet::AutoNormal | Specialized field for automatically generating normals from coordinates |
| H3D::IndexedTriangleSet | The IndexedTriangleSet node represents a 3D shape composed of a collection of individual triangles |
| H3D::IndexedTriangleSet::AutoNormal | Specialized field for automatically generating normals from coordinates |
| H3D::IndexedTriangleStripSet | An IndexedTriangleStripSet represents a 3D shape composed of strips of triangles |
| H3D::IndexedTriangleStripSet::AutoNormal | Specialized field for automatically generating normals from coordinates |
| H3D::InfiniteBound | An InfiniteBound is a Bound that encompasses everything |
| H3D::Inline | The Inline node embeds an X3D scene stored at a location on the World Wide Web into the current scene |
| H3D::Inline::LoadedScene | The LoadedScene class 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 |
| H3D::Inline::SFBound | SFBound is specialized to update from the SFBound fields routed to it |
| H3D::IntegerSequencer | The IntegerSequencer node generates sequential discrete SFInt32 |
| H3D::IntegerTrigger | IntegerTrigger handles single field Boolean |
| H3D::IntegerTrigger::SetTriggerValue | The SetTriggerValue class is specialize to set the vaule of the triggerValue field to the value of the field integerKey |
| H3D::X3D::IStreamInputSource | This class is a derivative of the standard Xerxes C InputSource class |
| H3D::X3D::IStreamInputStream | This class implements the BinInputStream interface to read from a istream |
| H3D::KeySensor | A KeySensor node generates events when the user presses keys on the keyboard |
| H3D::LineProperties | The LineProperties node specifies additional properties to be applied to all line geometry |
| H3D::LineSet | The LineSet node represents a 3D geometry formed by constructing polylines from 3D vertices specified in the coord field |
| H3D::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 |
| yy::location | Abstract a location |
| H3D::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 |
| H3D::Material | The Material node specifies surface material properties for associated geometry nodes and is used by the X3D lighting equations during rendering |
| H3D::ArithmeticTypes::Matrix3d | Representation of a 3x3 matrix |
| H3D::ArithmeticTypes::Matrix3f | Representation of a 3x3 matrix |
| H3D::Matrix3VertexAttribute | Defines a set of per-vertex 3×3 matrix attributes |
| H3D::ArithmeticTypes::Matrix4d | Representation of a 4x4 matrix |
| H3D::ArithmeticTypes::Matrix4f | Representation of a 4x4 matrix |
| H3D::Matrix4VertexAttribute | Defines a set of per-vertex 4×4 matrix attributes |
| H3D::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 |
| H3D::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 |
| H3D::MetadataDouble | The metadata provided by this node is contained in the double-precision floating point numbers of the value field |
| H3D::MetadataFloat | The metadata provided by this node is contained in the single-precision floating point numbers of the value field |
| H3D::MetadataInteger | The metadata provided by this node is contained in the integers of the value field |
| H3D::MetadataSet | The metadata provided by this node is contained in the metadata nodes of the value field |
| H3D::MetadataString | The metadata provided by this node is contained in the strings of the value field |
| H3D::MFBool | The MFBool field contains a vector of boolean values |
| H3D::MFColor | The MFColor field contains a vector of RGB (red-green-blue) colour triples |
| H3D::MFColorRGBA | The MFColorRGBA field contains a vector of RGBA (red-green-blue-alpha) colour 4-tuples |
| H3D::MFDouble | The MFDouble field contains a vector of high-precision floating point numbers |
| H3D::MFFloat | The MFFloat field contains a vector of single-precision floating point numbers |
| H3D::MField< Type > | Template class that adds the Field mechanism to a vector of values |
| H3D::MFieldBase< Type, VectorClass, BaseField > | The common base class for MField types and MFNode |
| H3D::MFInt32 | The MFInt32 field contains a vector of 32-bit integers |
| H3D::MFMatrix3d | The MFMatrix3d field contains a vector of Matrix3d instances |
| H3D::MFMatrix3f | The MFMatrix3f field contains a vector of Matrix3f instances |
| H3D::MFMatrix4d | The MFMatrix4d field contains a vector of Matrix4d instances |
| H3D::MFMatrix4f | The MFMatrix4f field contains a vector of Matrix4f instances |
| H3D::MFNode | MFNode is almost like any MField but it encapsulates a vector of Node pointers |
| H3D::MFQuaternion | The MFQuaternion field contains a vector of arbitrary Quaternion objects |
| H3D::MFRotation | The MFRotation field contains a vector of arbitrary Rotation objects |
| H3D::MFString | The MFString field conatins a vector of strings |
| H3D::MFTime | The MFTime field contains a vector of time values |
| H3D::MFVec2d | The MFVec2d field contains a vector of Vec2d |
| H3D::MFVec2f | The MFVec2f field contains a vector of Vec2f |
| H3D::MFVec3d | The MFVec3d field contains a vector of Vec3d |
| H3D::MFVec3f | The MFVec3f field contains a vector of Vec3f |
| H3D::MFVec4d | The MFVec4d field contains a vector of Vec4d |
| H3D::MFVec4f | The MFVec4f field contains a vector of Vec4f |
| H3D::MouseSensor | A sensor node for reading mouse values |
| H3D::MultiTexture | Partially implemented |
| H3D::MultiTextureCoordinate | MultiTextureCoordinate supplies multiple texture coordinates per vertex |
| H3D::MultiTextureTransform | MultiTextureTransform supplies multiple texture transforms per appearance |
| H3D::MutexLock | Mutual exclusion lock class for synchronisation between threads |
| H3D::NavigationInfo | The NavigationInfo node contains information describing the physical characteristics of the viewer's avatar and viewing model |
| H3D::Node | Node is the base class for all classes that can be part of the H3D scene-graph |
| H3D::Normal | This node defines a set of 3D surface normal vectors to be used in the vector field of some geometry nodes |
| H3D::NormalInterpolator | The NormalInterpolator node interpolates among a list of normal vector sets specified by the keyValue field to produce an MFVec3f value_changed event |
| H3D::NormalInterpolator::MFValue | The SFValue field updates the interpolated value from the fields routed to it |
| H3D::NurbsCurve2D | The NurbsCurve2D node defines a trimming segment that is part of a |
| H3D::NurbsPatchSurface | The NurbsPatchSurface node is a contiguous NURBS surface patch |
| H3D::NurbsTextureCoordinate | The tessellation process generates 2D texture coordinates |
| H3D::NurbsTrimmedSurface | The NurbsTrimmedSurface node defines a NURBS surface |
| H3D::NurbsTrimmedSurface::AddContour | This field class checks whether the given node is of the right type (Contour2D) |
| H3D::NurbsTrimmedSurface::CheckContour | This field class checks whether the given node is of the right type (Contour2D) for adding or removing |
| H3D::NurbsTrimmedSurface::RemoveContour | This field class checks whether the given node is of the right type (Contour2D) |
| H3D::OpenHapticsOptions | Specifies parameters to use for when rendering an object with OpenHaptics |
| H3D::OrientationInterpolator | The OrientationInterpolator node interpolates among a list of rotation values specified in the keyValue field to produce an SFRotation value_changed event |
| H3D::OrientationInterpolator::SFValue | The SFValue field updates the interpolated value from the fields routed to it |
| H3D::PackagedShader | PackagedShader node describes a single file that may contain a number of shaders and combined effects |
| H3D::ParsableField | This is a field which value can be set by a string from the X3D parser |
| H3D::ParsableMField | This is a field which value can be set by a string from the X3D parser |
| H3D::PeriodicThread | The PeriodicThread class is used to create new threads and provides an interface to add callback functions to be executed in the new thread that can be used by other threads |
| H3D::PeriodicThreadBase | The abstract base class for threads that have a main loop and that allow you to add callback functions to be run in that loop |
| H3D::PeriodicUpdate< BaseFieldType > | The PeriodicUpdate is a template modifier that changes the way the field is updated |
| H3D::PeriodicUpdateField | Abstract base class for all Fields that will be updated without anyone asking for a value |
| H3D::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 |
| H3D::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 |
| H3D::PointLight | The PointLight node specifies a point light source at a 3D location in the local coordinate system |
| H3D::PointNormalClipPlane | This is a ClipPlane where the plane is specified with a point and a normal |
| H3D::PointNormalClipPlane::PlaneEq | The PlaneEq updates the plane equation from the values of the point and normal fields |
| H3D::PointSet | The PointSet node specifies a set of 3D points, in the local coordinate system, with associated colours at each point |
| H3D::Polyline2D | The Polyline2D node specifies a series of contiguous line segments in the local 2D coordinate system connecting the specified vertices |
| H3D::Polyline2D::SFBound | SFBound is specialized update itself from the radius field of the Box node |
| H3D::Polypoint2D | The Polyline2D node specifies a set of vertices in the local 2D coordinate system at each of which is displayed a point |
| H3D::Polypoint2D::SFBound | SFBound is specialized update itself from the radius field of the Box node |
| yy::position | Abstract a position |
| H3D::PositionInterpolator | The PositionInterpolator node linearly interpolates among a list of 3D vectors to produce an SFVec3f value_changed event |
| H3D::PositionInterpolator2D | The PositionInterpolator node linearly interpolates among a list of 2D vectors to produce an SFVec2f value_changed event |
| H3D::PositionInterpolator2D::SFValue | The SFValue field updates the interpolated value from the fields routed to it |
| H3D::PositionInterpolator::SFValue | The SFValue field updates the interpolated value from the fields routed to it |
| H3D::ProgramShader | He ProgramShader node defines a shader that can consist of one or more individually programmable, self contained pieces |
| H3D::ProgramShader::MFShaderProgram | The MFShaderProgram class sets the profile for each ShaderProgram node that is added to it |
| H3D::ProtoDeclaration | The ProtoDeclaration class containse information about a PROTO node from the X3D standard |
| H3D::ProtoDeclaration::FieldDeclaration | Class that contains information about a field that is part of the prototype declaration |
| H3D::PrototypeInstance | The PrototypeInstance is an instance of a prototyped node |
| H3D::ArithmeticTypes::Quaternion | Quaternion describes an arbitrary rotation |
| H3D::Exception::QuitAPI | This is special exception that can be thrown in order to quit the API |
| H3D::RawImageLoader | The RawImageLoader loads a raw data file and lets the user specify the parameters for the values directly |
| H3D::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 |
| H3D::Rectangle2D::SFBound | SFBound is specialized update itself from the radius field of the Box node |
| H3D::RefCountMField< RefClass > | RefCountMField is almost like any MField but it encapsulates a vector of RefCoundtedClass pointers |
| H3D::RefCountSField< RefClass, BaseField > | RefCountSField is almost like any SField but it encapsulates a pointer to a RefCountedClass |
| H3D::RenderProperties | The RenderProperties node specifies additional rendering options that cannot be specified with the X3D Appearance node |
| H3D::ResourceResolver | The ResourceResolver class is both a base class for all classes that resolves resource names and contains static functions for resolving them |
| H3D::RGB | Structure for RGB values |
| H3D::RGBA | Structure for RGBA values |
| H3D::ArithmeticTypes::Rotation | Rotation describes an arbitrary rotation |
| H3D::ScalarInterpolator | This node linearly interpolates among a list of SFFloat values to produce an SFFloat value_changed event |
| H3D::ScalarInterpolator::SFValue | The SFValue field updates the interpolated value from the fields routed to it |
| H3D::Scene | The Scene node is topmost node that takes care of the rendering of the scene graph both haptically and graphically |
| H3D::Scene::EventSink | The EventSink class makes all fields up-to-date what are routed to it, with the exception of PeriodicUpdateFields |
| H3D::SFBool | The SFBool field contains a single boolean value |
| H3D::SFColor | The SFColor field contains one RGB (red-green-blue) colour triple |
| H3D::SFColorRGBA | The SFColorRGBA field contains one RGBA (red-green-blue-alpha) colour 4-tuple |
| H3D::SFDouble | The SFDouble field contains one high-precision floating point number |
| H3D::SFFloat | The SFFloat field contains one single-precision floating point number |
| H3D::SField< Type > | Template class that adds the Field mechanisms to an encapsulated value of specified type |
| H3D::SFieldClass | Base class for all fields created with the SField template |
| H3D::SFInt32 | The SFInt32 field contains one 32-bit integer |
| H3D::SFMatrix3d | The SFMatrix3d field contains a Matrix3d |
| H3D::SFMatrix3f | The SFMatrix3f field contains a Matrix3f |
| H3D::SFMatrix4d | The SFMatrix4d field contains a Matrix4d |
| H3D::SFMatrix4f | The SFMatrix4f field contains a Matrix4f |
| H3D::SFNode | SFNode is almost like any SField but it encapsulates a pointer to a Node |
| H3D::SFQuaternion | The SFQuaternion field contains a Quaternion |
| H3D::SFRotation | The SFRotation field contains one arbitrary Rotation |
| H3D::SFString | The SFString field contains a string |
| H3D::SFTime | The SFTime field contains a single time value |
| H3D::SFVec2d | The SFVec2d field contains a Vec2d |
| H3D::SFVec2f | The SFVec2f field contains a Vec2f |
| H3D::SFVec3d | The SFVec3d field contains a Vec3d |
| H3D::SFVec3f | The SFVec3f field contains a Vec3f |
| H3D::SFVec4d | The SFVec4d field contains a Vec4d |
| H3D::SFVec4f | The SFVec4f field contains a Vec4f |
| H3D::ShaderPart | The ShaderPart node defines the source for a single object to be used by a ComposedShader node |
| H3D::ShaderPart::SFShaderString | Update the string to use as shader depending from the urls given |
| H3D::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 |
| H3D::Shape | The Shape node has two fields, appearance and geometry, which are used to create rendered objects in the world |
| H3D::SimpleMovieTexture | SimpleMovieTexture is a node for showing movies as textures with a simpler interface than the movie texture node |
| H3D::SimpleMovieTexture::DecoderManager | The DecoderManager class manages all state changes in the decoder depending on the values of the fields in SimpleMovieTexture |
| H3D::SimpleThread | The SimpleThread class creates a new thread to run a function |
| yy::slice< T, S > | Present a slice of the top of a stack |
| H3D::SmoothSurface | A SmoothSurface has no friction at all |
| H3D::Sound | The Sound node specifies the spatial presentation of a sound in a X3D scene |
| H3D::Sound::ALSoundSetup | Field that calls ALrender() when a field routed to it has generated an event |
| H3D::Sound::SFSoundSourceNode | The SFSoundSourceNode registers the Sound node in the X3DSoundSourceNode that is put into the field |
| H3D::SpaceballSensor | A sensor node for reading GLUT Spaceball values |
| H3D::SpaceWareHapticsDevice | A fake haptics device where the position and orientation is controlled via a SpaceWare device such as the SpaceMouse or SpaceTraveller |
| H3D::SpaceWareHapticsDevice::SetMainButton | SetMainButton is set to true if any of the buttons on the SpaceWare device is pressed |
| H3D::SpaceWareSensor | This is a X3DSensorNode for reading values from a 3DConnexion motion controller such as the SpaceTraveller or SpaceMouse 5000 |
| H3D::SpaceWareSensor::AccumulateRotation | This class is an AutoUpdate class that accumulates the rotation values routed to it, i.e |
| H3D::SpaceWareSensor::AccumulateTranslation | This class is an AutoUpdate class that accumulates the Vec3f values routed to it, i.e |
| H3D::SpaceWareSensor::ScaleRotation | Updates itself to the Rotation routed to it where the angle is scaled by the scale factor |
| H3D::SpaceWareSensor::ScaleTranslation | Updates itself to the SFVec3f routed to it scaled by the scale factor |
| H3D::Sphere | The Sphere node specifies a sphere centred at (0, 0, 0) in the local coordinate system |
| H3D::Sphere::SFBound | SFBound is specialized update itself from the radius field of the Sphere node |
| H3D::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 |
| H3D::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 |
| H3D::StereoInfo | The StereoInfo nis a bindable node that contains information used when rendering the scene in stereo |
| H3D::SuperShape | The SuperShape node implements a SuperShape! |
| H3D::Switch | The Switch grouping node traverses zero or one of the nodes specified in the choice field |
| H3D::Switch::SFBound | SFBound is specialized to update from the SFBound fields routed to it |
| H3D::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 |
| H3D::TexGenGeometry::SFGeometryNode | The SFGeometryNode keeps a route between the contained X3DGeometryNode's bound field and the bound field ot the TexGenGeometry |
| H3D::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) |
| H3D::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 |
| H3D::Text::SFBound | The SFBound field is specialized to update itself from the values in the fields of the Text node |
| H3D::TextureBackground | A background node that uses six individual texture nodes to compose the backdrop |
| H3D::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 |
| H3D::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 |
| H3D::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 |
| H3D::TextureCoordinateGenerator | TextureCoordinateGenerator supports the automatic generation of texture coodinates for geometric shapes |
| H3D::TextureMatrixTransform | The matrix field specifies a generalized, unfiltered 4×4 transformation matrix that can be used to modify the texture |
| H3D::TextureProperties | TextureProperties allows fine control over a texture's application |
| H3D::TextureTransform | The TextureTransform node defines a 2D transformation that is applied to texture coordinates (see TextureCoordinate) |
| H3D::TextureTransform3D | The TextureTransform3D node defines a 3D transformation that is applied to texture coordinates (see TextureCoordinate) |
| H3D::ThreadBase | The abstract base class for threads |
| H3D::ThreadSafeMField< BaseField > | A template modifier to add thread safety to an MField type |
| H3D::ThreadSafeRefSField< BaseField > | A template modifier to add thread safety to an RefCountedSField type |
| H3D::ThreadSafeSField< BaseField > | A template modifier to add thread safety to an SField type |
| H3D::TimeSensor | TimeSensor nodes generate events as time passes |
| H3D::TimeSensor::TimeHandler | The TimeHandler field is specialized to include the handling of the TimeSensor specific fields |
| H3D::TimeTrigger | TimeTrigger is a trigger node that generates time events upon receiving boolean events |
| H3D::TimeTrigger::SetTriggerTime | The SetTriggerTime class is specialize to set the vaule of the triggerTime field to the current time |
| H3D::ToggleGroup | The ToggleGroup node enables you to enable/disable haptics and graphics rendering of its children nodes |
| H3D::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 |
| H3D::Transform::Matrix | Specialize the SFMatrix4f to update the matrix from the fields in the Transform node |
| H3D::TransformedBoxBound | A TransformedBoxBound is a wrapper around another BoxBound and its values are the values of the BoxBound transformed by a transformation matrix |
| H3D::TransformedBoxBound::Center | The Center field updates itself from the boxBound and matrix fields |
| H3D::TransformedBoxBound::Size | The Size field updates itself from the boxBound and matrix fields |
| H3D::TransformInfo | The TransformInfo node provides information about the coordinate space it resides in in the scene graph |
| H3D::TraverseInfo | TraverseInfo is a structure that is passed along when traversing the scene graph |
| H3D::TriangleFanSet | A TriangleFanSet represents a 3D shape composed of triangles that form a fan shape around the first vertex declared in each fan |
| H3D::TriangleFanSet::AutoNormal | Specialized field for automatically generating normals from coordinates |
| H3D::TriangleSet | The TriangleSet node represents a 3D shape that represents a collection of individual triangles |
| H3D::TriangleSet2D | The TriangleSet2D node specifies a set of triangles in the local 2D coordinate system |
| H3D::TriangleSet2D::SFBound | SFBound is specialized update itself from the radius field of the Box node |
| H3D::TriangleSet::AutoNormal | Specialized field for automatically generating normals from coordinates |
| H3D::TriangleStripSet | A TriangleStripSet represents a 3D shape composed of strips of triangles |
| H3D::TriangleStripSet::AutoNormal | Specialized field for automatically generating normals from coordinates |
| H3D::TwoSidedMaterial | This node defines material properties that can effect both the front and back side of a polygon individually |
| H3D::TypedField< BaseField, RequiredArgTypes, OptionalArgTypes > | A template modifier class for adding type checking on the routes to any Field class |
| TypedFieldError | An exception thrown when the field does not conform to the type specification from a TypedField |
| H3D::TypedMFNode< NodeType > | Template to make sure that the Nodes that are added to a MFNode are of a specified Node type |
| H3D::TypedMFNodeObject< Type > | Template to make sure that the Nodes that is set in a SFNode is of a specified type |
| H3D::TypedRefCountField< RefCountedType, BaseRefCountType > | Template to make sure that the Node that is set in a SFNode is of a specified Node type |
| H3D::TypedSFNode< NodeType > | Template to make sure that the Node that is set in a SFNode is of a specified Node type |
| H3D::TypedSFNodeObject< Type > | Template to make sure that the Node that is set in a SFNode is of a specified type |
| H3D::TypedFieldTypeCheck::Types<> | The Types template can be used in the RequiredArgTypes or OptionalArgTypes arguments of a TypedField template instantiation |
| UnimplementedConversionType | An exception for errors when the conversion from a string to the type that we try convert to is not implemented |
| H3D::URNResolver | The URNResolver resolves URNs (Uniform Resource Name) into paths |
| H3D::Exception::ValueException< ValueType > | A virtual template class for instantiating exceptions based on a value |
| H3D::ArithmeticTypes::Vec2d | A Vec2d specifies a high-precision 2d vector |
| H3D::ArithmeticTypes::Vec2f | A Vec2f specifies a 2d vector |
| H3D::ArithmeticTypes::Vec3d | A Vec3d specifies a high-precision 3d vector |
| H3D::ArithmeticTypes::Vec3f | A Vec3f specifies a high-precision 3d vector |
| H3D::ArithmeticTypes::Vec4d | A Vec4d specifies a high-precision 4d vector |
| H3D::ArithmeticTypes::Vec4f | A Vec4f specifies a 4d vector |
| H3D::Viewpoint | The Viewpoint node defines a specific location in the local coordinate system from which the user may view the scene |
| yy::VrmlParser | A Bison parser |
| H3D::WorldInfo | The WorldInfo node contains information about the world |
| H3D::X3DAppearanceChildNode | This is the base node type for the child nodes of the X3DAppearanceNode type |
| H3D::X3DAppearanceNode | This is the base node type for all Appearance nodes |
| H3D::X3DBackgroundNode | X3DBackgroundNode is the abstract type from which all backgrounds inherit |
| H3D::X3DBindableNode | X3DBindableNode is the abstract base type for all bindable children nodes, including Background, TextureBackground, Fog, NavigationInfo, Viewpoint and DeviceInfo |
| H3D::X3DBindableNode::SFSetBind | The SFSetBind field calls toStackTop() and removeFromStack() on the X3DBindableNode it is in depending on the value that it is set to |
| H3D::X3DBoundedObject | This X3D abstract interface type is basis for all X3D node types that have bounds specified as part of the definition |
| H3D::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 |
| H3D::X3DColorNode | This is the base node type for color specifications in X3D |
| H3D::X3DComposedGeometryNode | This is the base node type for all composed 3D geometry in X3D |
| H3D::X3DComposedGeometryNode::DisplayList | Display list is extended in order to set front sidedness of triangles outside the display list |
| H3D::X3DCoordinateNode | This is the base node type for all coordinate node types in X3D |
| H3D::X3DEnvironmentTextureNode | This abstract node type is the base type for all node types that specify cubic environment map sources for texture images |
| X3DFieldConversionError | An exception for errors when string to convert to a field value is invalid for the field type |
| H3D::X3DFogObject | X3DFogObject is the abstract type that describes a node that influences the lighting equation through the use of fog semantics |
| H3D::X3DFontStyleNode | This abstract node type is the base node type for all FontStyle nodes |
| H3D::X3DGeometricPropertyNode | This is the base node type for all geometric property node types defined in X3D |
| H3D::X3DGeometryNode | This is the base node type for all geometry in X3D |
| H3D::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 |
| H3D::X3DGeometryNode::DisplayList | Display list is extended in order to set front sidedness of triangles outside the display list |
| H3D::X3DGroupingNode | This abstract node type indicates that concrete node types derived from it contain children nodes and is the basis for all aggregation |
| H3D::X3DGroupingNode::MFChild | MFChild sets up a routes from the Nodes that are added and removed from the field to the owner of the field |
| H3D::X3DGroupingNode::SFBound | SFBound is specialized to update from the SFBound fields routed to it |
| H3D::X3DInfoNode | This is the base node type for all nodes that contain only information without visual semantics |
| H3D::X3DInterpolatorNode | The abstract node X3DInterpolatorNode forms the basis for all types of interpolators specified in this clause |
| H3D::X3DKeyDeviceSensorNode | This abstract node type is the base type for all sensor node types which operate using key devices |
| H3D::X3DLightNode | The X3DLightNode abstract node type is the base type from which all node types that serve as light sources are derived |
| H3D::X3DMaterialNode | This is the base node type for all Material nodes |
| H3D::X3DMetadataObject | This abstract interface is the basis for all metadata nodes |
| H3D::X3DNetworkSensorNode | This abstract node type is the basis for all sensors that generate events based on network activity |
| H3D::X3DNode | This abstract node type is the base type for all nodes in the X3D system |
| H3D::X3DNormalNode | This is the base node type for all normal node types in X3D |
| H3D::X3DNurbsControlCurveNode | Provide control curve information in 2D space |
| H3D::X3DNurbsSurfaceGeometryNode | The X3DNurbsSurfaceGeometryNode represents the abstract geometry type for all types of NURBS surfaces |
| H3D::X3DNurbsSurfaceGeometryNode::TexCoordOrNurbsTex | This field class takes as input SFNode field and checks whether this is one of the allowed textureNodes or not |
| H3D::X3DParametricGeometryNode | This abstract node type is the base type for all geometry n |