# 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
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

CHAI3D 2.0.0 documentation
Please address any questions to support@chai3d.org
(C) 2003-2009 - CHAI 3D
All Rights Reserved.