Main Page Class Hierarchy Compound List File List Compound Members

Crystal Space Compound List

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

csAbsoluteLayout (This is just for completness)
csAnimatedPixmap (A pixmap with a 2d animation)
csAnimationTemplate (A 2d animation template. This class is used to create animated pixmaps)
csApp (This class is a top-level CrystalSpace Windowing Toolkit object)
csApp::csAppPlugin (The iComponent interface)
csArchive (This class can be used to work with standard ZIP archives)
csAudioStreamDescription (Audio stream description structure)
csBackground (This class is meant for displaying textured or gradiented backgrounds)
csBasicVector (This is a lightweight base class for containers)
csBezierCurve (A specific curve implementation for Bezier curves)
csBezierTemplate (A specific curve implementation for Bezier curve template)
csBitSet (A BitSet is an array of bits)
csBorderConstraint (This subclass of csLayoutConstraint additionally stores the location of the attached control)
csBox2 (A bounding box in 2D space)
csBox3 (A bounding box in 3D space)
csBoxClipper (Able to clip convex polygons to a rectangle (such as the screen))
csBoxLayout (Components are scaled to fit in one row or one column of the canvas)
csBSpline (A B-spline)
csBspNode (A BSP node)
csBspNode2D (A 2D BSP node)
csBspPolygon (This class represents a polygon which can be inserted dynamically in a BSP tree)
csBspPolygonFactory (A factor for creating instances of csBspPolygon)
csBspTree (The BSP tree)
csBspTree2D (The BSP tree)
csBumpMap (A class representing a bumpmap)
csButton (The Button class implements different types of push buttons)
csButtonSkin (This class defines the interface for a button skin slice)
csCamera (A camera positioned in the 3D world)
csCameraPosition (A camera position)
csCameraPositionList (List of camera positions for the engine)
csCatmullRomSpline (A CatmullRom spline)
csCBuffer (The CBuffer)
csCBufferCube (A cbuffer cube is a set of six c-buffers arranged in a cube)
csCBufferLine (A line in the CBuffer)
csCBufferPersp (Subclass of csCBuffer which adds perspective correction of 3d polygons)
csCBufferSpan (A simple span in a CBuffer line)
csCheckBox (Close child of csButton class)
csClipInfo (Structure for use with ClipToPlane)
csClipper (Abstract parent to all 2D clipping objects)
csCodecDescription (Codec description structure)
csCollection (A collection object is for conveniance of the script language)
csCollectionList (List of collections for the engine)
csColliderWrapper (This is a conveniance object that you can use in your own games to attach an iCollider object (from the CD plugin system) to any other csObject (including CS entities))
csCollisionPair (A structure used to return collision pairs)
csColor (A class used to represent a color in RGB space)
csColorScheme (This structure is used to change color scheme)
csColorWheel (Color wheel static control)
csCommandLineHelper (This class can be used to help parsing the commandline)
csCommandLineParser (A utility class that makes it easier to parse the command line)
csComponent (Graphics system component: a menu, window etc.<)
csConfigAccess (This is a simple convenience class that can be used to deal with the sytem config manager)
csConfigFile (Configuration file which implements the iConfigFile SCF interface)
csConfigManager (A configuration manager makes a number of individual configuration files appear to be a single configuration object)
csConstraintVector (The layout classes collect the constraints in here)
csCrossHalo (This is a halo which resembles a cross)
csCrystalBall (This is an attempt to provide a massdetection of backfaced polygons)
csCubicSpline (A cubic spline)
csCurve (This is an abstract class for all curves in Crystal Space)
csCurveTemplate (A curve template)
csCurveTesselated (Tesselated curve)
csDataBuffer (This is a implementation of iDataBuffer interface)
csDataObject (A generic data object)
csDataStream (This class can be used as a wrapper around a data buffer for easy stream-like access)
csDebuggingGraph (This is a static class that helps with debugging)
csDefaultButtonSkin (This is the default skin for buttons)
csDefaultDialogSkin (This is the default skin for dialogs)
csDefaultListBoxItemSkin (This is the default skin for listbox items)
csDefaultListBoxSkin (This is the default skin for listboxes)
csDefaultScrollBarSkin (This is the default skin for scroll bars)
csDefaultTitlebarSkin (This is the default skin for window titlebars)
csDefaultVertexArrayPool (This is a default implementation of csVertexArrayPool)
csDefaultWindowSkin (This is the default skin for windows)
csDialog (The Dialog class is a single-colored canvas which contains a number of child controls)
csDialogSkin (This class defines the interface for a dialog skin slice)
csDIntersect3 (Some functions to perform various intersection calculations with 3D line segments)
csDLinkList (This class implements a doubly-linked list)
csDLListItem (This structure should not need to be accessed directly)
csDMath3 (Various assorted 3D mathematical functions)
csDMatrix3 (A 3x3 matrix)
csDPlane (A plane in 3D space)
csDSquaredDist (Some functions to perform squared distance calculations)
csDVector3 (A 3D vector)
csDynLight (Class for a dynamic light)
csEdgeIterator (An iterator to iterate over all edges)
csEngine (The 3D engine)
csEngineConfig (Object which implements iConfig interface on behalf of csEngine)
csEngineMeshList (A list of meshes for the engine)
csEvent (This class represents a system event.<)
csEventOutlet (A class which implements the iEventOutlet interface)
csEventQueue (This class represents a general event queue)
csFileTime (File time structure - used to query and set the last-modification time of a file)
csFlags (Set of flags which can be accessed through masks)
csFlareComponent (Structure used to keep flare component information)
csFlareHalo (This halo is used for (solar)flares)
csFlowLayout (In a flow layout components are displayed in a row and wraped at parents boundaries)
csFog (Fog structure)
csFogInfo (Information for vertex based fog)
csFrustum (A general frustum)
csFrustumContext (This structure keeps track of the current frustum context)
csFrustumView (This structure represents all information needed for the frustum visibility calculator)
csGenerateImage (This class will compute a texture for a terrain)
csGenerateImageLayer (This class is used to store the layers of textures per value)
csGenerateImageTexture (A base class which represents a texture that can be displayed on the terrain)
csGenerateImageTextureBlend (A class for a texture that is made by blending together other textures based on a value)
csGenerateImageTextureSingle (A class for a single texture)
csGenerateImageTextureSolid (A class for a solid coloured texture)
csGenerateImageValue (A base class which represents a value that can be computed for blending purposes for each pixel)
csGenerateImageValueFunc (This class will generate a value using a given function)
csGenerateImageValueFuncConst (This class will generate a constant value)
csGenerateImageValueFuncTex (This class will generate a value using a texture)
csGraphicsPipeline (Graphics System pipeline class <)
csGrid (This is the grid object itself)
csGridBagConstraint (CsGridBagLayout is the most flexible layout class)
csGridCell (The following class collects properties for drawing the cell and acts as a container for the csComponent (i.e)
csGridLayout (Components are displayed in a grid fashion)
csGridView (The GridView displays a continuous rectangular region of the grid)
csHalo (This is the basic class for all types of halos)
csHashElement (An element inside the hashmap (private element))
csHashIterator (An iterator to iterate over elements in the hashmap)
csHashIteratorReversible (A csHashIterator that knows about csHashMapReversible's reverse hash)
csHashMap (This is a general hashmap)
csHashMapReversible (A csHashMap that maintains a reverse hash for indexing key strings by keys)
csHashSet (This class implements a basic set for objects)
csHint (This component will display "floating hints", which will vanish as soon as you move the mouse or press a key)
csHintManager (The "hint manager" keeps track of all hints and associated components, and creates the appropiate csHint when it detects mouse is not moved for too long time)
csImageArea (This structure is used for saving/restoring areas of screen)
csImageFile (An abstract class representing an abstract image)
csImageMemory (This class represents a block of memory in the true colour format only)
csInitializer (This class contains several static member functions that can help setup an application)
csInputBinder (Bind an input event to a pointer to a variable, so that that variable will reflect the state of a given key, button or axis)
csInputDriver (Superclass of all the generic input drivers)
csInputLine (The Input Line class implements a rectangular are where user can enter any text)
csIntersect2 (Some functions to perform various intersection calculations with 2D line segments)
csIntersect3 (Some functions to perform various intersection calculations with 3D line segments)
csJoystickDriver (Generic Joystick driver.<)
csKeyboardAccelerator (A keyboard accelerator is a invisible component which monitors all events and if it sees a keyboard event which matches one of the predefined combinations it emmits a corresponding event)
csKeyboardDriver (Generic Keyboard Driver.<)
csKeyValuePair (A Key Value pair)
csLayout (CsLayout is our baseclass for various derived classes like csFlowLayout, csBoxLayout, csGridBagLayout and others)
csLayout2 (CsLayout2 extends csLayout to take the maximum layout size and aligning along the x and y axis into account)
csLayoutConstraint (CsLayoutConstraint is a basic constraint used for positioning a control in a csLayout derived component)
csLight (Superclass of all positional lights)
csLightFlareHalo (This class is used to keep track of visible Flares)
csLightHalo (This is used to keep track of halos.<)
csLightingPolyTexQueue (This is user-data for iFrustumView for the lighting process)
csLightList (List of lights for a sector)
csLightMap (The static and all dynamic lightmaps for one polygon)
csLightPatch (A light patch)
csLightPatchPool (This is an object pool which holds objects of type csLightPatch)
csListBox (List box class is a rectangle which contains a number of list box items)
csListBoxItem (This class encapsulates a menu item)
csListBoxItemSkin (This class defines the interface for a listbox item skin slice)
csListBoxSkin (This class defines the interface for a listbox skin slice)
csMapNode (A node)
csMaterial (A material class)
csMaterialList (This class is used to hold a list of materials)
csMaterialWrapper (CsMaterialWrapper represents a texture and its link to the iMaterialHandle as returned by iTextureManager)
csMath2 (Various functions in 2D, such as 2D vector functions)
csMath3 (Various assorted 3D mathematical functions)
csMatrix2 (A 2x2 matrix)
csMatrix3 (A 3x3 matrix)
csMD5 (This is am encapsulation of a C-implementation of MD5 digest algorithm by Peter Deutsch <ghost@aladdin.com>)
csMemFile (Essentially a raw memory buffer which implements the abstract iFile interface)
csMemoryMappedIO (Defines a simple memory-mapped IO class that is portable. Requires that data be organized in fixed block sizes)
csMenu (The Menu class represents two types of menu: vertical (popup) menus and bar menus)
csMenuItem (This class encapsulates a menu item)
csMeshedPolygon (A polygon)
csMeshFactoryFactoryList (Subclass of csMeshFactoryList to hold the children of another mesh factory)
csMeshFactoryList (A list of mesh factories)
csMeshFactoryWrapper (The holder class for all implementations of iMeshObjectFactory)
csMeshList (General list of meshes)
csMeshMeshList (Subclass of csMeshList to hold the children of another mesh object)
csMeshWrapper (The holder class for all implementations of iMeshObject)
csApp::csModalInfo (A structure for keeping modal information on a stack)
csModelDataTools (A set of utility functions to deal with model data components)
csMouse (This class handles mouse pointer and generates mouse events.<)
csMouseDriver (Generic Mouse Driver.<)
csMousePointer (This class encapsulates mouse pointer)
csMovable (This class represents an entity that can move in the engine)
csMovableSectorList (A list of sectors as the movable uses it)
csNamedObjectVector (This class is intended as a wrapper around an existing csVector)
csNamedObjVector (CsNamedObjVector is a version of csObjVector that assumes all its components are csObject's which can be examined by name etc)
csNetworkDriverCapabilities (Network driver capabilities structure)
csNodeIterator (A node iterator)
csNotebook (A notebook (OS/2 term, Windows term "property shit") is a collection of dialogs enclosed in a single window)
csNovaHalo (This halo has a center with a number of spokes)
csObject (A generic csObject class)
csObjectPool (This is a helper class for DECLARE_OBJECT_POOL)
csObjectRegistry (This is an implementation of iObjectRegistry)
csObjVector (CsObjVector is a version of csVector which assumes its components are iBase heirs)
csOctree (The octree)
csOctreeNode (An octree node)
csOrthoTransform (A class which defines a reversible transformation from one coordinate system to another by maintaining an inverse transformation matrix)
csPaletteExport (Control palette export structure)
csPath (A path in 3D)
csPixelFormat (Structure describing the pixel format)
csPixmap (This class is an simple set of inline routines good as an abstraction for simple 2D sprites)
csPlane2 (A plane in 2D space)
csPlane3 (A plane in 3D space)
csPluginLoader (This utility class helps to load plugins based on request, config file, and commandline)
csPluginManager (This is the standard implementation of the plugin manager)
csPoint (A 2D point object)
csPolEdge (A private structure inside the hashmap)
csPolEdgeIterator (An iterator to iterate over all polygons sharing some edge)
csPoly2D (The following class represents a general 2D polygon with a bounding box)
csPoly2DEdges (The following class represents a general 2D polygon represented with edges instead of vertices)
csPoly2DEdgesPool (This is an object pool which holds objects of type csPoly2DEdges)
csPoly2DFactory (This factory is responsible for creating csPoly2D objects or subclasses of csPoly2D)
csPoly2DPool (This is an object pool which holds objects of type csPolygon2D)
csPoly3D (The following class represents a general 3D polygon)
csPolygon2D (The following class represents a 2D polygon (the 2D coordinates are perspective corrected coordinates).<)
csPolygon2DFactory (Factory to create csPolygon2D objects)
csPolygon2DQueue (A queue for polygon 2D objects to render at a later time)
csPolygon3D (This is our main 3D polygon class)
csPolygonArray (An dynamic array of csPolygon3D objects)
csPolygonClipper (Can be used for clipping any polygon against any other convex polygon)
csPolygonEdges (A class representing all edges in a set of polygons)
csPolygonInt (This class indicates what methods a class should use in order to be a 'polygon')
csPolygonIntArray (An array of csPolygonInt pointers)
csPolygonIntFactory (An abstract factory class to create specific instances of csPolygonInt)
csPolygonIntPool (This is an object pool which holds objects of type csPolygonInt)
csPolygonLightInfo (Structure containing lighting information valid for all types of polygons)
csPolygonStub (An object stub)
csPolygonStubFactory (A csPolygonStub factory)
csPolygonStubPool (This is an object pool which holds objects of type csPolygonStub)
csPolygonTree (A general polygon tree)
csPolygonTreeNode (A general node in a polygon tree)
csPolyIndexed (The following class represents a general polygon)
csPolyPlane (This class represents a polygon plane)
csPolyTexFlat (This structure contains all required information for flat-shaded (do not mix with flat-colored!) texture mapped (or flat-shaded) polygons)
csPolyTexGouraud (Structure containing information about texture mapping and vertex colors for Gouraud-shaded polygons)
csPolyTexLightMap (Structure containing all required information for lightmapped polygons)
csPolyTexture (This class represents a lighted texture for a polygon)
csPolyTexType (Kind of texturing that is used for a 3D polygon)
csPolyTreeBBox (This class represents a (dynamic) object that can be placed in a polygon tree (BSP, octree, ...))
csPolyTxtPlane (This class represents a texture plane)
csPooledVertexArrayPool (This is another implementation of csVertexArrayPool)
csPortal (This class represents a portal)
csPrefixConfig (This is an implementation of iConfigFile that stores an ID string at construction, which it then prepends to all config keys on read/write operations)
csProcDots (Random dots (demonstration procedural texture))
csProcFire (Plasma)
csProcPlasma (Plasma)
csProcSky (A sky, this represents a whole sphere of sky - so multiple polygons can be rendered to)
csProcSkyTexture (A polygon of a sky)
csProcWater (Plasma)
csProgressPulse (Simple twirling textual cursor built out of the characters '-', '\', '|', and '/')
csQuaternion (Class for a quaternion)
csRadCurve (A radiosity curve, containing lightmap patches, the lumels)
csRadElement (A radiosity Element, containing lightmap patches, the lumels)
csRadioButton (Close child of csButton class)
csRadiosity (Calculates radiosity)
csRadList (All csRadPolys, keeps them sorted on priority)
csRadPoly (A radiosity polygon, containing lightmap patches, the lumels)
csRadTree (CsRadTree is a binary tree, used to store RadPolys by csRadList)
csRandomGen (Portable random number generator class.<)
csRect (Rectangle class: simple class for manipulating 2D rectangles)
csRectRegion (A rect region is a class that implements splittable 2d rectangles)
csRegion (A region)
csRenderContext (This structure keeps track of the current render context)
csRenderContextFrustum (This structure holds the current render context frustum)
csRenderQueueSet (This class contains a list of rendering queues, each of which is a list of mesh wrappers)
csRenderView (This structure represents all information needed for drawing a scene)
csRestrictedAccessVector (Subclass of csVector that restricts access to the contained objects)
csReversibleTransform (A class which defines a reversible transformation from one coordinate system to another by maintaining an inverse transformation matrix)
csRGBcolor (An RGB color)
csRGBFloatLightMap (A small class encapsulating an RGB lightmap)
csRGBpixel (An RGB pixel)
csRGBVector (This is a vector class that expects you to push csRGBcolor structs onto it)
csSchedule (Easy way to get timers in applications)
csScrollBar (The ScrollBar component class is used to scroll left/right or up/down windows whose content does not fit into their size)
csScrollBarSkin (This class defines the interface for a scrollbar skin slice)
csScrollBarStatus (Scroll bar range structure)
csSector (A sector is a container for objects)
csSectorLightList (A list of lights for a sector)
csSectorMeshList (A list of meshes for a sector)
csSegment2 (A 2D line segment)
csSegment3 (A 3D line segment)
csSegmentArray (An dynamic array of csSegment2 objects)
csShadowBitmap (This class represents a shadow-bitmap)
csShadowBlock (A single block of shadows)
csShadowBlockList (A list of shadow blocks)
csShadowFrustum (This class is a csFrustum especially used for the lighting calculations)
csShadowIterator (An iterator to iterate over a list of shadows)
csSimplePixmap (This is the simple implementation of csPixmap that uses a single texture)
csSingleIndexVertexSet (This class can be used to construct objects which use a single index for vertex)
csSkin (This class defines the interface for a container of skins)
csSkinSlice (A `skin slice' is responsible for managing the external view of a certain component)
csSoundFormat (The sound format)
csSparse3D (General 3D sparse matrix class)
csSparseGrid (If cells are populated with data or components, we need to store this somewhere and thats what the SparseGrid is for)
csSphere (This class represents a sphere)
csSpinBox (The spinbox class is a combination of an input line and a bi-directional arrow button which can be used to switch input line contents back and forth between a set of predefined values)
csSpinBoxItem (Spin box item structure)
csSpline (A spline superclass)
csSplitter (This is a splitter control that draws vertical and/or horizontal lines in its parent canvas)
csSpriteBuilder (This is a generic sprite builder interface)
csSpriteBuilderFile (This sprite builder writes the data to a buffer)
csSpriteBuilderMesh (This sprite builder takes a sprite factory and adds the input information)
csSquaredDist (Some functions to perform squared distance calculations)
csStackedVertexArrayPool (This is another implementation of csVertexArrayPool)
csStatic (The Static component class represents a decorative control (widget) which usually does not have functionality, but serves as a decoration)
csStatLight (Class for a static light)
csStreamDescription (Stream description structure)
csString (This is a string class with a range of useful operators and typesafe overloads)
csStringSet (The string set is a list of strings, all with different content)
csStrVector (CsStrVector is a version of csVector which assumes its components were allocated with 'new char *[]')
csSubRect (Sub-rectangle)
csSubRectangles (A class managing allocations of sub-rectangles)
csSystemDriver (This is the interface to operating system.<)
csTesselator (A general purpose tesselation mechanism)
csTextProgressMeter (Displays a simple percentage-style textual progress meter)
csTextureLayer (This structure represents an extra texture layer which is applied on top of the previous one)
csTextureList (This class is used to hold a list of textures)
csTextureTrans (This is a static class which encapsulates a few functions that can transform texture information into a texture matrix/vector)
csTextureWrapper (CsTextureWrapper represents a texture and its link to the iTextureHandle as returned by iTextureManager)
csThing (A Thing is a set of polygons)
csThingBBox (This structure keeps the indices of the vertices which define the bounding box of a csThing)
csThingEdge (This struct represents a line along which polygons are attached)
csThingObjectType (Thing type)
csTimer (Timer is a pseudo-component class which counts time and generates a cscmdTimerPulse command to its parent each time timer crosses bound between two periods)
csTitleBar (The TitleBar class represents a bar with a text string written across which is usually drawn at the top of complex windows :-))
csTitlebarSkin (This class defines the interface for a window titlebar skin slice)
csTokenDesc (Structure to describe a single token in a token table that is passed to most token-parsing functions)
csTransform (A class which defines a transformation from one coordinate system to another)
csTreeBox (Rectangle which contains a number of subrectangles, each of which is recursively similar to its parent)
csTreeItem (This class encapsulates a tree item)
csTreeNode (A generic tree class)
csTriangle (A triangle)
csVector (CsVector is an abstract class which can hold an unlimited array of unspecified (void*) data)
csVector2 (A 2D vector)
csVector3 (A 3D vector)
csVector3Array (This is actually the same class as csPoly3D)
csVertexArrayPool (This is a generalized vertex array pool)
csVertexStatus (The clipper can output additional information about each vertex in output polygon)
csVfsCacheManager (This is a general cache that can cache data on VFS)
csVideoPreferences (This class is a video preference editor)
csVideoStreamDescription (Video stream description structure)
csView (Encapsulates the top-level Crystal Space renderer interface)
csVirtualClock (This is an implementation of a virtual clock)
csVisObjInfo (Structure that is used by the visisibility culler to attach extra information to every bsp polygon)
csWfColor (A color for an object in a WireFrame)
csWfLine (Line in a WireFrame)
csWfObject (Object in a WireFrame)
csWfPolygon (A polygon in a WireFrame)
csWfVertex (Vertex in a WireFrame)
csWideSparse3D (This implementation of csSparse3D is very suited where the accesses will be very widely spaced (for example: one element at (-1000,0,0) and one at (1000,0,0)))
csWindow (A csWindow object is a rectangular area of screen with border which optionally contains a titlebar, a menubar and a client component)
csWindowList (Window List class<)
csWindowSkin (This class defines the interface for a window skin slice)
csWireFrame (A WireFrame is a set of lines, vertices and polygons in 3D)
csWireFrameCam (A WireFrame associated with a camera)
csWSTexture (Texture representation within the windowing system)
csWSTexVector (This class is a vector of csWSTexture's)
csXRotMatrix3 (An instance of csMatrix3 that is initialized as a rotation about X)
csXScaleMatrix3 (An instance of csMatrix3 that is initialized to scale the X dimension)
csYRotMatrix3 (An instance of csMatrix3 that is initialized as a rotation about Y)
csYScaleMatrix3 (An instance of csMatrix3 that is initialized to scale the Y dimension)
csZRotMatrix3 (An instance of csMatrix3 that is initialized as a rotation about Z)
csZScaleMatrix3 (An instance of csMatrix3 that is initialized to scale the Z dimension)
ctAirResistanceF (F = -kv !me really simplified right now....)
ctArticulatedBody (Me some of these methods probably don't need to be virtual anymore, esp. those dealing with RF and dRF)
ctArticulatedGoalSolver (IK or Inverse dyanmics parents)
ctArticulatedSolver (Parent of solver for articulated bodies)
ctCatastropheManager (This class provides an interface to sources of discontinuity in the physical simulation)
ctConstrainedRevoluteJoint (A hinge with a joint angle "constraint" enforced by PID controller techniques)
ctGoalSolver (Tries to reach a goal by applying it's own forces and torques)
ctGravityF (Magnitude = g. g = 9.81 for earth gravity)
ctGravityWell (1/r^2 force)
ctInverseKinematics (No dynamics here)
ctJoint (A joint that links together and constrains the motion of two articulated bodies inboard means articulated body that is closer to the root of the whole outboard is the opposite)
ctKinematicEntity (Kinematic entities are not controlled by newtons laws)
ctLinkList (Singly-link list)
ctPhysicalEntity (Parent class of physical bodies)
ctPointObj (A ctPointObj is the parent class of anything which acts like a point, including point-masses and points (connectors) on larger objects)
ctPrismaticJoint (Joint that slides in and out!me needs some work. Needs proper constructor)
ctReferenceFrame (Me add support for nested frames of reference.me This class should take care of it's ODE state interface... maybe..)
ctRevoluteJoint (A hinge)
ctRigidBody (A rigid body. has inertia tensor)
ctSimpleDynamicsSolver (Calc accel of a simple body affected by simple forces and torques)
ctSolver (Parent of classes that implement different algorithms and methods to solve physical motion problems responsible for calculating the change in state wrt time uses forces list and current state to do this)
ctSpatialVector6 (Wacky vectors that have certain mathematical properties that allow for an O(n) forward dynamics articulated body solver)
ctSpringF (Spring attached to two bodies or inertial reference frame)
ctTorqueF (Just an applied torque)
csMD5::Digest (An MD5 digest is 16 unsigned characters (not NULL-terminated))
DosHelper (Implementation class for iDosHelper)
G3DFogInfo (Extra information for vertex fogging)
G3DPolygonDFP (Structure containing all info needed by DrawFogPolygon (DFP))
G3DPolygonDP (Structure containing all info needed by DrawPolygon (DP))
G3DPolygonDPFX (Structure containing all info needed by DrawPolygonFX (DPFX))
G3DPolygonMesh (Structure containing all info needed by DrawPolygonMesh)
G3DTexturedVertex (Vertex Structure for use with G3DPolygonDPQ)
G3DTriangleMesh (Structure containing all info needed by DrawTriangeMesh)
csTesselator::GridCell (A tesselation grid cell)
iAudioStream (An audio stream)
iAws (Interface for the window manager)
iAwsCanvas (Provider for AWS 2D / 3D Driver)
iAwsComponent (Interface that is the base of ALL components)
iAwsComponentFactory (Interface for component factories)
iAwsKeyFactory (Interface for key factories)
iAwsPrefManager (Interface for the preferences manager (window manager needs one.))
iAwsSink (Interface for sinks)
iAwsSinkManager (Interface for the sink manager)
iAwsSlot (Interface for signal slots (conduits))
iAwsSource (Interface for signal sources)
iAwsWindow (Interface for windows)
iBallState (This interface describes the API for the ball mesh object)
iBase (This is the basic interface: all other interfaces should be derived from this one, this will allow us to always use at least some minimal functionality given any interface pointer)
iBaseHalo (This is the basic interface for all types of halos)
iBeHelper (This interface describes actions specific to the BeOS platform)
iCacheManager (A generic cache system)
iCamera (Camera class)
iCameraPosition (A camera position)
iCameraPositionList (A list of camera position objects)
iClipper2D (This interfaces represents a 2D clipper for polygons)
iCollection (A collection object is for conveniance of the script language)
iCollider (A collider)
iCollideSystem (This is the Collide plug-in)
iCommandLineParser (A utility class that makes it easier to parse the command line)
iComponent (This interface describes a generic component in Crystal Space)
iConfig (Interface to a configurator object)
iConfigFile (Configuration file interface)
iConfigIterator (Iterator which allows sequential access to configuration information contained in an iConfigFile object)
iConfigManager (The config manager is used to make a number of config file objects look like a single object)
iConsoleExecCallback (Command execution callback)
iConsoleInput (This is a plugin that can handle keyboard input and display it on an associated console)
iConsoleOutput (This is the Crystal Space Console interface)
iConsoleWatcher (This interface is implemented by objects interested in knowing when the console's visibility status has changed)
iCrossBuilder (The crossbuilder can be used to build things and sprite factories from single objects of imported model files (iModelDataObject))
iCrossHalo (This is a halo which resembles a cross)
iCurve (This is the interface for a curve)
iCurveTemplate (This is a interface for a curve template)
iDataBuffer (The iDataBuffer interface can be used to exchange buffers with abstract data between plugins)
iDataObject (This is an iObject that contains a type-less data buffer)
iDosHelper (This interface describes actions specific to the DOS platform)
iDrawFuncCallback (A callback function for csEngine::DrawFunc())
iDynLight (The iDynLight interface represents a dynamic light)
iEmitBox (Box value emitter - returns points in an (axis aligned) box)
iEmitCone (Cone value emitter - returns points in a cone)
iEmitCylinder (Cylinder value emitter - returns values in a cylinder)
iEmitCylinderTangent (Cylinder tangential value emitter - gives direction tangential to cylinder Uses the given point, gives a tangential direction for that)
iEmitFactoryState (This interface describes the API for the emitter mesh factory object)
iEmitFixed (Fixed value emitter - returns a particular point value)
iEmitGen3D (This interface is for objects that can generate 3d vectors, which are used for emitting)
iEmitLine (Line value emitter - returns values on the line between start and end)
iEmitMix (Mix value emitter - returns a weighted random mix of other emitters)
iEmitSphere (Sphere value emitter - returns points in a sphere)
iEmitSphereTangent (Sphere tangential value emitter - gives direction tangential to sphere Uses the given point, gives a tangential direction for that)
iEmitState (This interface describes the API for the emitter mesh object)
iEngine (This interface is the main interface to the 3D engine)
iEvent (This interface describes any system event.<)
iEventCord (The iEventCord is an interface provided by an event queue to any event handlers wanting to receive some subclasses of events ASAP in a specified priority, bypassing the queue itself)
iEventHandler (This interface describes an entity that can receive events)
iEventOutlet (The iEventOutlet is the interface to an object that is provided by an event queue to every event plug when it registers itself)
iEventPlug (Event plug interface, also referred as "event source".<)
iEventQueue (This interface represents a general event queue.<)
iExplosionState (This interface describes the API for the explosion mesh object)
iFactory (IFactory is a interface that is used to create instances of shared classes)
iFile (A replacement for FILE type in the virtual file space)
iFireState (This interface describes the API for the fire mesh object)
iFlareHalo (This is a halo which resembles a (solar) flare)
iFont (A font object)
iFontDeleteNotify (Called before a font is deleted)
iFontServer (A font server interface)
iFountainState (This interface describes the API for the fountain mesh object)
iFrustumView (This structure represents all information needed for the frustum visibility calculator)
iFrustumViewUserdata (User data which can be attached to iFrustumView)
iGeneralFactoryState (This interface describes the API for the general mesh factory)
iGeneralMeshState (This interface describes the API for the general mesh object)
iGenerateImageFunction (This class represents a function for csGenerateImageValueFunc)
iGraphics2D (This is the interface for 2D renderer)
iGraphics3D (This is the standard 3D graphics interface)
iGridChangeCallback (Called when a grid change happens)
iHalo (IHalo: used to render halos (aka "light globes"))
iHazeFactoryState (This interface describes the API for the sprite factory mesh object)
iHazeHull (A mesh specially meant for use by the haze)
iHazeHullBox (A predefined hull)
iHazeHullCone (A predefined hull)
iHazeHullCreation (This interface is implemented by the haze factory in order to be able to create the predefined haze hulls)
iHazeState (This interface describes the API for the sprite factory mesh object)
iImage (The iImage interface is used to work with image files (what did you expect?))
iIsoCell (A grid cell)
iIsoCellTraverseCallback (A callback that is called for cell traversal)
iIsoEngine (SCF Interface to the isometric engine)
iIsoGrid (A grid - part of the world)
iIsoLight (A light for the isometric engine)
iIsoLoader (This interface represents the isometric engine map loader)
iIsoMaterialWrapperIndex (The materialwrappers, iMaterialWrappers made by the isoengine, also implement this interface, giving an index in the materials list)
iIsoMeshSprite (This class wraps meshes (meant for the 3d engine) and adapts them for use by the isometric engine)
iIsoRenderView (A view being rendered onto the screen)
iIsoSprite (A sprite for the isometric engine)
iIsoView (A view on the isometric world)
iIsoWorld (The isometric world, contains all the sprites to render the world)
iJoystickDriver (Generic Joystick driver.<)
iKeyboardDriver (Generic Keyboard Driver.<)
iKeyValuePair (A Key Value pair)
iLexicalAnalyzer (The interface to the lexical analyzer / regular expression virtual machine)
iLight (The iLight interface is the SCF interface for the csLight class)
iLightingInfo (This interface is implemented by mesh objects that have some kind of lighting system)
iLightingProcessInfo (The iLightingProcessInfo interface holds information for the lighting system)
iLightList (This structure represents a list of lights)
iLightMap (The lightmap interface)
iLoader (This interface represents the map loader)
iLoaderContext (This interface gives the context for the loader)
iLoaderPlugin (This is a plugin for the loader)
iLODControl (The iLODControl interface represents an object that has controllable LOD features)
iMapNode (A node)
iMaterial (This class represents a material as seen from the engine view)
iMaterialHandle (This class represents a material handle (compiled material) for the 3D rasterizer)
iMaterialList (This class represents a list of materials)
iMaterialWrapper (A material wrapper is an engine-level object that wraps around an actual material (iMaterialHandle))
iMeshDrawCallback (Set a callback which is called just before the object is drawn)
iMeshFactoryList (A list of mesh factories)
iMeshFactoryWrapper (A mesh factory wrapper is an engine-level object that wraps around a mesh object factory (iMeshObjectFactory))
iMeshList (A list of meshes)
iMeshObject (This is a general mesh object that the engine can interact with)
iMeshObjectDrawCallback (Set a callback which is called just before the object is drawn)
iMeshObjectFactory (This object is a factory which can generate mesh objects of a certain type)
iMeshObjectType (This plugin describes a specific type of mesh objects)
iMeshWrapper (A mesh wrapper is an engine-level object that wraps around an actual mesh object (iMeshObject))
iMessageBoxData (The application will receive a cscmdStopModal event when csMessageBox is done)
iModelData (This structure represents a complete scene with objects, light sources, cameras etc)
iModelDataAction (An action)
iModelDataCamera (A camera in the scene)
iModelDataLight (A light source in the scene)
iModelDataMaterial (This structure contains the information about a material for an imported model)
iModelDataObject (One object in the scene)
iModelDataPolygon (One polygon in a model)
iModelDataTexture (This structure contains the information about a texture for an imported model)
iModelDataVertices (A set of vertices, including position, normal, color and texture coordinates)
iMotionController (Interface for setting motion parameters on a skeleton)
iMotionManager (Engine for managing MotionTemplates and MotionControllers)
iMotionTemplate (Interface to loading motion data)
iMouseDriver (Generic Mouse Driver.<)
iMovable (This interface describes a movable entity)
iMovableListener (Implement this class if you're interested in hearing about movable changes)
iNativeWindow (This interface represents a native window)
iNativeWindowManager (This interface represents the native window manager system)
iNetworkConnection (This is the network connection interface for CS)
iNetworkDriver (This is the network driver interface for CS)
iNetworkEndPoint (This is the network end-point interface for CS)
iNetworkListener (This is the network listener interface for CS)
iNetworkSocket (This interface represents a network socket)
iNeXTAssistant (This is an interface for an object which provides assistance to NeXT-specific canvases and Objective-C bridging code for application run-loop support)
iNovaHalo (This is a halo which resembles a nova)
iObject (This interface is an SCF interface for encapsulating csObject)
iObjectIterator (This is an iterator for child objects of a csObject)
iObjectRegistry (This interface serves as a registry of other objects)
iObjectRegistryIterator (Use an instance of this class to iterate over objects in the object registry)
iParticle (A iParticle can be used in particle Systems)
iParticleState (This interface describes the API for the particle mesh object)
iPerfStats (The performance and statistics plugin)
iPluginManager (This is the plugin manager)
iPolygon3D (This is the interface to 3D polygons)
iPolygonBuffer (This interface represents a black-box polygon buffer)
iPolygonMesh (This interface reprents a mesh of polygons)
iPolygonTexture (This is a interface to an object responsible for containing the data required for a lighted texture on a polygon)
iPolyTexFlat (Kind of texturing that is used for a 3D polygon which has flat-shaded texture mapping)
iPolyTexGouraud (Kind of texturing that is used for a 3D polygon which has gouraud-shaded texture mapping)
iPolyTexLightMap (Kind of texturing that is used for a 3D polygon which has lightmaps)
iPolyTexType (Kind of texturing that is used for a 3D polygon)
iPolyTxtPlane (This is the interface to a texture plane)
iPortal (This is the interface to the Portal objects)
iPortalCallback (When a sector is missing this callback will be called)
iProgressMeter (This is a general interface for a progress meter)
iRainState (This interface describes the API for the rain mesh object)
iReference (This is a reference to some other object)
iReferencedObject (This is an object which is referenced by other objects)
iRegExp (Interface definition for a bytecode regular expression)
iRegExpCompiler (Interface definition for a regular expression compiler)
iRegion (A region)
iRegionList (A list of region objects)
iRenderView (This interface represents all information needed to render some object in a current draw context)
iReporter (This is the interface for the error/message reporter plugin)
iReporterListener (Implement this interface if you're interested in hearing about new messages on the reporter)
iSaverPlugin (This is a plugin to save with)
iSCF (ISCF is the interface that allows using SCF functions from shared classes)
iScript (@@ Please document iScript with Doxygen comments)
iSector (The iSector interface is used to work with "sectors")
iSectorIterator (An iterator to iterate over sectors)
iSectorList (A list of sectors)
iSequence (A sequence of operations tagged with relative time information)
iSequenceCondition (A sequence condition)
iSequenceManager (The sequence manager)
iSequenceOperation (A sequence operation)
iShadowBlock (A block of shadows represent the shadows that are casted by one iShadowCaster object)
iShadowBlockList (This is a list of shadow blocks)
iShadowCaster (An object that can cast shadows)
iShadowIterator (A shadow iterator allows someone to iterate over all shadows in a iShadowBlock or iShadowBlockList)
iShadowReceiver (An object that is interested in getting shadow information)
iSkeleton (This interface describes the API for the main skeleton itself)
iSkeletonBone (A bone in the skeleton system)
iSkeletonConnection (This interface describes the API for a connection in the skeleton system)
iSkeletonConnectionState (This interface describes the API for a connection state in the skeleton system)
iSkeletonLimb (This interface describes the API for a limb in the skeleton system)
iSkeletonLimbState (This interface describes the API for a limb state in the skeleton system)
iSkeletonState (This interface describes the API for the skeleton state itself)
iSnowState (This interface describes the API for the snow mesh object)
iSoftProcTexture (This interface is for internal use)
iSoundData (The sound data is a template used to play sounds)
iSoundDriver (This is the interface for the low-level, system-dependent sound driver that is used by the software sound renderer)
iSoundHandle (The sound handle is a sound in the state that is needed by the sound renderer)
iSoundListener (The sound listener is a unique object created by the sound renderer)
iSoundLoader (The sound loader is used to load sound files given a raw input data stream)
iSoundRender (The sound renderer is used to play previously loaded sounds or music)
iSoundSource (The sound source is an instance of a sound)
iSoundWrapper (This class is a csObject (iObject) wrapper for sound handles)
iSpiralState (This interface describes the API for the spiral mesh object)
iSprite2DFactoryState (This interface describes the API for the sprite factory mesh object)
iSprite2DState (This interface describes the API for the sprite factory mesh object)
iSprite3DFactoryState (This interface describes the API for the 3D sprite factory mesh object)
iSprite3DState (This interface describes the API for the 3D sprite mesh object)
iSpriteAction (An action frameset for 3D sprite animation)
iSpriteFrame (A frame for 3D sprite animation)
iStandardReporterListener (Interface to control the settings of the reporter listener plugin)
iStarsState (This interface describes the API for the stars mesh object)
iStatLight (The iStatLight interface is the SCF interface for the csStatLight class)
iStream (A stream)
iStreamFormat (Stream format)
iString (This is a SCF-compatible interface for csString)
iStrVector (This is a SCF-compatible interface for csStrVector)
iSyntaxService (This component provides services for other loaders to easily parse properties of standard CS world syntax)
iTerrainHeightFunction (This class represents a function for the terrain engine)
iTerrainNormalFunction (This class represents a function for the terrain engine)
iTerrFuncState (This interface describes the API for the terrain object)
iTextureCallback (A callback for when a iTextureWrapper is used)
iTextureHandle (A texture handle as returned by iTextureManager)
iTextureList (This class represents a list of texture wrappers)
iTextureManager (This is the standard texture manager interface)
iTextureWrapper (A texture wrapper is an engine-level object that wraps around an actual texture (iTextureHandle))
iThingEnvironment (This interface is implemented by the iObjectType for things)
iThingState (This is the state interface to access the internals of a thing mesh object and factory (both))
iVertexBuffer (This interface represents a black-box vertex buffer)
iVertexBufferManager (This interface represents the vertex buffer manager)
iVertexBufferManagerClient (Objects using services provided by the vertexbuffermanager can register with the manager to receive information about it current state, e.g)
iVFS (The Virtual Filesystem Class is intended to be the only way for Crystal Space engine to access the files)
iVideoStream (A video stream)
iView (Encapsulates the top-level Crystal Space renderer interface)
iVirtualClock (A virtual game clock)
iVisibilityCuller (This interface represents a visibility culling system)
iVisibilityObject (An object that wants to know if it is visible or not for some visibility culler needs to implement this interface)
csMD5::md5_state_t (Define the state of the MD5 Algorithm)
OdeEuler (The fastest and least stable ODE-solver)
OdeMidPoint (If you need speed and don't have many forces more complicated than gravity or propulsion this is a good one to use)
OdeRungaKutta4 (Runga-Kutta order 4 pretty standard dynamics ODE solver)
scfClassInfo (The shared library loader expects an array of such structures to be exported from each shared library)
scfString (This is a thin SCF wrapper around csString)
scfStrVector (This class is a thin wrapper around csStrVector with SCF capability)
Stats (Class containing statistics information for the renderer)
SysSystemDriver (DJGPP version)