| 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 |
| 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 |
| 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 |
| cCollisionAABBox | CCollisionAABBox contains the properties and methods of an axis-aligned bounding box, as used in the AABB collision detection algorithm |
| cCollisionBrute | CCollisionBrute provides methods to check for the intersection of a line segment with a mesh by checking all triangles in the mesh |
| 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 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 |
| cDelta3dofPointer | CDelta3dofPointer inherites from all tool properties of cGeneric3dofPointer |
| cDeltaDevice | Interface to delta and omega devices |
| cDriverSensoray626 | CDriverSensoray626 offers an interface to the Sensoray 626 boards |
| cDriverServotogo | CDriverServotogo offers an interface to the Servo2Go boards |
| 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) |
| cFreedom6S3dofPointer | CFreedom6S3dofPointer provides a cursor-like tool which is graphically rendered by a small sphere illustrating the tip of the device. The tools interacts with the enviornment by using the finger-proxy algorithm |
| cFreedom6SDevice | CFreedom6SDevice describes an interface to the Freedom6S haptic device from MPB Technologies Inc |
| 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 describes a virtual class from which all devices and hardware interfaces are derived |
| 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 |
| cGenericPotentialField | CGenericPotentialField describes a generic class to create objects which are describe by implicit functions |
| cGenericShader | This class defines a generic vertex/fragment shader, which will be subclassed by particular implementations. Shaders in CHAI are objects in the scenegraph, whose children are rendered with this shader enabled |
| cGenericTool | CGenericTool describes a generic class to create virtual tools inside a virtual environment (cWorld) and connecting them to haptic devices |
| cGLSLShader | This class is a GLSL-specific implementation of cGenericShader |
| 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 |
| cLabelPanel | This class represents a 2D panel with at least one piece of text on it, optionally including several pieces of text with colored markers next to them (like the key on a graph) |
| cLight | CLight describes an OpenGL light source, generally rendered by a cWorld object, which is typically the top of a scene graph |
| cMaterial | CMaterial describes the graphic and haptic properties of a solid |
| cMatrix3d | CMatrix3d represents a 3x3 matrix. Each cell of the matrix is composed of a double |
| 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 geometrical 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 |
| cMeta3dofPointer | CMeta3dofPointer connects a generic haptic device as a simple pointer in space. The tool is visually graphically rendered by a small sphere illustrating the tip of the device. The tool tries to connect to a a SensAble device, a ForceDimension device (delta/omega), and a Freedom-6 (in that order); if none are available it loads a virtual haptic device |
| cPanel | This class represents a rectangular panel that can be displayed within a CHAI viewport, and it is intended to be added to the front and back 2d rendering trees within the camera class. It generally behaves like a cMesh (from which it subclasses), you can give it colors, materials, textures, etc. It can also be used as a 3D rectangle, although its primary purpose is for 2D rendering |
| cPhantom3dofPointer | CPhantom3dofPointer connects the Phantom haptic device as a simple pointer in space. The tool is visually graphically rendered by a small sphere illustrating the tip of the device |
| cPhantomDevice | Class to interface with Phantom devices |
| cPotentialFieldForceAlgo | CPotentialFieldForceAlgo is an abstract class for algorithms that compute single point force contacts |
| cPrecisionClock | CPrecisionClock provides a class to manage high precision time measurments. Units are micro seconds |
| cPrecisionTimer | Manages high-rate callbacks using win32 multimedia timers. Rates up to 1kHz should be supported |
| cProxyPointForceAlgo | Implements the finger-proxy algorithm for computing interaction forces between a point force device and meshes |
| cQuaternion | CQuaternion represents rotations in quaternion form |
| cRay3D | CRay3D represents a 3D vector with an origin |
| cSegment3D | CSegment3D represents a line segment with a start and an end |
| cShapeSphere | CShapeSphere describes a simple spherical potential field |
| cShapeTorus | CShapeTorus describes a simple torus potential field |
| cTexture2D | CTexture2D describes a 2D bitmap texture used for OpenGL texture-mapping |
| cTriangle | CTriangle defines a triangle, typically bound to a mesh for graphic rendering |
| cVBOMesh | This class is a replacement for cMesh that uses vertex buffers for rendering. It allows for much faster rendering, but requires hardware support for VBO's and does not allow vertices to be moved around without re-initializing the VBO |
| cVector3d | CVector3d represents a 3D vector with components X, Y and Z |
| 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 |
| 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 |
