| cBitmap | This class provides functionalities to display a bitmap image |
| cCallback | CCallback is an abstract class that allows subclasses to define a single callback function, for example to be called by a device when it's time to compute haptic forces. This feature is _not_ supported by all devices; see cGenericDevice::setCallback() |
| cCamera | CCamera describes a virtual Camera located inside the world. Its job in life is to set up the OpenGL projection matrix for the current OpenGL rendering context. The default camera looks down the negative x-axis. OpenGL folks may wonder why we chose the negative x-axis... it turns out that's a better representation of the standard conventions used in general robotics |
| cClippingPlane | Struct used for enabling arbitrary clipping planes after the viewing matrix has been set up |
| cCollisionAABB | CCollisionAABB provides methods to create an Axis-Aligned Bounding Box collision detection tree, and to use this tree to check for the intersection of a line segment with a mesh |
| cCollisionAABBBox | CCollisionAABBox contains the properties and methods of an axis-aligned bounding box, as used in the AABB collision detection algorithm |
| cCollisionAABBInternal | CCollisionAABBInternal contains methods to set up internal nodes of an AABB tree and to use them to detect for collision with a line |
| cCollisionAABBLeaf | CCollisionAABBLeaf contains methods to set up leaf nodes of an AABB tree and to use them to detect for collision with a line |
| cCollisionAABBNode | CCollisionAABBNode is an abstract class that contains methods to set up internal and leaf nodes of an AABB tree and to use them to detect for collision with a line |
| cCollisionBrute | CCollisionBrute provides methods to check for the intersection of a line segment with a mesh by checking all triangles in the mesh |
| cCollisionEvent | CCollisionEvent stores all information related to the intersection (or collision) between an segment and an object |
| cCollisionRecorder | CCollisionRecorder stores a list of collision events |
| cCollisionSettings | This structure contains a list of settings which are passed to the collision detector when checking for a collision |
| cCollisionSpheres | CCollisionSpheres provides methods to create a sphere tree for collision detection, and to use this tree to check for the intersection of a line with a mesh |
| cCollisionSpheresEdge | CCollisionSpheresEdge defines edges of shape primitives |
| cCollisionSpheresGenericShape | CCollisionSpheresGenericShape is an abstract class for shape primitives (such as triangles or lines) which are surrounded by spheres for the collision detector |
| cCollisionSpheresLeaf | CCollisionSpheresLeaf defines leaf nodes of the collision sphere tree and provides methods for constructing the nodes and using them to determine collisions |
| cCollisionSpheresLine | CCollisionSpheresLine defines a line primitive that may collide with other primitives. It is used for instance by the proxy algorithm |
| cCollisionSpheresNode | CCollisionSpheresNode defines internal nodes of the collision sphere tree and provides methods for constructing the nodes and using them to determine collisions |
| cCollisionSpheresPoint | CCollisionSpheresPoint defines points used in the primitive shapes |
| cCollisionSpheresSphere | CCollisionSpheresSphere is an abstract class for nodes of the collision sphere tree |
| cCollisionSpheresTri | CCollisionSpheresTri defines the triangle primitives that make up the mesh and are bounded by the collision spheres. It is essentially just a wrapper around a cTriangle object, to which it has a pointer (m_original) |
| cColorb | CColorb describes a color composed of 4 bytes |
| cColorf | CColorf describes a color composed of 4 GLfloats |
| cDeltaDevice | CDeltaDevice implements an interface to the omega.x and delta.x haptic devices from Force Dimension |
| cDriverSensoray626 | CDriverSensoray626 offers an interface to the Sensoray 626 boards |
| cDriverServotogo | CDriverServotogo offers an interface to the Servo2Go boards |
| cEffectMagnet | CEffectMagnet models the reaction force on a tool located near a magnet field |
| cEffectStickSlip | CEffectStickSlip models a stick and slip effect |
| cEffectSurface | CEffectSurface models the reaction force of on tool pushing against the surface of an object |
| cEffectVibration | CEffectVibration models force vibrations by defining a frequency and amplitude |
| cEffectViscosity | CEffectViscosity models the reaction force of a tool moving through a viscous environment |
| cFalconDevice | CFalconDevice describes an interface to the Falcon haptic device from Novint Technlogies |
| cFileLoaderBMP | CFileLoaderBMP provides a class to load BMP bitmap images into memory |
| cFileLoaderTGA | Class that loads TGA files |
| cFont | CFont is a generic and pure virtual Font interface, to be subclassed by platform-specific implementations. For the simplest, most portable approach, use this class and the static method createFont", which returns an actual Font object. You may also create subclass Font types directly (see below). Specific implementations can be found later in this file |
| cFreedom6SDevice | CFreedom6SDevice describes an interface to the Freedom6S haptic device from MPB Technologies Inc |
| cGELLinearSpring | CGELLinearSpring models a linear spring between two mass particles |
| cGELMassParticle | CGELMassParticle defines a simple mass particle point |
| cGELMesh | CGELMesh inherits from cMesh and integrate a skeleton model for deformation simulation |
| cGELSkeletonLink | CGELSkeletonLink models a link between two nodes |
| cGELSkeletonNode | CGELSkeletonNode defines a dynamic node within the skeleton |
| cGELVertex | CGELVertex implement a cVertex class with a mass particle for simulating deformable objects |
| cGELWorld | CGELWorld implements a world to handle deformable objects within CHAI 3D |
| cGELWorldCollision | CGELWorldCollision provides a collision detection model to support deformable objects |
| cGeneric3dofPointer | CGeneric3dofPointer represents a haptic tool that can apply forces in three degrees of freedom and maintains three or six degrees of device pose. |
| cGenericCollision | CGenericCollision is an abstract class for collision-detection algorithms for meshes with line segments |
| cGenericDevice | CGenericDevice Provides an general interface to communicate with hardware devices. A number of constants define a set of generic commands supported by the cGenericDevice:command method. For each generic command, we describe the data type and information that must be passed by parameter for index and data. command contains of course the command number corresponding to the following list of command constants |
| cGenericEffect | CGenericEffect provides a base class to program haptic effects (force models) when a virtual tool interacts with objects of a virtual environment |
| cGenericHapticDevice | CGenericHapticDevice describes a virtual class from which all 2D or 3D point contact haptic devices are derived. These include for instance the delta.x, omega.x or Phantom haptic devices |
| cGenericObject | This class is the root of basically every render-able object in CHAI. It defines a reference frame (position and rotation) and virtual methods for rendering, which are overloaded by useful subclasses. |
| cGenericPointForceAlgo | CGenericPointForceAlgo is an abstract class for algorithms that compute single point force contacts |
| cGenericTexture | CGenericTexture implements a base class for handling OpenGL textures |
| cGenericTool | CGenericTool describes a generic class to create virtual tools inside a virtual environment (cWorld) and connecting them to haptic devices |
| cGenericType | Definition of an abstract type |
| cGLUTBitmapFont | OpenGL Fonts provided with the GLUT library |
| cHapticDeviceHandler | This class implements a manager which lists the different devices available on your computer and provides handles to them |
| cHapticDeviceInfo | Provides a structure which can hold technical specifications about a particular haptic device |
| cImageLoader | CImageLoader provides a class to load images files into memory. The real work is deferred to specific files that know how to load specific image file types |
| cInteractionEvent | CInteractionEvent stores all information related to the intersection between a point and an object |
| cInteractionRecorder | CInteractionRecorder stores a list of interaction events |
| cInteractionSettings | This structure contains a list of settings which are passed to the interaction detector when checking for an interaction |
| cLabel | This class provides functionalities to display one line of text |
| cLight | CLight describes an OpenGL light source, generally rendered by a cWorld object, which is typically the top of a scene graph. By default, lights are directional and non-spot |
| cMaterial | CMaterial provide a description for handling OpenGL graphic material properties. These include: ambient color, diffuse color, specular color, emissive color, and shininess. |
| cMatrix3d | CMatrix3d represents a 3x3 matrix. Each cell of the matrix is composed of a double. This matrix class also provides as simple set of methods to handle floating point arithmetic operations |
| cMatrixGL | CHAI describes rotations using 3x3 rotation matrices (cMatrix3d) and 3D vectors (cVector3d) to express position or translation. On the OpenGL side 4x4 matrices are required to perform all geometric transformations. cMatrixGL provides a structure which encapsulates all the necessary functionality to generate 4x4 OpenGL transformation matrices from 3D position vectors and rotation matrices. |
| cMesh | CMesh represents a collection of vertices, triangles, materials, and texture properties that can be rendered graphically and haptically |
| cMyCustomDevice | CMyCustomDevice provides the structure in which you can very easily interface CHAI 3D to your custom haptic device. |
| cODEGenericBody | CODEGenericBody is a base class for modeling any ODE dynamic body |
| cODEWorld | CODEWorld implements a virtual world to handle ODE based objects (cODEGenericBody) |
| cODEWorldCollision | CODEWorldCollision provides a collision detection model to support ODE objects modeled under the CHAI framework |
| cPhantomDevice | CPhantomDevice describes an interface to the Phantom haptic devices from Sensable Technologies |
| cPotentialFieldForceAlgo | CPotentialFieldForceAlgo is an abstract class for algorithms that compute single point force contacts |
| cPrecisionClock | CPrecisionClock provides a class to manage high-precision time measurements. All measurements are in seconds unless otherwise-specified |
| cProxyPointForceAlgo | Implements the finger-proxy algorithm for computing interaction forces between a point force device and meshes |
| cQuaternion | CQuaternion can be used to represents rotations in quaternion form. Simple floating point arithmetic operations are provided too |
| cRay3d | CRay3d represents a 3D vector with an origin |
| cSegment3d | CSegment3d represents a line segment with a start and an end |
| cShapeLine | CShapeLine describes a simple line potential field |
| cShapeSphere | Implementation of a virtual sphere shape |
| cShapeTorus | CShapeTorus describes a simple torus potential field |
| cStickSlipStatus | |
| cTexture2D | CTexture2D describes a 2D bitmap texture used for OpenGL texture-mapping |
| cThread | CThread provides a class to manage threads |
| cTimestampPos | Provides a structure to store a position with a time stamp |
| cTimestampRot | Provides a structure to store an orientation frame with a time stamp |
| cTimestampValue | Provides a structure to store a double value with a time stamp |
| cTriangle | CTriangle defines a triangle, typically bound to a mesh for graphic rendering |
| cVector3d | This vector class provides storage for a 3 dimensional double precision floating point vector as well as simple floating point arithmetic operations |
| cVertex | CVertex defines a point in 3 dimensional space and the associated rendering properties (position, color, texture coordinate, and surface normal) |
| cViewport | CViewport describes a two-dimensional window for rendering an OpenGL scene. Basically this class encapsulates an OpenGL rendering context. Creating a window is left to the application programmer, since that will depend on the development environment that you're using. Once you have a window handle, use this class to bind it to an OpenGL context |
| cVirtualDevice | Class which interfaces with the virtual device |
| cWin32BitmapFont | A 2D, texture-based, win32-specific implementation of cFont |
| cWorld | CWorld defines the typical root of the CHAI scene graph. It stores lights, allocates textures, and serves as the root for scene-wide collision detection |