Class List

Here are the classes, structs, unions and interfaces with brief descriptions:
H3D::AnchorThe 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
H3D::TypedFieldTypeCheck::Any< H3D_ANY_TEMPLATE_SPEC >The Any template can be used in the RequiredArgTypes or OptionalArgTypes arguments of a TypedField template instantiation
H3D::AnyDeviceAnyDevice tries to initialize all available HAPI haptics device nodes and uses the first one that succeeds
H3D::TypedFieldTypeCheck::AnyNumber< Type >The AnyNumber template can be used in the OptionalArgTypes argument of a TypedField template instantiation
H3D::AppearanceThe Appearance node specifies the visual properties of geometry
H3D::Arc2DThe 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::SFBoundSFBound is specialized update itself from the radius field of the Box node
H3D::ArcClose2DThe 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::SFBoundSFBound is specialized update itself from the radius field of the Box node
H3D::AudioClipAn AudioClip node specifies audio data that can be referenced by Sound nodes
H3D::AudioFileReaderAudioFileReader uses the Audio File Library ( http://www.68k.org/~michael/audiofile/ ) to read sound data
H3D::AutoUpdate< BaseFieldType >The AutoUpdate field is a template to force the BaseField to update itself as soon as an event is received
H3D::BackgroundA background node that uses six static images to compose the backdrop
H3D::BillboardThe 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::SFMatrix4fSpecialize the SFMatrix4f to update the matrix from the fields in the Billboard node
H3D::BooleanFilterBooleanFilter filters boolean events, allowing for selective routing of TRUE or FALSE values and negation
H3D::BooleanFilter::NegateSFBoolThis field class takes as input SFBool fields and sets its value to the negated value of the input field
H3D::BooleanFilter::SetBooleanSpecialize 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::BooleanSequencerBooleanSequencer generates sequential SFBool events when driven from a TimeSensor clock
H3D::BooleanToggleBooleanToggle stores a boolean value for toggling on/off
H3D::BooleanToggle::SetBooleanSpecialize to negate the value of the toggle field if a true event is given
H3D::BooleanTriggerBooleanTrigger is a trigger node that generates boolean events upon receiving time events
H3D::BooleanTrigger::SetBooleanIf a time event is given, generate a true event
H3D::BoundAbstract base class for all classes specifying bounding objects
H3D::BoxThe 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::SFBoundSFBound is specialized update itself from the size field of the Box node
H3D::BoxBoundThe BoxBound is a Bound class that specifies the bound using an axis-aligned bounding box
H3D::Chai3DRendererHaptics renderer using Chai3D(www.chai3d.org) Uses the HAPI::Chai3DRenderer class
H3D::Circle2DThe Circle2D node specifies a circle centred at (0,0) in the local 2D coordinate system
H3D::Circle2D::SFBoundSFBound is specialized update itself from the radius field of the Circle2D node
H3D::ClipPlaneThis node defines a single plane equation that will be used to clip the geometry, i.e
H3D::CollisionThe 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
H3D::CollisionOptionsSpecifies parameters to use for graphical rendering of nodes
H3D::ColorThis node defines a set of RGB colours to be used in the fields of another node
H3D::ColorInterpolatorThis node interpolates among a list of MFColor key values to produce an SFColor (RGB) value_changed event
H3D::ColorInterpolator::SFValueThe SFValue field updates the interpolated value from the fields routed to it
H3D::ColorRGBAThis node defines a set of RGBA colours to be used in the fields of another node
H3D::Composed3DTextureThe 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::ComposedCubeMapTextureThe ComposedCubeMapTexture node defines a cubic environment map source as an explicit set of images drawn from individual 2D texture descriptions
H3D::ComposedShaderThe ComposedShader node defines a shader where the individual source files are not individually programmable
H3D::ConeThe 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::SFBoundSFBound is specialized update itself from the radius and heigh field of the Cone node
H3D::ConeEmitterThe ConeEmitter node is an emitter that generates all the available particles from a specific point in space
H3D::Contour2DThe Contour2D node groups a set of curve segments to a composite contour
H3D::Contour2D::AddTheChildrenThis field class checks whether the given node is of the right type (ContourPolyline2D or NurbsCurve2D)
H3D::Contour2D::CheckTheChildrenThis field class checks whether the given Node is of the right type (ContourPolyline2D or NurbsCurve2D) for adding or removing
H3D::Contour2D::RemoveTheChildrenThis field class checks whether the given node is of the right type (ContourPolyline2D or NurbsCurve2D)
H3D::ContourPolyline2DThe ContourPolyline2D node defines a piecewise linear curve segment as a part of a trimming contour in the u,v domain of a surface
H3D::CoordBoundFieldThe CoordBoundField is specialized update itself from a X3DCoordinateNode
H3D::CoordinateThis node defines a set of 3D coordinates to be used in the coord field of vertex-based geometry nodes
H3D::CoordinateDeformerThe CoordinateDeformer uses a H3DFunctionNode to determine the deformation
H3D::CoordinateInterpolatorThis node linearly interpolates among a list of MFVec3f values to produce an MFVec3f value_changed event
H3D::CoordinateInterpolator2DThis node linearly interpolates among a list of MFVec2f values to produce an MFVec2f value_changed event
H3D::CoordinateInterpolator2D::MFValueThe SFValue field updates the interpolated value from the fields routed to it
H3D::CoordinateInterpolator::MFValueThe SFValue field updates the interpolated value from the fields routed to it
H3D::CylinderThe 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::SFBoundSFBound is specialized update itself from the radius and heigh field of the Cylinder node
H3D::CylinderSensorThe 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 coordinate system
H3D::CylinderSensor::Check_Angle_LimitsThe Check_Angle_Limits field checks that the float is in the correct range
H3D::CylinderSensor::Set_CylinderEventsThe Set_CylinderEvents field takes care of sending trackPoint_changed, rotation_changed, and offset events when they should be sent
H3D::DebugOptionsSpecifies parameters for if displaying debug information like bounding boxes, haptically rendered triangles etc
H3D::DefaultAppearanceSpecifies the default appearance parameters to use for graphical rendering
H3D::X3D::DEFNodesProvides a mapping between defined DEF names in X3D and the nodes they refer to
H3D::DeformableShapeThe DeformableShape is an X3DShapeNode which makes it possible to deform the geometry of the shape when touching it with a haptics device
H3D::DeformableShape::SFGeometryNodeThe 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 >::EventFieldConstructor
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::DepthMapSurfaceUses a 2D texture to modify the depth of the surface
H3D::DepthMapSurface::SetImagePtrField used to transfer the routed image to the HAPISurfaceObject
H3D::DepthMapSurface::SFTexture2DNodeField that contains an X3DTexture2DNode
H3D::DeviceInfoDeviceInfo is a X3DBindableNode that contains the devices that are used with the API
H3D::DeviceLogDeviceLog records haptic device position and orientation to a binary data file
H3D::DirectionalLightThe DirectionalLight node defines a directional light source that illuminates along rays parallel to a given 3-dimensional vector
H3D::DirectShowDecoderThis node uses DirectShow to decode video clips
H3D::Disk2DThe Disk2D node specifies a circular disk which is centred at (0, 0) in the local coordinate system
H3D::Disk2D::SFBoundSFBound is specialized update itself from the radius field of the Box node
H3D::DynamicFieldDBElementThe 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::DynamicTransformThe DynamicTransform node is a Shape container that has basic properties for defining rigid body motion
H3D::DynamicTransform::SFAngularVelocityCalculates the angular velocity based on the inertia tensor and angular momentum
H3D::DynamicTransform::SFMatrix4fSpecialize the SFMatrix4f to update the matrix from the fields in the Transform node
H3D::DynamicTransform::SFMotionTime dependant field to perform the RK4 integration for determining the motion of the dynamic transform routes_in[0] time field
H3D::DynamicTransform::SFSpinCalculates the spin (time derivative of the orientation)
H3D::DynamicTransform::SFVelocityCalculates the velocity based on the mass and momentum
H3D::ElevationGridThe ElevationGrid node specifies a uniform rectangular grid of varying height in the Y=0 plane of the local coordinate system
H3D::ElevationGrid::AutoNormalSpecialized field for automatically generating normals from coordinates
H3D::ElevationGrid::DisplayListDisplay list is extended in order to set front sidedness of triangles outside the display list
H3D::ElevationGrid::SFBoundSFBound is specialized update itself from the fields of the ElevationGrid
H3D::EmptyBoundAn EmptyBound is a Bound that encompasses nothing
H3D::ExplosionEmitterThe ExplosionEmitter node is an emitter that generates all the available particles from a specific point in space at the initial time
H3D::ExtrusionThe Extrusion node specifies geometric shapes based on a two dimensional cross-section extruded along a three dimensional spine in the local coordinate system
H3D::Extrusion::SFBoundSFBound is specialized update itself from the fields of the Extrusion
H3D::Extrusion::VertexVectorsSpecialized field vertex coordinates from the fields affecting this, the resulting vertexVector will be used both in render and in bound
H3D::FakeHapticsDeviceA H3DHapticsDevice node where the position, orientation and button can be controlled via the set_devicePosition, set_deviceOrientation and set_mainButton fields
H3D::FalconDeviceA FalconDevice is a node for handling communication with a haptics device from Novint, such as the Falcon Novint
H3D::FieldThe Field class
H3D::Field::EventThe Event struct encapsulates an event in the field network
H3D::Field::FieldAccessErrorException thrown when performing actions that conflict with the field's access type
H3D::FieldDBElementA 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::FillPropertiesThe 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::FitToBoxTransformThe 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::SFMatrix4fWe specialize the SFMatrix4f field to that update itself from a SFBound field and two SFVec3f fields
H3D::FloatVertexAttributeThe FloatVertexAttribute node defines a set of per-vertex single precision floating point attributes
H3D::FogThe 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::FogCoordinateThis node defines a set of explicit fog depths on a per-vertex basis
H3D::FontStyleThe 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::FontStyle::InvalidFontStyleJustifyThrown when the strings in the justify field are invalid values
H3D::FontStyle::InvalidFontStyleRenderTypeThrown when the strings in the renderType field are invalid values
H3D::FontStyle::InvalidFontStyleStyleThrown when the string in the style field is an invalid value
H3D::ForceDimensionDeviceA ForceDimensionDevice is a node for handling communication with a haptics device from ForceDimension, such as the Omega and Delta haptics devices
H3D::ForceDimensionDevice::BrakesBrakes specializes SFBool to toggle brakes on and off
H3D::ForceDimensionDevice::EffectorMassEffectorMass specializes SFFloat to change the end effector mass at change of value
H3D::ForceDimensionDevice::GravityCompGravityComp specializes SFBool to toggle gravity compensation on and off
H3D::ForceDimensionDevice::ResetReset specializes SFBool to go into reset mode when a true event is received
H3D::ForceDimensionDevice::WaitResetWaitReset specializes SFBool to go into wait on reset mode when a true event is received
H3D::ForceFieldThis effect adds a constant force to all haptics devices at all times
H3D::FreeImageLoaderFreeImageLoader uses the FreeImage library to load the images
H3D::FrictionalSurfaceSurface with friction
H3D::FunctionPlotTextureTexture showing a plot of a function
H3D::FunctionPlotTexture::SFImageSFImage is overridden to update the image from the field values
H3D::GaussianFunctionThe function node implements a gaussian function
H3D::GeneralFunctionThe function node implements a general function R^n -> R by specifying it by a string
H3D::GeneralFunction::SFFunctionObjectClass for updating an HAPI::ParsedFunction depending on field input value
H3D::GeneratedCubeMapTextureThe ComposedCubeMapTexture node defines a cubic environment map that sources its data from internally generated images
H3D::GeometryBoundTreeOptionsSpecifies parameters to use for the tree of bounding primitives that are built for each X3DGeometryNode for collision detection purposes
H3D::GlobalSettingsGlobalSettings is a X3DBindableNode that specifies default settings for use in H3D API, such as caching options, haptic rendering options etc
H3D::GLUTWindowH3DWindowNode implementet using GLUT
H3D::GodObjectRendererHaptics renderer using the god object algorithm to render objects
H3D::GraphicsCachingOptionsSpecifies parameters to use for graphical rendering of nodes
H3D::GravityPhysicsModelThe GravityPhysicsModel node specifies a physics model that applies a constant gravity value to the particles
H3D::GroupA Group node contains children nodes without introducing a new transformation
H3D::H3DBoundedObjectThis abstract interface is the base class for all node types that include a bounding box
H3D::H3DBoundedObject::SFBoundThe Bound object is reference counted by the field
H3D::H3DCoordinateDeformerNodeThe H3DCoordinateDeformerNode is the abstract base class for all nodes specifying deformation of coordinates based on contact of haptics devices
H3D::H3DDisplayListObjectThis 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::DisplayListWe 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::IsActiveThe 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::H3DDynamicFieldsObjectThis abstract interface class is the base class for all node types that specify arbitrary fields i.e
H3D::H3DFakeHapticsDeviceH3DFakeHapticsDevice is a base class for making fake haptics devices, i.e
H3D::H3DForceEffectThe base class for scenegraph force effects
H3D::H3DFrictionalSurfaceNodeBase class for surfaces with friction
H3D::H3DFrictionalSurfaceNode::UpdateDynamicFrictionSpecialized field which sets the dynamic_friction variable in H3DFrictionalSurfaceNode when the dynamicFriction field of H3DFrictonalSurface is changed
H3D::H3DFrictionalSurfaceNode::UpdateStaticFrictionSpecialized field which sets the static_friction variable in H3DFrictionalSurfaceNode when the staticFriction field of H3DFrictionalSurfaceNode is changed
H3D::H3DFunctionNodeBase class for nodes evaluating function
H3D::H3DFunctionNode::ValueField class that calculates the function value for the given input
H3D::H3DHapticsDeviceBase class for all haptic devices
H3D::H3DHapticsDevice::OrnCalibrationSaves the value of the field in a variable that can be accessed from the realtime loop
H3D::H3DHapticsDevice::PosCalibrationSaves the value of the field in a variable that can be accessed from the realtime loop
H3D::H3DHapticsDevice::SetEnabledSetEnabled specializes SFBool to go into reset mode when a true event is received
H3D::H3DHapticsDevice::SFHapticsRendererNodeSFHapticsRendererNode extends TypedSFNode< H3DHapticsRendererNode > in order to change the haptics renderer for the used HAPIHapticsDevice when changing H3DHapticsRendererNode
H3D::H3DHapticsDevice::TrackerOrientationThe TrackerOrientation field updates itself from the device_orientation and orientation_calibration fields
H3D::H3DHapticsDevice::TrackerPositionThe TrackerPosition field updates itself from the device_position and position_calibration fields
H3D::H3DHapticsDevice::TrackerVelocityThe TrackerVelocity field updates itself from the device_velocity and velocity_calibration fields
H3D::H3DHapticsDevice::WeightedProxyThe WeightedProxy field updates to be a value between the proxy position and tracker position depending on the value of a weighting factor
H3D::H3DHapticsRendererNodeBase class for all haptic renderers, i.e
H3D::H3DImageLoaderNodeH3DImageLoaderNode 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::FileReaderRegistrationClass used to register a class to the registered file readers
H3D::H3DImageObjectThis abstract interface is inherited by all nodes that contains an SFImage object with an Image containing data
H3D::H3DImageObject::SFImageThe SFImage field is a field containing an Image pointer
H3D::H3DMultiPassRenderObjectThis abstract interface is inherited by all nodes that needs to render the scene an extra time(or more) to perform its task, e.g
H3D::H3DNavigationH3DNavigation is a Singleton class used for navigation in H3DAPI
H3D::H3DNodeDatabaseThe H3DNodeDatabase contains a mapping between a name of a Node and the constructor for the Node with that name
H3D::H3DNodeDatabase::FieldDBConstIteratorThe FieldDBConstIterator is an iterator class used for iterating over the field instances in an H3DNodeDatabase
H3D::H3DOptionNodeThis abstract node type indicates that the concrete nodes which are instantiated based on it may be used in children, addChildren, and removeChildren fields
H3D::H3DRenderStateObjectThis 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::H3DScriptNodeThe base class for script nodes
H3D::H3DSoundFileNodeThis abstract node type is used to derive node types that can stream PCM sound data from a file
H3D::H3DSoundFileNode::FileReaderRegistrationClass used to register a class to the registered file readers
H3D::H3DSoundStreamNodeThis abstract node type is used to derive node types that can stream PCM sound data
H3D::H3DStiffnessSurfaceNodeA H3DStiffnessSurfaceNode is the base class for surfaces that have stiffness and damping
H3D::H3DStiffnessSurfaceNode::UpdateDampingSpecialized field which sets the damping variable in H3DStiffnessSurfaceNode when the damping field of H3DStiffnessSurfaceNode is changed
H3D::H3DStiffnessSurfaceNode::UpdateStiffnessSpecialized field which sets the stiffness variable in H3DStiffnessSurfaceNode when the stiffness field of H3DStiffnessSurfaceNode is changed
H3D::H3DSurfaceNodeBase class for all surfaces
H3D::H3DVideoClipDecoderNodeH3DVideoClipDecoderNode is a virtual base class for classes decoding video clips making new frames available to render
H3D::H3DVideoClipDecoderNode::DecoderRegistrationClass used to register a class to the registered file readers
H3D::H3DVideoTextureNodeH3DVideoTextureNode is a virtual base class for classes using video as a texture
H3D::H3DWindowNodeThe base class for all window nodes
H3D::H3DWindowNode::RenderModeThe mode for rendering specified as a string
H3D::H3DWindowNode::RenderMode::InvalidRenderModeThrown when the value of RenderMode is an invalid mode
H3D::HapticDeviceNavigationTakes care of navigation using a haptics device
H3D::HapticMasterDeviceA HapticMasterDevice is a node for handling communication with the HapticMaster haptics device from Moog/FCS
H3D::HapticsOptionsSpecifies parameters to use when rendering an object with haptics
H3D::HaptikDeviceThe HaptikDevice uses the Haptik library (www.haptiklibrary.org) to access haptics devices
H3D::HaptikDevice::SelectDeviceThe SelectDevice field changes the haptics device to use depending on the values of set_selectedDevice and preferredDeviceType fields
H3D::Image3DTextureThe 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::CouldNotLoadImageCouldNotLoadImage is thrown when not any of the urls could be read with any of the image loaders in a Image3DTexture
H3D::Image3DTexture::SFImageSFImage is overridden to update the value from the url and imageLoader fields of the Image3DTexture
H3D::Image3DTexture::SFImage::CBDataStruct for storing input needed for the callback function
H3D::Image3DTexture::SFImage::ThreadFuncDataStruct for storing input needed to the thread function
H3D::ImageObjectTextureThe ImageObjectTexture node uses the image data from any node that implements the H3DImageObject interface as texture data
H3D::ImageObjectTexture::SFImageObjectH3DImageObject and maintains a route from the contained object's image field to the image field of the ImageObjectTexture it resides in
H3D::ImageTextureThe ImageTexture node defines a texture map by specifying an image file and general parameters for mapping to geometry
H3D::ImageTexture::CouldNotLoadImageCouldNotLoadImage is thrown when not any of the urls could be read with any of the image loaders in a ImageTexture
H3D::ImageTexture::SFImageSFImage is overridden to update the value from the url and imageLoader fields of the ImageTexture
H3D::ImageTexture::SFImage::CBDataStruct for storing input needed for the callback function
H3D::ImageTexture::SFImage::ThreadFuncDataStruct for storing input needed to the thread function
H3D::ImportLibraryThe ImportLibrary node makes it possible from a X3D file to load a dynamically linked library in order to e.g
H3D::IndexedFaceSetThe IndexedFaceSet node represents a 3D shape formed by constructing faces (polygons) from vertices listed in the coord field
H3D::IndexedFaceSet::AutoNormalSpecialized field for automatically generating normals from coordinates
H3D::IndexedLineSetThe IndexedLineSet node represents a 3D geometry formed by constructing polylines from 3D vertices specified in the coord field
H3D::IndexedLineSet::InvalidColorIndexThrown when the colorIndex field does not match the coordIndex field properly
H3D::IndexedLineSet::InvalidColorIndexSizeThrown when the colorIndex field's size does not match the coordIndex field properly
H3D::IndexedTriangleFanSetAn IndexedTriangleFanSet represents a 3D shape composed of triangles that form a fan shape around the first vertex declared in each fan
H3D::IndexedTriangleFanSet::AutoNormalSpecialized field for automatically generating normals from coordinates
H3D::IndexedTriangleFanSet::NotEnoughColorsThrown if the number of colors in the color field is less than
H3D::IndexedTriangleFanSet::NotEnoughTextureCoordinatesThrown if the number of texture coordinates in the color field is less than the number coordinates in the coord field
H3D::IndexedTriangleSetThe IndexedTriangleSet node represents a 3D shape composed of a collection of individual triangles
H3D::IndexedTriangleSet::AutoNormalSpecialized field for automatically generating normals from coordinates
H3D::IndexedTriangleSet::NotEnoughColorsThrown if the number of colors in the color field is less than the number coordinates in the coord field
H3D::IndexedTriangleSet::NotEnoughTextureCoordinatesThrown if the number of texture coordinates in the color field is less than the number coordinates in the coord field
H3D::IndexedTriangleStripSetAn IndexedTriangleStripSet represents a 3D shape composed of strips of triangles
H3D::IndexedTriangleStripSet::AutoNormalSpecialized field for automatically generating normals from coordinates
H3D::IndexedTriangleStripSet::NotEnoughColorsThrown if the number of colors in the color field is less than the number coordinates in the coord field
H3D::IndexedTriangleStripSet::NotEnoughTextureCoordinatesThrown if the number of texture coordinates in the color field is less than the number coordinates in the coord field
H3D::InfiniteBoundAn InfiniteBound is a Bound that encompasses everything
H3D::InlineThe Inline node embeds an X3D scene stored at a location on the World Wide Web into the current scene
H3D::Inline::LoadedSceneUpdates 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::SFBoundSFBound is specialized to update from the SFBound fields routed to it
H3D::IntegerSequencerThe IntegerSequencer node generates sequential discrete SFInt32 events in response to each set_fraction, next, or previous event
H3D::IntegerTriggerIntegerTrigger handles single field Boolean events to set an integer value for the output event
H3D::IntegerTrigger::SetTriggerValueSpecialize to set the vaule of the triggerValue field to the value of the field integerKey
H3D::X3D::InvalidNodeTypeAn exception for errors when the Node type is not what was expected
H3D::TypedFieldTypeCheck::InvalidTemplateArgumentsInvalidTemplateArguments An exception thrown when the template argument list does not follow the rules defined in TypedField
H3D::X3D::IStreamInputSourceThis class is a derivative of the standard Xerxes C InputSource class
H3D::X3D::IStreamInputStreamThis class implements the BinInputStream interface to read from a istream
H3D::KeyboardNavigationTakes care of navigation using keyboard
H3D::KeySensorA KeySensor node generates events when the user presses keys on the keyboard
H3D::LibCurlResolverThe LibCurlResolver uses libcurl to resolve URLs using e.g
H3D::LinePropertiesThe LineProperties node specifies additional properties to be applied to all line geometry
H3D::LineSetThe LineSet node represents a 3D geometry formed by constructing polylines from 3D vertices specified in the coord field
H3D::LineSet::InvalidVertexCountValueThrown then vertexCount value is < 2
H3D::LoadSensorThe LoadSensor monitors the progress and success of downloading URL elements over a network
H3D::LocalFogThe 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::locationAbstract a location
H3D::LODThe 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
H3D::MagneticGeometryEffectMagneticGeometryEffect is a localized haptic effect that tries to constrain the haptic device to the surface of the given geometry
H3D::MagneticSurfaceThe 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::MagneticSurface::UpdateDampingSpecialized field which sets the damping variable in HAPI::OpenHapticsRenderer::OpenHapticsSurface when the damping field of MagneticSurface is changed
H3D::MagneticSurface::UpdateDynamicFrictionSpecialized field which sets the dynamic_friction variable in HAPI::OpenHapticsRenderer::OpenHapticsSurface when the dynamicFriction field of MagneticSurface is changed
H3D::MagneticSurface::UpdateSnapDistanceSpecialized field which sets the snap_distance variable in HAPI::OpenHapticsRenderer::OpenHapticsSurface when the snapDistance field of MagneticSurface is changed
H3D::MagneticSurface::UpdateStaticFrictionSpecialized field which sets the static_friction variable in HAPI::OpenHapticsRenderer::OpenHapticsSurface when the staticFriction field of MagneticSurface is changed
H3D::MagneticSurface::UpdateStiffnessSpecialized field which sets the stiffness variable in HAPI::OpenHapticsRenderer::OpenHapticsSurface when the stiffness field of SmoothSurface is changed
H3D::MaterialThe Material node specifies surface material properties for associated geometry nodes and is used by the X3D lighting equations during rendering
H3D::Matrix3VertexAttributeDefines a set of per-vertex 33 matrix attributes
H3D::Matrix4VertexAttributeDefines a set of per-vertex 44 matrix attributes
H3D::MatrixTransformThe 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::SFTransformedBoundSFTransformedBound maintains the routes from the owner Node's bound and matrix field to the contained TransformedBoxBound instance's boxBound and matrix field
H3D::MetadataDoubleThe metadata provided by this node is contained in the double-precision floating point numbers of the value field
H3D::MetadataFloatThe metadata provided by this node is contained in the single-precision floating point numbers of the value field
H3D::MetadataIntegerThe metadata provided by this node is contained in the integers of the value field
H3D::MetadataSetThe metadata provided by this node is contained in the metadata nodes of the value field
H3D::MetadataStringThe metadata provided by this node is contained in the strings of the value field
H3D::MFBoolThe MFBool field contains a vector of boolean values
H3D::MFColorThe MFColor field contains a vector of RGB (red-green-blue) colour triples
H3D::MFColorRGBAThe MFColorRGBA field contains a vector of RGBA (red-green-blue-alpha) colour 4-tuples
H3D::MFDoubleThe MFDouble field contains a vector of high-precision floating point numbers
H3D::MFFloatThe 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::MField< Type >::InvalidIndexThrown if the index given to getValueByIndex() is outside the boundaries
H3D::MFieldBase< Type, VectorClass, BaseField >The common base class for MField types and MFNode
H3D::MFInt32The MFInt32 field contains a vector of 32-bit integers
H3D::MFMatrix3dThe MFMatrix3d field contains a vector of Matrix3d instances
H3D::MFMatrix3fThe MFMatrix3f field contains a vector of Matrix3f instances
H3D::MFMatrix4dThe MFMatrix4d field contains a vector of Matrix4d instances
H3D::MFMatrix4fThe MFMatrix4f field contains a vector of Matrix4f instances
H3D::MFNodeMFNode is almost like any MField but it encapsulates a vector of Node pointers
H3D::MFQuaternionThe MFQuaternion field contains a vector of arbitrary Quaternion objects
H3D::MFRotationThe MFRotation field contains a vector of arbitrary Rotation objects
H3D::MFStringThe MFString field conatins a vector of strings
H3D::MFTimeThe MFTime field contains a vector of time values
H3D::MFVec2dThe MFVec2d field contains a vector of Vec2d
H3D::MFVec2fThe MFVec2f field contains a vector of Vec2f
H3D::MFVec3dThe MFVec3d field contains a vector of Vec3d
H3D::MFVec3fThe MFVec3f field contains a vector of Vec3f
H3D::MFVec4dThe MFVec4d field contains a vector of Vec4d
H3D::MFVec4fThe MFVec4f field contains a vector of Vec4f
H3D::MouseNavigationTake care of mouseNavigation
H3D::MouseSensorA sensor node for reading mouse values
H3D::MultiTexturePartially implemented
H3D::MultiTextureCoordinateMultiTextureCoordinate supplies multiple texture coordinates per vertex
H3D::MultiTextureTransformMultiTextureTransform supplies multiple texture transforms per appearance
H3D::NavigationInfoThe NavigationInfo node contains information describing the physical characteristics of the viewer's avatar and viewing model
H3D::NodeNode is the base class for all classes that can be part of the H3D scene-graph
H3D::Node::LineIntersectResult::PointingDeviceResultStructContains a list of Nodes (X3DPointingDeviceNodes) and a transformation matrix from global space to local space of the nodes
H3D::NormalThis node defines a set of 3D surface normal vectors to be used in the vector field of some geometry nodes
H3D::NormalInterpolatorThe NormalInterpolator node interpolates among a list of normal vector sets specified by the keyValue field to produce an MFVec3f value_changed event
H3D::NormalInterpolator::MFValueThe SFValue field updates the interpolated value from the fields routed to it
H3D::X3D::NoSuchDEFNameAn exception for errors when the DEF name does not exist in the DEF nodes structure
H3D::NurbsCurveThe NurbsCurve node is a geometry node defining a parametric curve in 3D space
H3D::NurbsCurve2DThe NurbsCurve2D node defines a trimming segment that is part of a trimming contour in the u,v domain of the surface
H3D::NurbsCurve::SFBoundSFBound is specialized to update from the SFBound fields routed to it
H3D::NurbsPatchSurfaceThe NurbsPatchSurface node is a contiguous NURBS surface patch
H3D::NurbsTextureCoordinateThe NurbsTextureCoordinate node is a NURBS surface existing in the parametric domain of its surface host specifying the mapping of the texture onto the surface
H3D::NurbsTrimmedSurfaceThe NurbsTrimmedSurface node defines a NURBS surface that is trimmed by a set of trimming loops
H3D::NurbsTrimmedSurface::AddContourThis field class checks whether the given node is of the right type (Contour2D)
H3D::NurbsTrimmedSurface::CheckContourThis field class checks whether the given node is of the right type (Contour2D) for adding or removing
H3D::NurbsTrimmedSurface::RemoveContourThis field class checks whether the given node is of the right type (Contour2D)
H3D::OggFileReaderOggFileReader uses the libVorbis (http://www.vorbis.com) decoder library to support Ogg Vorbis files
H3D::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 )
H3D::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
H3D::OpenHapticsOptionsSpecifies parameters to use for when rendering an object with OpenHaptics
H3D::OpenHapticsRendererHaptics renderer using OpenHaptics to render objects
H3D::OpenHapticsRenderer::AdaptiveViewportAdaptiveViewport specializes SFBool to set the appropriate default values in the HAPI::OpenHapticsRenderer used
H3D::OpenHapticsRenderer::CameraViewCameraView specializes SFBool to set the appropriate default values in the HAPI::OpenHapticsRenderer used
H3D::OpenHapticsRenderer::ShapeTypeShapeType specializes SFString to set the appropriate default OpenHaptics shape in the HAPI::OpenHapticsRenderer
H3D::OpenHapticsSurfaceSurface type for setting OpenHaptics surface parameters directly
H3D::OpenHapticsSurface::UpdateMagneticSpecialized field which sets the magnetic variable in HAPI::OpenHapticsRenderer::OpenHapticsSurface when the magnetic field of OpenHapticsSurface is changed
H3D::OrientationInterpolatorThe OrientationInterpolator node interpolates among a list of rotation values specified in the keyValue field to produce an SFRotation value_changed event
H3D::OrientationInterpolator::SFValueThe SFValue field updates the interpolated value from the fields routed to it
H3D::OrthoViewpointThe OrthoViewpoint node defines a viewpoint that provides an orthographic view of the scene
H3D::PackagedShaderA PackagedShader node describes a single file that may contain a number of shaders and combined effects
H3D::ParsableFieldThis is a field which value can be set by a string from the X3D parser
H3D::ParsableMFieldThis is a field which value can be set by a string from the X3D parser
H3D::ParticleSystemThe ParticleSystem node specifies a complete particle system
H3D::PeriodicUpdate< BaseFieldType >The PeriodicUpdate is a template modifier that changes the way the field is updated
H3D::PeriodicUpdateFieldAbstract base class for all Fields that will be updated without anyone asking for a value
H3D::PhantomDeviceA PhantomDevice is a node for handling communication with a haptics device from SensAble, such as the Phantom Omni and the Phantom Desktop haptics devices
H3D::Pixel3DTextureThe 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::PixelTextureThe 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::PlanarReflector
H3D::PlanarReflector::SFGeometryNodeSFGeometryNode is dependent on the displayList field of its encapsulated X3DGeometryNode node, i.e
H3D::PlaneSensorThe PlaneSensor node maps pointing device motion into two-dimensional translation in a plane parallel to the Z=0 plane of the local coordinate system
H3D::PlaneSensor::Set_PlaneEventsThe Set_PlaneEvents field takes care of sending trackPoint_changed, translation_changed, and offset events when they should be sent
H3D::PointEmitterThe PointEmitter node is an emitter that generates particles from a specific point in space
H3D::PointLightThe PointLight node specifies a point light source at a 3D location in the local coordinate system
H3D::PointNormalClipPlaneThis is a ClipPlane where the plane is specified with a point and a normal
H3D::PointNormalClipPlane::PlaneEqThe PlaneEq updates the plane equation from the values of the point and normal fields
H3D::PointSetThe PointSet node specifies a set of 3D points, in the local coordinate system, with associated colours at each point
H3D::PointSet::NotEnoughColorsThrown when the number of colors in the color field are less than the number of points in the coord field
H3D::Polyline2DThe Polyline2D node specifies a series of contiguous line segments in the local 2D coordinate system connecting the specified vertices
H3D::Polyline2D::SFBoundSFBound is specialized update itself from the lineSegments field of the Polyline2D node
H3D::Polypoint2DThe Polyline2D node specifies a set of vertices in the local 2D coordinate system at each of which is displayed a point
H3D::Polypoint2D::SFBoundSFBound is specialized update itself from the point field of the Polypoint2D node
yy::positionAbstract a position
H3D::PositionFunctionEffectPositionFunctionEffect takes as input three functions that controls the force in x, y and z direction
H3D::PositionInterpolatorThe PositionInterpolator node linearly interpolates among a list of 3D vectors to produce an SFVec3f value_changed event
H3D::PositionInterpolator2DThe PositionInterpolator node linearly interpolates among a list of 2D vectors to produce an SFVec2f value_changed event
H3D::PositionInterpolator2D::SFValueThe SFValue field updates the interpolated value from the fields routed to it
H3D::PositionInterpolator::SFValueThe SFValue field updates the interpolated value from the fields routed to it
H3D::ProfilesAndComponentsProfilesAndComponents is a Singleton class used for taking care of profile and component conformance in H3DAPI At the moment no checking is done when creating nodes that this node exists in the given profile
ProfileSAX2HandlersThis class implements the SAX2 ContentHandler and ErrorHandler interface in order to read profile and components information from the files in the Conformance folder
ProfileSAX2Handlers::myX3DComponentThis is the definition of a component
ProfileSAX2Handlers::myX3DNodeInformation about a node and what conformance levels fields should have
ProfileSAX2Handlers::myX3DProfileContains information about what components at what level is required to have support for this profile
H3D::ProgramShaderHe ProgramShader node defines a shader that can consist of one or more individually programmable, self contained pieces
H3D::ProgramShader::MFShaderProgramSets the profile for each ShaderProgram node that is added to it
H3D::ProtoDeclarationContainse information about a PROTO node from the X3D standard
H3D::ProtoDeclaration::FieldDeclarationClass that contains information about a field that is part of the prototype declaration
H3D::PrototypeInstanceThe PrototypeInstance is an instance of a prototyped node
H3D::ProximitySensorThe ProximitySensor node generates events when the viewer enters, exits, and moves within a region in space (defined by a box)
H3D::ProximitySensor::SetTimeThe 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
H3D::PyMatrix3dPython C Type wrapper around Matrix3d
H3D::PyMatrix3fPython C Type wrapper around Matrix3f
H3D::PyMatrix4dPython C Type wrapper around Matrix4d
H3D::PyMatrix4fPython C Type wrapper around Matrix4f
H3D::PyNodePython C Type wrapper around Node*
H3D::PyQuaternionPython C Type wrapper around Quaternion
H3D::PyRGBPython C Type wrapper around RGB
H3D::PyRGBAPython C Type wrapper around RGBA
H3D::PyRotationPython C Type wrapper around Rotation
H3D::PythonInvalidFieldTypeAn exception thrown when a field is of the wrong type when it is checked
H3D::PythonScriptInterface to the dynamic Python library for executing script code as part of the API
H3D::PyVec2dPython C Type wrapper around Vec2d
H3D::PyVec2fPython C Type wrapper around Vec2f
H3D::PyVec3dPython C Type wrapper around Vec3d
H3D::PyVec3fPython C Type wrapper around Vec3f
H3D::PyVec4dPython C Type wrapper around Vec4d
H3D::PyVec4fPython C Type wrapper around Vec4f
H3D::QuanserDeviceA QuanserDevice is a node for handling communication with a haptics device from Quanser, such as the 2-DOF Pantograph
H3D::RawImageLoaderThe RawImageLoader loads a raw data file and lets the user specify the parameters for the values directly
H3D::Rectangle2DThe 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::SFBoundSFBound is specialized update itself from the size field of the Rectangle2D node
H3D::RefCountMField< RefClass >RefCountMField is almost like any MField but it encapsulates a vector of RefCoundtedClass pointers
H3D::RefCountMField< RefClass >::InvalidIndexThrown if the index given to getValueByIndex() is outside the boundaries
H3D::RefCountSField< RefClass, BaseField >RefCountSField is almost like any SField but it encapsulates a pointer to a RefCountedClass
H3D::RenderPropertiesThe RenderProperties node specifies additional rendering options that cannot be specified with the X3D Appearance node
H3D::ResourceResolverBoth a base class for all classes that resolves resource names and contains static functions for resolving them
H3D::ResourceResolver::TmpFileNameListList of tmpfile names
H3D::RuspiniRendererHaptics renderer using a variant of the Ruspini algorithm allowing you to specify a radius on the proxy
H3D::RuspiniRenderer::ProxyRadiusProxyRadius specializes SFFloat to set the proxy radius in the HAPI::RuspiniRenderer used
H3D::ScalarInterpolatorThis node linearly interpolates among a list of SFFloat values to produce an SFFloat value_changed event
H3D::ScalarInterpolator::SFValueThe SFValue field updates the interpolated value from the fields routed to it
H3D::SceneThe Scene node is topmost node that takes care of the rendering of the scene graph both haptically and graphically
H3D::Scene::EventSinkMakes all fields up-to-date what are routed to it, with the exception of PeriodicUpdateFields
H3D::ScriptNo scripting is supported with the Script node yet
H3D::SFBoolThe SFBool field contains a single boolean value
H3D::SFColorThe SFColor field contains one RGB (red-green-blue) colour triple
H3D::SFColorRGBAThe SFColorRGBA field contains one RGBA (red-green-blue-alpha) colour 4-tuple
H3D::SFDoubleThe SFDouble field contains one high-precision floating point number
H3D::SFFloatThe 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::SFieldClassBase class for all fields created with the SField template
H3D::SFInt32The SFInt32 field contains one 32-bit integer
H3D::SFMatrix3dThe SFMatrix3d field contains a Matrix3d
H3D::SFMatrix3fThe SFMatrix3f field contains a Matrix3f
H3D::SFMatrix4dThe SFMatrix4d field contains a Matrix4d
H3D::SFMatrix4fThe SFMatrix4f field contains a Matrix4f
H3D::SFNodeSFNode is almost like any SField but it encapsulates a pointer to a Node
H3D::SFQuaternionThe SFQuaternion field contains a Quaternion
H3D::SFRotationThe SFRotation field contains one arbitrary Rotation
H3D::SFStringThe SFString field contains a string
H3D::SFTimeThe SFTime field contains a single time value
H3D::SFVec2dThe SFVec2d field contains a Vec2d
H3D::SFVec2fThe SFVec2f field contains a Vec2f
H3D::SFVec3dThe SFVec3d field contains a Vec3d
H3D::SFVec3fThe SFVec3f field contains a Vec3f
H3D::SFVec4dThe SFVec4d field contains a Vec4d
H3D::SFVec4fThe SFVec4f field contains a Vec4f
H3D::ShaderPartThe ShaderPart node defines the source for a single object to be used by a ComposedShader node
H3D::ShaderPart::SFShaderStringUpdate the string to use as shader depending from the urls given
H3D::ShaderProgramThe 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::ShapeThe Shape node has two fields, appearance and geometry, which are used to create rendered objects in the world
H3D::SimballDeviceA SimballDevice is a node for handling communication with a haptics device from ForceDimension, such as the Omega and Delta haptics devices
H3D::SimpleMovieTextureSimpleMovieTexture is a node for showing movies as textures with a simpler interface than the movie texture node
H3D::SimpleMovieTexture::DecoderManagerManages all state changes in the decoder depending on the values of the fields in SimpleMovieTexture
yy::slice< T, S >Present a slice of the top of a stack
H3D::SmoothSurfaceA SmoothSurface has no friction at all
H3D::SoundThe Sound node specifies the spatial presentation of a sound in a X3D scene
H3D::Sound::ALSoundSetupField that calls ALrender() when a field routed to it has generated an event
H3D::Sound::SFSoundSourceNodeThe SFSoundSourceNode registers the Sound node in the X3DSoundSourceNode that is put into the field
H3D::SpaceballSensorA sensor node for reading GLUT Spaceball values
H3D::SpaceWareHapticsDeviceA fake haptics device where the position and orientation is controlled via a SpaceWare device such as the SpaceMouse or SpaceTraveller
H3D::SpaceWareHapticsDevice::SetMainButtonSetMainButton is set to true if any of the buttons on the SpaceWare device is pressed
H3D::SpaceWareSensorThis is a X3DSensorNode for reading values from a 3DConnexion motion controller such as the SpaceTraveller or SpaceMouse 5000
H3D::SpaceWareSensor::AccumulateRotationThis class is an AutoUpdate class that accumulates the rotation values routed to it, i.e
H3D::SpaceWareSensor::AccumulateTranslationThis class is an AutoUpdate class that accumulates the Vec3f values routed to it, i.e
H3D::SpaceWareSensor::ResetAccumulatedRotationThis 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
H3D::SpaceWareSensor::ResetAccumulatedTranslationThis class is an AutoUpdate class that sets the field accumulatedTranslation to its input value
H3D::SpaceWareSensor::ScaleRotationUpdates itself to the Rotation routed to it where the angle is scaled by the scale factor
H3D::SpaceWareSensor::ScaleTranslationUpdates itself to the SFVec3f routed to it scaled by the scale factor
H3D::SphereThe Sphere node specifies a sphere centred at (0, 0, 0) in the local coordinate system
H3D::Sphere::SFBoundSFBound is specialized update itself from the radius field of the Sphere node
H3D::SphereSensorThe SphereSensor node maps pointing device motion into spherical rotation about the origin of the local coordinate system
H3D::SphereSensor::Set_SphereEventsThe Set_SphereEvents field takes care of sending trackPoint_changed, rotation_changed, and offset events when they should be sent
H3D::SplinePositionInterpolatorThe SplinePositionInterpolator node non-linearly interpolates among a list of 3D vectors to produce an SFVec3f value_changed event
H3D::SplinePositionInterpolator2DThe SplinePositionInterpolator2D node non-linearly interpolates among a list of 2D vectors to produce an SFVec2f value_changed event
H3D::SplinePositionInterpolator2D::SFValueThe SFValue field updates the interpolated value from the fields routed to it
H3D::SplinePositionInterpolator::SFValueThe SFValue field updates the interpolated value from the fields routed to it
H3D::SplineScalarInterpolatorThe SplineScalarInterpolator node non-linearly interpolates among a list of floats to produce an SFFloat value_changed event
H3D::SplineScalarInterpolator::SFValueThe SFValue field updates the interpolated value from the fields routed to it
H3D::SpotLightThe 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::SpringEffectSpringEffect 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::StereoInfoThe StereoInfo nis a bindable node that contains information used when rendering the scene in stereo
H3D::StringSensorA StringSensor node generates events as the user presses keys on the keyboard
H3D::SuperShapeThe SuperShape node implements a SuperShape!
H3D::SuperShape::SFCoordinateNodeThe SFCoordinateNode is a class that contain a X3DCoordinateNode
H3D::SurfaceEmitterThe SurfaceEmitter node is an emitter that generates particles from the surface of an object
H3D::SwitchThe Switch grouping node traverses zero or one of the nodes specified in the choice field
H3D::Switch::SFBoundSFBound is specialized to update from the SFBound fields routed to it
H3D::SWSNavigationTakes care of navigation with SpaceWareSensor
H3D::TexGenGeometryThe 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::SFGeometryNodeThe SFGeometryNode keeps a route between the contained X3DGeometryNode's bound field and the bound field ot the TexGenGeometry
H3D::TextThe 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::DisplayListWe extend the DisplayList to build the fonts of the X3DFontStyleNode in the fontStyle field of the Text node this DisplayList resides in
H3D::Text::SFBoundThe SFBound field is specialized to update itself from the values in the fields of the Text node
H3D::TextureBackgroundA background node that uses six individual texture nodes to compose the backdrop
H3D::TextureCoordinateThe 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::TextureCoordinate3DThe 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::TextureCoordinate4DThe 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::TextureCoordinateGeneratorTextureCoordinateGenerator supports the automatic generation of texture coodinates for geometric shapes
H3D::TextureMatrixTransformThe matrix field specifies a generalized, unfiltered 44 transformation matrix that can be used to modify the texture
H3D::TexturePropertiesTextureProperties allows fine control over a texture's application
H3D::TextureTransformThe TextureTransform node defines a 2D transformation that is applied to texture coordinates (see TextureCoordinate)
H3D::TextureTransform3DThe TextureTransform3D node defines a 3D transformation that is applied to texture coordinates (see TextureCoordinate)
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::TimeFunctionEffectTimeFunctionEffect takes as input three functions that controls the force in x, y and z direction
H3D::TimeSensorTimeSensor nodes generate events as time passes
H3D::TimeSensor::TimeHandlerThe TimeHandler field is specialized to include the handling of the TimeSensor specific fields
H3D::TimeTriggerTimeTrigger is a trigger node that generates time events upon receiving boolean events
H3D::TimeTrigger::SetTriggerTimeSpecialize to set the vaule of the triggerTime field to the current time
H3D::ToggleGroupThe ToggleGroup node enables you to enable/disable haptics and graphics rendering of its children nodes
H3D::TouchSensorA 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
H3D::TransferFunctionTextureTexture for defining a transfer function from a single value to RGBA values using H3DFunctionNode instances
H3D::TransferFunctionTexture::SFImageSFImage is overridden to update the value from the functions
H3D::TransformThe 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::MatrixSpecialize the SFMatrix4f to update the matrix from the fields in the Transform node
H3D::TransformedBoxBoundA TransformedBoxBound is a wrapper around another BoxBound and its values are the values of the BoxBound transformed by a transformation matrix
H3D::TransformedBoxBound::CenterThe Center field updates itself from the boxBound and matrix fields
H3D::TransformedBoxBound::SizeThe Size field updates itself from the boxBound and matrix fields
H3D::TransformInfoThe TransformInfo node provides information about the coordinate space it resides in in the scene graph
H3D::TraverseInfoTraverseInfo is a structure that is passed along when traversing the scene graph
H3D::TraverseInfo::InvalidHapticsDeviceIndexThrown when trying to get hold of a H3DHapticsDevice using an invalid device index
H3D::TriangleFanSetA TriangleFanSet represents a 3D shape composed of triangles that form a fan shape around the first vertex declared in each fan
H3D::TriangleFanSet::AutoNormalSpecialized field for automatically generating normals from coordinates
H3D::TriangleFanSet::InvalidFanCountThrown when fanCount value is < 3
H3D::TriangleFanSet::NotEnoughColorsThrown if the number of colors in the color field is less than the number coordinates in the coord field
H3D::TriangleFanSet::NotEnoughTextureCoordinatesThrown if the number of texture coordinates in the color field is less than the number coordinates in the coord field
H3D::TriangleSetThe TriangleSet node represents a 3D shape that represents a collection of individual triangles
H3D::TriangleSet2DThe TriangleSet2D node specifies a set of triangles in the local 2D coordinate system
H3D::TriangleSet2D::SFBoundSFBound is specialized update itself from the vertices field of the TriangleSet2D node
H3D::TriangleSet::AutoNormalSpecialized field for automatically generating normals from coordinates
H3D::TriangleSet::NotEnoughColorsThrown if the number of colors in the color field is less than the number coordinates in the coord field
H3D::TriangleSet::NotEnoughTextureCoordinatesThrown if the number of texture coordinates in the color field is less than the number coordinates in the coord field
H3D::TriangleStripSetA TriangleStripSet represents a 3D shape composed of strips of triangles
H3D::TriangleStripSet::AutoNormalSpecialized field for automatically generating normals from coordinates
H3D::TriangleStripSet::InvalidStripCountThrown when stripCount value is < 3
H3D::TriangleStripSet::NotEnoughColorsThrown if the number of colors in the color field is less than the number coordinates in the coord field
H3D::TriangleStripSet::NotEnoughTextureCoordinatesThrown if the number of texture coordinates in the color field is less than the number coordinates in the coord field
H3D::TwoSidedMaterialThis 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
H3D::TypedFieldErrorAn 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< H3D_TYPES_TEMPLATE_SPEC >The Types template can be used in the RequiredArgTypes or OptionalArgTypes arguments of a TypedField template instantiation
H3D::X3D::Convert::UnimplementedConversionTypeAn exception for errors when the conversion from a string to the type that we try convert to is not implemented
H3D::URNResolverThe URNResolver resolves URNs (Uniform Resource Name) into paths
H3D::ViewpointThe Viewpoint node defines a viewpoint that provides a perspective view of the scene
H3D::ViewpointGroupViewpointGroup is used to control display of viewpoints on the viewpoint list
H3D::ViscosityEffectViscosityEffect is a localized haptic effect
H3D::VisibilitySensorTRUE
H3D::VisibilitySensor::SetTimeSpecialize 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
yy::VrmlParserA Bison parser
yy::VrmlParser::semantic_typeSymbol semantic values
yy::VrmlParser::tokenTokens
H3D::WindPhysicsModelThe WindPhysicsModel node specifies a physics model that applies a wind effect to the particles
H3D::WorldInfoThe WorldInfo node contains information about the world
H3D::X3DAppearanceChildNodeThis is the base node type for the child nodes of the X3DAppearanceNode type
H3D::X3DAppearanceNodeThis is the base node type for all Appearance nodes
H3D::X3DBackgroundNodeX3DBackgroundNode is the abstract type from which all backgrounds inherit
H3D::X3DBindableNodeX3DBindableNode is the abstract base type for all bindable children nodes, including Background, TextureBackground, Fog, NavigationInfo, Viewpoint and DeviceInfo
H3D::X3DBindableNode::SFSetBindThe SFSetBind field calls toStackTop() and removeFromStack() on the X3DBindableNode it is in depending on the value that it is set to
H3D::X3DBoundedObjectThis X3D abstract interface type is basis for all X3D node types that have bounds specified as part of the definition
H3D::X3DChildNodeThis abstract node type indicates that the concrete nodes which are instantiated based on it may be used in children, addChildren, and removeChildren fields
H3D::X3DColorNodeThis is the base node type for color specifications in X3D
H3D::X3DComposedGeometryNodeThis is the base node type for all composed 3D geometry in X3D
H3D::X3DComposedGeometryNode::DisplayListDisplay list is extended in order to set front sidedness of triangles outside the display list
H3D::X3DCoordinateNodeThis is the base node type for all coordinate node types in X3D
H3D::X3DDragSensorNodeThis abstract node type is the base type for all drag-style pointing device sensors
H3D::X3DEnvironmentalSensorNodeThis abstract node type is the base type for all sensors
H3D::X3DEnvironmentTextureNodeThis abstract node type is the base type for all node types that specify cubic environment map sources for texture images
H3D::X3D::Convert::X3DFieldConversionErrorAn exception for errors when string to convert to a field value is invalid for the field type
H3D::X3DFogObjectX3DFogObject is the abstract type that describes a node that influences the lighting equation through the use of fog semantics
H3D::X3DFontStyleNodeThis abstract node type is the base node type for all FontStyle nodes
H3D::X3DGeometricPropertyNodeThis is the base node type for all geometric property node types defined in X3D
H3D::X3DGeometryNodeThis is the base node type for all geometry in X3D
H3D::X3DGeometryNode::BugWorkaroundDisplayListThis 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::DisplayListDisplay list is extended in order to set front sidedness of triangles outside the display list
H3D::X3DGeometryNode::SFBoundTreeThe HAPIBoundTree constructs a
H3D::X3DGroupingNodeThis abstract node type indicates that concrete node types derived from it contain children nodes and is the basis for all aggregation
H3D::X3DGroupingNode::MFChildMFChild sets up a routes from the Nodes that are added and removed from the field to the owner of the field
H3D::X3DGroupingNode::SFBoundSFBound is specialized to update from the SFBound fields routed to it
H3D::X3DInfoNodeThis is the base node type for all nodes that contain only information without visual semantics
H3D::X3DInterpolatorNodeThe abstract node X3DInterpolatorNode forms the basis for all types of interpolators specified in this clause
H3D::X3DKeyDeviceSensorNodeThis abstract node type is the base type for all sensor node types which operate using key devices
H3D::X3DLightNodeThe X3DLightNode abstract node type is the base type from which all node types that serve as light sources are derived
H3D::X3DMaterialNodeThis is the base node type for all Material nodes
H3D::X3DMetadataObjectThis abstract interface is the basis for all metadata nodes
H3D::X3DNetworkSensorNodeThis abstract node type is the basis for all sensors that generate events based on network activity
H3D::X3DNodeThis abstract node type is the base type for all nodes in the X3D system
H3D::X3DNormalNodeThis is the base node type for all normal node types in X3D
H3D::X3DNurbsControlCurveNodeThis abstract node type is the base type for all node types that provide control curve information in 2D space
H3D::X3DNurbsSurfaceGeometryNodeThe X3DNurbsSurfaceGeometryNode represents the abstract geometry type for all types of NURBS surfaces
H3D::X3DNurbsSurfaceGeometryNode::TexCoordOrNurbsTexThis field class takes as input SFNode field and checks whether this is one of the allowed textureNodes or not
H3D::X3DParametricGeometryNodeThis 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
H3D::X3DParticleEmitterNodeThe X3DParticleEmitterNode abstract type represents any node that is an emitter of particles
H3D::X3DParticlePhysicsModelNodeThe X3DParticlePhysicsModelNode is the abstract representation of any node that will apply a form of constraints on the particles after they have been generated
H3D::X3DPointingDeviceSensorNodeThis abstract node type is the base type for all pointing device sensors
H3D::X3DPointingDeviceSensorNode::SetIsActiveSpecialize field to set the isActive field
H3D::X3DPointingDeviceSensorNode::SetIsEnabledSpecialize to check if the primary pointing device button is pressed when the enabled field is set to true
H3D::X3DProgrammableShaderObjectThis abstract node type is the base type for all node types that specify arbitrary fields for interfacing with per-object attribute values
H3D::X3DPrototypeInstanceThis abstract node type is the base type for all prototype instances in the X3D system
H3D::X3D::X3DSAX2HandlersThis class implements the SAX2 ContentHandler and ErrorHandler interface in order to build an H3D scenegraph from a X3D XML file
H3D::X3D::X3DSAX2Handlers::NodeElementEncapsulate a node with its XML containerField attribute
H3D::X3DScriptNodeThe base class for script nodes
H3D::X3DSensorNodeThis abstract node type is the base type for all sensors
H3D::X3DSequencerNodeThis abstract node type is the base node type from which all Sequencers are derived
H3D::X3DSequencerNode::KeyValues< MType >Each value in the keyValue field corresponds in order to the parameter value in the key field
H3D::X3DSequencerNode::ValueChanged< TheType, KeyValuesIn >ValueChanged is a specialized class used to evaluate and set the value_changed field depending on the input to the class
H3D::X3DShaderNodeThis abstract node type is the base type for all node types which specify a programmable shader
H3D::X3DShapeNodeThis is the base node type for all Shape nodes
H3D::X3DShapeNode::BugWorkaroundDisplayListThis 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::X3DShapeNode::DisplayListDisplay list is extended in
H3D::X3DShapeNode::SFGeometryNodeSFGeometryNode is dependent on the displayList field of its encapsulated X3DGeometryNode node, i.e
H3D::X3DSoundNodeThis abstract node type is the base for all Sound nodes
H3D::X3DSoundSourceNodeThis abstract node type is used to derive node types that can emit audio data
H3D::X3DSoundSourceNode::ALSoundBufferField that calls ALrender() when a field routed to it has generated an event
H3D::X3DSoundSourceNode::TimeHandlerTimeHandler is extended to stream audio data to OpenAL buffers if the sound source is a streaming source
H3D::X3DTexture2DNodeThis abstract node type is the base type for all node types which specify 2D sources for texture images
H3D::X3DTexture2DNode::SFImageA SFNode encapsulating an Image class
H3D::X3DTexture3DNodeThis abstract node type is the base type for all node types which specify 3D sources for texture images
H3D::X3DTextureCoordinateNodeThis abstract node type is the base type for all node types which specify texture coordinates
H3D::X3DTextureNodeThis abstract node type is the base type for all node types which specify sources for texture images
H3D::X3DTextureNode::glTexImageFunctionNotDefinedThrown when a subclass to X3DTextureNode calls renderImage without defining the glTexImage () function
H3D::X3DTextureNode::InvalidTextureDimensionsThrown by renderImage () if the dimensions of an image are invalid, e.g
H3D::X3DTextureNode::OpenGLTextureErrorThrown when an OpenGL error occurs while setting up the texture
H3D::X3DTextureTransform2DNodeThis abstract node type is the base type for all node types which specify a 2D transformation of texture coordinates
H3D::X3DTextureTransformNodeThis abstract node type is the base type for all node types which specify a transformation of texture coordinates
H3D::X3DTextureTransformNode::DisplayListThe rendering of texture transformation requires the specifiation of which texture units to render the transformation for
H3D::X3DTimeDependentNodeThis abstract node type is the base node type from which all time-dependent nodes are derived
H3D::X3DTimeDependentNode::StartTimeThe 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
H3D::X3DTimeDependentNode::StopTimeThe 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
H3D::X3DTimeDependentNode::TimeHandlerThe 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
H3D::X3DTouchSensorNodeThis abstract node type is the base type for all touch-style pointing device sensors
H3D::X3DTouchSensorNode::SetTouchTimeSpecialize field to generate a touchTime event
H3D::X3DTriggerNodeThis abstract node type is the base node type from which all Triggers are derived
H3D::X3DUrlObjectThis abstract interface is inherited by all nodes that contain data located on the World Wide Web, such as AudioClip, ImageTexture and Inline
H3D::X3DVertexAttributeNodeThis abstract node type is the base type for all node types that specify per-vertex attribute information to the shader
H3D::X3DViewpointNodeThe X3DViewpointNode node defines a specific location in the local coordinate system from which the user may view the scene
H3D::X3DViewpointNode::SFOrientationThis field is used for the orientation field in order to reset the internal variables rel_pos and rel_orn used for H3DAPIs internal navigation
H3D::X3DViewpointNode::SFPositionThis field is used for the position field in order to reset the internal variables rel_pos and rel_orn used for H3DAPIs internal navigation
H3D::X3DViewpointNode::SFSumRotationThis field sums the value of the two SFRotation routed to it
H3D::X3DViewpointNode::SFSumVec3fThis field sums the value of the two SFVec3f routed to it
H3D::X3D::XMLParseErrorAn exception for errors occuring while parsing an X3D XML file

Generated on Fri Nov 7 10:29:00 2008 for H3D API by  doxygen 1.5.7