CHAI 3D Class List

Here are the classes, structs, unions and interfaces with brief descriptions:
cBitmapThis class provides functionalities to display a bitmap image
cCallbackCCallback 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()
cCameraCCamera 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
cCollisionAABBCCollisionAABB 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
cCollisionAABBInternalCCollisionAABBInternal contains methods to set up internal nodes of an AABB tree and to use them to detect for collision with a line
cCollisionAABBLeafCCollisionAABBLeaf contains methods to set up leaf nodes of an AABB tree and to use them to detect for collision with a line
cCollisionAABBNodeCCollisionAABBNode 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
cCollisionAABBoxCCollisionAABBox contains the properties and methods of an axis-aligned bounding box, as used in the AABB collision detection algorithm
cCollisionBruteCCollisionBrute provides methods to check for the intersection of a line segment with a mesh by checking all triangles in the mesh
cCollisionSpheresCCollisionSpheres 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
cCollisionSpheresEdgeCCollisionSpheresEdge defines edges of shape primitives
cCollisionSpheresGenericShapeCCollisionSpheresGenericShape is an abstract class for shape primitives (such as triangles or lines) which are surrounded by spheres for the collision detector
cCollisionSpheresLeafCCollisionSpheresLeaf defines leaf nodes of the collision sphere tree and provides methods for constructing the nodes and using them to determine collisions
cCollisionSpheresLineCCollisionSpheresLine defines a line primitive that may collide with other primitives. It is used by the proxy algorithm
cCollisionSpheresNodeCCollisionSpheresNode defines internal nodes of the collision sphere tree and provides methods for constructing the nodes and using them to determine collisions
cCollisionSpheresPointCCollisionSpheresPoint defines points used in the primitive shapes
cCollisionSpheresSphereCCollisionSpheresSphere is an abstract class for nodes of the collision sphere tree
cCollisionSpheresTriCCollisionSpheresTri 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)
cColorbCColorb describes a color composed of 4 bytes
cColorfCColorf describes a color composed of 4 GLfloats
cDelta3dofPointerCDelta3dofPointer inherites from all tool properties of cGeneric3dofPointer
cDeltaDeviceInterface to delta and omega devices
cDriverSensoray626CDriverSensoray626 offers an interface to the Sensoray 626 boards
cDriverServotogoCDriverServotogo offers an interface to the Servo2Go boards
cFileLoaderBMPCFileLoaderBMP provides a class to load BMp bitmap images into memory
cFileLoaderTGAClass that loads TGA files
cFontCFont 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)
cFreedom6S3dofPointerCFreedom6S3dofPointer 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
cFreedom6SDeviceCFreedom6SDevice describes an interface to the Freedom6S haptic device from MPB Technologies Inc
cGeneric3dofPointerCGeneric3dofPointer represents a haptic tool that can apply forces in three degrees of freedom and maintains three or six degrees of device pose
cGenericCollisionCGenericCollision is an abstract class for collision-detection algorithms for meshes with line segments
cGenericDeviceCGenericDevice describes a virtual class from which all devices and hardware interfaces are derived
cGenericObjectThis 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
cGenericPointForceAlgoCGenericPointForceAlgo is an abstract class for algorithms that compute single point force contacts
cGenericPotentialFieldCGenericPotentialField describes a generic class to create objects which are describe by implicit functions
cGenericShaderThis 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
cGenericToolCGenericTool describes a generic class to create virtual tools inside a virtual environment (cWorld) and connecting them to haptic devices
cGLSLShaderThis class is a GLSL-specific implementation of cGenericShader
cImageLoaderCImageLoader 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
cLabelPanelThis 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)
cLightCLight describes an OpenGL light source, generally rendered by a cWorld object, which is typically the top of a scene graph
cMaterialCMaterial describes the graphic and haptic properties of a solid
cMatrix3dCMatrix3d represents a 3x3 matrix. Each cell of the matrix is composed of a double
cMatrixGLCHAI 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
cMeshCMesh represents a collection of vertices, triangles, materials, and texture properties that can be rendered graphically and haptically
cMeta3dofPointerCMeta3dofPointer 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
cPanelThis 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
cPhantom3dofPointerCPhantom3dofPointer 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
cPhantomDeviceClass to interface with Phantom devices
cPotentialFieldForceAlgoCPotentialFieldForceAlgo is an abstract class for algorithms that compute single point force contacts
cPrecisionClockCPrecisionClock provides a class to manage high precision time measurments. Units are micro seconds
cPrecisionTimerManages high-rate callbacks using win32 multimedia timers. Rates up to 1kHz should be supported
cProxyPointForceAlgoImplements the finger-proxy algorithm for computing interaction forces between a point force device and meshes
cQuaternionCQuaternion represents rotations in quaternion form
cRay3DCRay3D represents a 3D vector with an origin
cSegment3DCSegment3D represents a line segment with a start and an end
cShapeSphereCShapeSphere describes a simple spherical potential field
cShapeTorusCShapeTorus describes a simple torus potential field
cTexture2DCTexture2D describes a 2D bitmap texture used for OpenGL texture-mapping
cTriangleCTriangle defines a triangle, typically bound to a mesh for graphic rendering
cVBOMeshThis 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
cVector3dCVector3d represents a 3D vector with components X, Y and Z
cVertexCVertex defines a point in 3 dimensional space and the associated rendering properties (position, color, texture coordinate, and surface normal)
cViewportCViewport 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
cVirtualDeviceClass which interfaces with the virtual device
cWorldCWorld defines the typical root of the CHAI scene graph. It stores lights, allocates textures, and serves as the root for scene-wide collision detection

Generated on Mon Jun 11 09:41:46 2007 for CHAI 3D by  doxygen 1.5.2