- Main Page
- Classes
- Files
- Directories

- Class List
- Class Hierarchy
- Class Members

# CHAI 3D Class List

Here are the classes, structs, unions and interfaces with brief descriptions:

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