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