CrystalSpace

Public API Reference

Main Page   Modules   Class Hierarchy   Alphabetical List   Compound List   File List   Compound Members   File Members  

Crystal Space Compound List

Here are the classes, structs, unions and interfaces with brief descriptions:
csAbsoluteLayoutThis is just for completeness
csAnimatedPixmapA pixmap with a 2d animation
csAnimationTemplateA 2d animation template. This class is used to create animated pixmaps
csAppThis class is a top-level CrystalSpace Windowing Toolkit object
csApp::csAppPluginThe iComponent interface
csApp::csAppPlugin::eiEventHandlerIEventHandler implementation
csApplicationFrameworkApplication framework class
csArchiveThis class can be used to work with standard ZIP archives
csArray< T >A templated array class
iAudioStreamAn audio stream
csAudioStreamDescriptionAudio stream description structure
iAwsInterface for the window manager
iAwsCanvasProvider for AWS 2D / 3D Driver
iAwsComponentInterface that is the base of ALL components
iAwsComponentFactoryInterface for component factories
iAwsConnectionNodeFactoryInterface for connection node factories
iAwsKeyFactoryInterface for key factories
iAwsParmListProvides support for safely passing named parameters through to different functions in a portable manner
iAwsPrefManagerInterface for the preferences manager (window manager needs one.)
iAwsSinkInterface for sinks
iAwsSinkManagerInterface for the sink manager
iAwsSlotInterface for signal slots (conduits)
iAwsSourceInterface for signal sources
csBackgroundThis class is meant for displaying textured or gradiented backgrounds
iBallStateThis interface describes the API for the ball mesh object
iBaseThis 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
csBaseEventHandlerBase implementation of a generic event handler
iBaseHaloThis is the basic interface for all types of halos
csBasicVector
iBCTerrFactoryStateThis interface describes the API for the Bezier Curve terrain Factory object
iBCTerrStateThis interface describes the API for the Bezier Curve terrain object
iBezierFactoryStateThis is the state interface to access the internals of a bezier mesh factory
iBezierStateThis is the state interface to access the internals of a thing mesh object
iBinaryLoaderPluginThis is a binary plugin for the loader
csBitArrayA one-dimensional array of bits, similar to STL bitset
csBitSetA BitSet is an array of bits
csBlockAllocator< T >This class implements a memory allocator which can efficiently allocate objects that all have the same size
iBodyGroupBody Group is a collection of bodies which don't collide with each other
csBorderConstraintThis subclass of csLayoutConstraint additionally stores the location of the attached control
csBorderLayoutDisplays upto 5 components
csBox2A bounding box in 2D space
csBox3A bounding box in 3D space
csBoxClipperAble to clip convex polygons to a rectangle (such as the screen)
csBoxLayoutComponents are scaled to fit in one row or one column of the canvas
csBSplineA B-spline
iBugPlugUsing this interface you can communicate with the BugPlug plugin
iBugPlugRenderObjectAn application/module can implement this interface to render something
csBumpMapA class representing a bumpmap
csButtonThe Button class implements different types of push buttons
csButtonSkinThis class defines the interface for a button skin slice
iCacheManagerA generic cache system
csCameraA camera positioned in the 3D world
iCameraCamera class
csCamera::CameraICamera implementation
csCameraPositionA camera position
iCameraPositionA camera position
csCameraPosition::CameraPositionICameraPosition implementation
csCameraPositionListList of camera positions for the engine
iCameraPositionListA list of camera position objects
csCameraPositionList::CameraPositionListICameraPositionList implementation
csCatmullRomSplineA CatmullRom spline
csCheckBoxClose child of csButton class
scfClassInfoThe shared library loader expects an array of such structures to be exported from each shared library
csClipInfoStructure for use with ClipToPlane
csClipperAbstract parent to all 2D clipping objects
iClipper2DThis interfaces represents a 2D clipper for polygons
iClothFactoryStateThis interface describes the API for the cloth mesh factory
iClothMeshStateThis interface describes the API for the cloth mesh object
csCodecDescriptionCodec description structure
csCollectionA collection object is for conveniance of the script language
iCollectionA collection object is for conveniance of the script language
csCollectionListList of collections for the engine
iCollectionListICollection list
csCollectionList::CollectionListICollectionList implementation
iColliderA mesh collider
csColliderHelperThis is a class containing a few static member functions to help work with csColliderWrapper and collision detection in general
csColliderWrapperThis 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)
iCollideSystemThis is the Collide plug-in
csCollisionPairA structure used to return collision pairs
csColorA class used to represent a color in RGB space
csColorQuantizerColor quantizer
csColorSchemeThis structure is used to change color scheme
csColorWheelColor wheel static control
csCommandLineHelperThis class can be used to help parsing the commandline
csCommandLineParserUtility class that makes it easier to parse the command line
iCommandLineParserA utility class that makes it easier to parse the command line
iComponentThis interface describes a generic component in Crystal Space
csComponentGraphics system component: a menu, window etc
csConditionA platform-independent condition object
iConfigInterface to a configurator object
csConfigAccessThis is a simple convenience class that can be used to deal with the sytem config manager
csConfigFileConfiguration file which implements the iConfigFile SCF interface
iConfigFileConfiguration file interface
iConfigIteratorIterator which allows sequential access to configuration information contained in an iConfigFile object
csConfigManagerA configuration manager makes a number of individual configuration files appear to be a single configuration object
iConfigManagerThe config manager is used to make a number of config file objects look like a single object
iConsoleExecCallbackCommand execution callback
iConsoleInputThis is a plugin that can handle keyboard input and display it on an associated console
iConsoleOutputThis is the Crystal Space Console interface
iConsoleWatcherThis interface is implemented by objects interested in knowing when the console's visibility status has changed
csConstraintVectorThe layout classes collect the constraints in here
iCrossBuilderThe crossbuilder can be used to build things and sprite factories from single objects of imported model files (iModelDataObject)
csCrossHaloThis is a halo which resembles a cross
iCrossHaloThis is a halo which resembles a cross
csCrossHalo::CrossHaloICrossHalo implementation
csCrystalBallThis is an attempt to provide a massdetection of backfaced polygons
csCubicSplineA cubic spline
iCurveThis is the interface for a curve
csDataBufferThis is a implementation of iDataBuffer interface
iDataBufferThe iDataBuffer interface can be used to exchange buffers with abstract data between plugins
csDataObjectA generic data object
iDataObjectThis is an iObject that contains a type-less data buffer
csDataObject::DataObjectIDataObject implementation
csDataStreamThis class can be used as a wrapper around a data buffer for easy stream-like access
csDebuggingGraphThis is a static class that helps with debugging
iDebugHelperSome object that wants to implement unit testing, debugging and/or benchmarking can implement this interface
csDefaultButtonSkinThis is the default skin for buttons
csDefaultDialogSkinThis is the default skin for dialogs
csDefaultListBoxItemSkinThis is the default skin for listbox items
csDefaultListBoxSkinThis is the default skin for listboxes
csDefaultScrollBarSkinThis is the default skin for scroll bars
csDefaultTitlebarSkinThis is the default skin for window titlebars
csDefaultVertexArrayPoolThis is a default implementation of csVertexArrayPool
csDefaultWindowSkinThis is the default skin for windows
csDialogThe Dialog class is a single-colored canvas which contains a number of child controls
csDialogSkinThis class defines the interface for a dialog skin slice
csDIntersect3Some functions to perform various intersection calculations with 3D line segments
csDMath3Various assorted 3D mathematical functions
csDMatrix3A 3x3 matrix
iDocumentRepresentation of a document containing a hierarchical structure of nodes
iDocumentAttributeAn attribute for an iDocumentNode
iDocumentAttributeIteratorAn iterator over iDocumentNode attributes
iDocumentNodeRepresentation of a node in a document
iDocumentNodeIteratorAn iterator over iDocumentNode
iDocumentSystemAn iDocument factory
csDPlaneA plane in 3D space
csDSquaredDistSome functions to perform squared distance calculations
csDVector3A 3D vector
csDVector4A 3D vector
iDynamicsThis is the interface for the actual plugin
iDynamicsCollisionCallbackThis is the interface for attaching a collider callback to the body
iDynamicsMoveCallbackThis is the interface for a dynamics move callback
iDynamicSystemThis is the interface for the dynamics core
csDynLightClass for a dynamic light
iDynLightThe iDynLight interface represents a dynamic light
csDynLight::eiDynLightIDynLight implementation
iEffectClientEffect client
iEffectDefinitionEffect definition
iEffectLayerA layer in an effect pass
iEffectPassAn effect pass
iEffectServerEffect server
iEffectTechniqueAn effect technique
csEffectVector4A simple 4-component vector, used by the effect system
awsEmbeddedComponentClass used to create new AWS components
awsEmbeddedComponentFactoryFactory for custom AWS component
iEmitBoxBox value emitter - returns points in an (axis aligned) box
iEmitConeCone value emitter - returns points in a cone
iEmitCylinderCylinder value emitter - returns values in a cylinder
iEmitCylinderTangentCylinder tangential value emitter - gives direction tangential to cylinder Uses the given point, gives a tangential direction for that
iEmitFactoryStateThis interface describes the API for the emitter mesh factory object
iEmitFixedFixed value emitter - returns a particular point value
iEmitGen3DThis interface is for objects that can generate 3d vectors, which are used for emitting
iEmitLineLine value emitter - returns values on the line between start and end
iEmitMixMix value emitter - returns a weighted random mix of other emitters
iEmitSphereSphere value emitter - returns points in a sphere
iEmitSphereTangentSphere tangential value emitter - gives direction tangential to sphere Uses the given point, gives a tangential direction for that
iEmitStateThis interface describes the API for the emitter mesh object
iEngineThis interface is the main interface to the 3D engine
csEngineThe 3D engine
csEngine::eiComponentIComponent implementation
csEngine::EventHandlerIEventHandler implementation
csEngineConfigObject which implements iConfig interface on behalf of csEngine
csEngineMeshListA list of meshes for the engine
iEngineSequenceManagerSequence manager specifically designed for working on the engine
iEngineSequenceParametersAn interface for passing on parameters to the engine sequence manager
csEventThis class represents a system event
iEventThis interface describes any system event
csEventCommandDataCommand event data in iEvent
csEventCordEvent cord
iEventCordThe 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
iEventHandlerThis interface describes an entity that can receive events
csEventJoystickDataJoystick event data in iEvent
csEventKeyDataKey event data in iEvent
csEventMouseDataMouse event data in iEvent
csEventNetworkDataNetwork event data in iEvent
csEventOutletA class which implements the iEventOutlet interface
iEventOutletThe iEventOutlet is the interface to an object that is provided by an event queue to every event plug when it registers itself
iEventPlugEvent plug interface, also referred as "event source"
csEventQueueThis class represents a general event queue
iEventQueueThis interface represents a general event queue
iExplosionStateThis interface describes the API for the explosion mesh object
iFactoryIFactory is a interface that is used to create instances of shared classes
iFileA replacement for FILE type in the virtual file space
csFileTimeFile time structure - used to query and set the last-modification time of a file
iFireStateThis interface describes the API for the fire mesh object
csFlagsSet of flags which can be accessed through masks
csFlareComponentStructure used to keep flare component information
csFlareHaloThis halo is used for (solar)flares
iFlareHaloThis is a halo which resembles a (solar) flare
csFlareHalo::FlareHaloIFlareHalo implementation
csFlowLayoutIn a flow layout components are displayed in a row and wraped at parents boundaries
csFogFog structure
csFogInfoInformation for vertex based fog
iFontA font object
iFontDeleteNotifyCalled before a font is deleted
iFontServerA font server interface
iFountainStateThis interface describes the API for the fountain mesh object
csFrustumA general frustum
csFrustumContextThis structure keeps track of the current frustum context
csFrustumViewThis structure represents all information needed for the frustum visibility calculator
iFrustumViewThis structure represents all information needed for the frustum visibility calculator
iFrustumViewUserdataUser data which can be attached to iFrustumView
G3DFogInfoExtra information for vertex fogging
G3DPolygonDFPStructure containing all info needed by DrawFogPolygon (DFP)
G3DPolygonDPStructure containing all info needed by DrawPolygon (DP)
G3DPolygonDPFXStructure containing all info needed by DrawPolygonFX (DPFX)
G3DPolygonMeshStructure containing all info needed by DrawPolygonMesh
G3DTexturePlaneInformation about a texture plane
G3DTriangleMeshStructure containing all info needed by DrawTriangeMesh
iGeneralFactoryStateThis interface describes the API for the general mesh factory
iGeneralMeshStateThis interface describes the API for the general mesh object
csGenerateImageThis class will compute a texture for a terrain
iGenerateImageFunctionThis class represents a function for csGenerateImageValueFunc
csGenerateImageLayerThis class is used to store the layers of textures per value
csGenerateImageTextureA base class which represents a texture that can be displayed on the terrain
csGenerateImageTextureBlendA class for a texture that is made by blending together other textures based on a value
csGenerateImageTextureSingleA class for a single texture
csGenerateImageTextureSolidA class for a solid coloured texture
csGenerateImageValueA base class which represents a value that can be computed for blending purposes for each pixel
csGenerateImageValueFuncThis class will generate a value using a given function
csGenerateImageValueFuncConstThis class will generate a constant value
csGenerateImageValueFuncTexThis class will generate a value using a texture
csGeomDebugHelperThis is a class that does unit testing (and other debug stuff) for most of csgeom classes
getopt_optionDescribe the long-named options requested by the application
csGlobalHashIteratorAn iterator to iterate over all elements in the hashmap
csGlobalHashIteratorReversibleA csHashIterator that knows about csHashMapReversible's reverse hash
iGraphics2DThis is the interface for 2D renderer
iGraphics3DThis is the standard 3D graphics interface
csGraphics3DCapsInformation about 3d renderer capabilities
csGraphicsPipelineGraphics System pipeline class
csGridThis is the grid object itself
csGridBagConstraintSubclass of csLayoutConstraint for use with csGridBagLayout
csGridBagLayoutCsGridBagLayout is the most flexible layout class
csGridCellThe following class collects properties for drawing the cell and acts as a container for the csComponent (i.e
iGridChangeCallbackCalled when a grid change happens
csGridLayoutComponents are displayed in a grid fashion
csGridViewThe GridView displays a continuous rectangular region of the grid
csGrowingArray< T >An automatically growing array of objects
iGUIConnectionA class implementing this interface is used to connect a GUI server to one or more clients
iGUIServerThis interface represents the server side of a client/server GUI system
csHaloThis is the basic class for all types of halos
iHaloIHalo: used to render halos (aka "light globes")
csHashElementAn element inside the hashmap (private element)
csHashIteratorAn iterator to iterate over elements in the hashmap
csHashIteratorReversibleA csHashIterator that knows about csHashMapReversible's reverse hash
csHashMapThis is a general hashmap
csHashMapReversibleA csHashMap that maintains a reverse hash for indexing key strings by keys
csHashSetThis class implements a basic set for objects
iHazeFactoryStateThis interface describes the API for the sprite factory mesh object
iHazeHullA mesh specially meant for use by the haze
iHazeHullBoxA predefined hull
iHazeHullConeA predefined hull
iHazeHullCreationThis interface is implemented by the haze factory in order to be able to create the predefined haze hulls
iHazeStateThis interface describes the API for the sprite factory mesh object
csHintThis component will display "floating hints", which will vanish as soon as you move the mouse or press a key
csHintManagerThe "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
iImageThe iImage interface is used to work with image files (what did you expect?)
csImageAreaThis structure is used for saving/restoring areas of screen
csImageFileAn abstract class representing an abstract image
iImageIOThe iImageIO interface is used to save and load graphic files
csImageIOFileFormatDescriptionDescription for a file format supported by an image loader
csImageMemoryThis class represents a block of memory in the true colour format only
iImposterIImposter defines the interface a mesh (or other) class must implement to be used as imposter mesh by the engine
csIndPrintA debugging class to help print out indented messages
csIndPrintDownThis class is a small helper class to indent a level down and automatically indent up again when this class is destructed
csInitializerThis class contains several static member functions that can help setup an application
iInputBinderBind an input event to a pointer to a variable, so that that variable will reflect the state of a given key, button or axis
csInputBinderBind an input event to a pointer to a variable so that that variable will reflect the state of a given key, button or axis
csInputBinderBooleanRepresents the up or down state of a keyboard key or a mouse or joystick button, shared between modules
iInputBinderBooleanRepresents the up or down state of a keyboard key or a mouse or joystick button, shared between plugins
iInputBinderPositionRepresents the position of a mouse or joystick axis, shared between plugins
csInputBinderPositionRepresents the position of a mouse or joystick axis, shared between modules
csInputDriverSuperclass of all the generic input drivers
csInputLineThe Input Line class implements a rectangular are where user can enter any text
csIntArrayGrowing array of ints
csIntersect2Some functions to perform various intersection calculations with 2D line segments
csIntersect3Some functions to perform various intersection calculations with 3D line segments
iIsoCellA grid cell
iIsoCellTraverseCallbackA callback that is called for cell traversal
iIsoEngineSCF Interface to the isometric engine
iIsoGridA grid - part of the world
iIsoLightA light for the isometric engine
iIsoLoaderThis interface represents the isometric engine map loader
iIsoMaterialWrapperIndexThe materialwrappers, iMaterialWrappers made by the isoengine, also implement this interface, giving an index in the materials list
iIsoMeshSpriteThis class wraps meshes (meant for the 3d engine) and adapts them for use by the isometric engine
iIsoRenderViewA view being rendered onto the screen
iIsoSpriteA sprite for the isometric engine
iIsoViewA view on the isometric world
iIsoWorldThe isometric world, contains all the sprites to render the world
iJointThis is the interface for a joint
csJoystickDriverGeneric Joystick driver
iJoystickDriverGeneric Joystick driver
csJoystickDriver::eiEventHandlerIEventHandler implementation
csKDTreeA KD-tree
csKDTreeChildA child in the KD-tree (usually some object)
csKeyboardAcceleratorA 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
csKeyboardDriverGeneric Keyboard Driver
iKeyboardDriverGeneric Keyboard Driver
csKeyboardDriver::eiEventHandlerIEventHandler implementation
iKeyValuePairA Key Value pair
csKeyValuePairA Key Value pair
csKeyValuePair::KeyValuePairIKeyValuePair implementation
csLayoutCsLayout is our baseclass for various derived classes like csFlowLayout, csBoxLayout, csGridBagLayout and others
csLayout2CsLayout2 extends csLayout to take the maximum layout size and aligning along the x and y axis into account
csLayoutConstraintCsLayoutConstraint is a basic constraint used for positioning a control in a csLayout derived component
csLightSuperclass of all positional lights
iLightThe iLight interface is the SCF interface for the csLight class
csLight::LightILight implementation
iLightCallbackSet a callback which is called when this light color is changed
csLightFlareHaloThis class is used to keep track of visible Flares
csLightHaloThis is used to keep track of halos
iLightingInfoThis interface is implemented by mesh objects that have some kind of lighting system
iLightingProcessDataThe iLightingProcessData interface can be implemented by a mesh object so that it can attach additional information for the lighting process
csLightingProcessInfoThis is user-data for iFrustumView for the lighting process
iLightingProcessInfoThe iLightingProcessInfo interface holds information for the lighting system
csLightItIterator to iterate over all static lights in the engine
iLightIteratorIterator to iterate over all static lights in the engine
csLightListList of lights for a sector
iLightListThis structure represents a list of lights
iLightMapThe lightmap interface
csLightMapMappingThis structure holds mapping information to map the lightmap on a polygon
csList< T >::IteratorIterator for the list
csListBoxList box class is a rectangle which contains a number of list box items
csListBoxItemThis class encapsulates a menu item
csListBoxItemSkinThis class defines the interface for a listbox item skin slice
csListBoxSkinThis class defines the interface for a listbox skin slice
iLoaderThis interface represents the map loader
iLoaderContextThis interface gives the context for the loader
iLoaderPluginThis is a plugin for the loader based on document tree
iLODControlThe iLODControl interface represents an object that has controllable LOD features
iMapNodeA node
csMapNodeA node
csMapNode::MapNodeIMapNode implementation
csMaterialA material class
iMaterialThis class represents a material as seen from the engine view
csMaterial::MaterialEngineIMaterialEngine implementation
iMaterialEngineThis interface represents the engine part of the material definition
iMaterialHandleThis class represents a material handle (compiled material) for the 3D rasterizer
csMaterialListThis class is used to hold a list of materials
iMaterialListThis class represents a list of materials
csMaterialWrapperCsMaterialWrapper represents a texture and its link to the iMaterialHandle as returned by iTextureManager
iMaterialWrapperA material wrapper is an engine-level object that wraps around an actual material (iMaterialHandle)
csMath2Various functions in 2D, such as 2D vector functions
csMath3Various assorted 3D mathematical functions
csMatrix2A 2x2 matrix
csMatrix3A 3x3 matrix
csMD5This is an encapsulation of a C-implementation of MD5 digest algorithm by Peter Deutsch <ghost@aladdin.com>
csMD5::DigestAn MD5 digest is 16 unsigned characters (not NULL-terminated)
csMemFileEssentially a raw memory buffer which implements the abstract iFile interface
csMemoryMappedIODefines a simple memory-mapped IO class that is portable
csMenuThe Menu class represents two types of menu: vertical (popup) menus and bar menus
csMenuItemThis class encapsulates a menu item
iMeshDrawCallbackSet a callback which is called just before the object is drawn
csMeshedPolygonA polygon
csMeshFactoryThis is the abstract implementation of iMeshObjectFactory
csMeshFactoryFactoryListSubclass of csMeshFactoryList to hold the children of another mesh factory
csMeshFactoryListA list of mesh factories
iMeshFactoryListA list of mesh factories
csMeshFactoryWrapperThe holder class for all implementations of iMeshObjectFactory
iMeshFactoryWrapperA mesh factory wrapper is an engine-level object that wraps around a mesh object factory (iMeshObjectFactory)
csMeshListGeneral list of meshes
iMeshListA list of meshes
csMeshMeshListSubclass of csMeshList to hold the children of another mesh object
iMeshObjectThis is a general mesh object that the engine can interact with
csMeshObjectThis is an abstract implementation of iMeshObject
iMeshObjectDrawCallbackSet a callback which is called just before the object is drawn
iMeshObjectFactoryThis object is a factory which can generate mesh objects of a certain type
iMeshObjectTypeThis plugin describes a specific type of mesh objects
csMeshTypeThis is the abstract implementation of iMeshObjectType
csMeshType::eiComponentIComponent implementation
csMeshWrapperThe holder class for all implementations of iMeshObject
iMeshWrapperA mesh wrapper is an engine-level object that wraps around an actual mesh object (iMeshObject)
iMessageBoxDataThe application will receive a cscmdStopModal event when csMessageBox is done
iModelConverterModel converter
csModelConverterFormatStructure describing a single format supported by a model converter
iModelDataThis structure represents a complete scene with objects, light sources, cameras etc
iModelDataActionAn action
iModelDataCameraA camera in the scene
iModelDataLightA light source in the scene
iModelDataMaterialThis structure contains the information about a material for an imported model
iModelDataObjectOne object in the scene
iModelDataPolygonOne polygon in a model
iModelDataTextureThis structure contains the information about a texture for an imported model
csModelDataToolsA set of utility functions to deal with model data components
csModelDataVertexMapMapping table, used by csModelDataTools::CopyVerticesMapped()
iModelDataVerticesA set of vertices, including position, normal, color and texture coordinates
iMotionControllerInterface for setting motion parameters on a skeleton
iMotionManagerEngine for managing MotionTemplates and MotionControllers
iMotionTemplateInterface to loading motion data
csMouseThis class handles mouse pointer and generates mouse events
csMouseDriverGeneric Mouse Driver
iMouseDriverGeneric Mouse Driver
csMouseDriver::eiEventHandlerIEventHandler implementation
csMousePointerThis class encapsulates mouse pointer
iMovableThis interface describes the transformation between local object space of some model and world space (i.e
csMovableThis class represents an entity that can move in the engine
iMovableListenerImplement this class if you're interested in hearing about movable changes
csMovableSectorListA list of sectors as the movable uses it
iMovieRecorderUsing this interface you can communicate with the MovieRecorder plugin
csMutexA platform-independent mutual-exclusion object
iNativeWindowThis interface represents a native window
iNativeWindowManagerThis interface represents the native window manager system
iNetworkConnectionThis is the network connection interface for CS
iNetworkDriverThis is the network driver interface for CS
iNetworkDriver2Network driver factory interface
csNetworkDriverCapabilitiesNetwork driver capabilities structure
iNetworkEndPointThis is the network end-point interface for CS
iNetworkListenerThis is the network listener interface for CS
iNetworkManagerThe network manager polls for incoming data on connections registered with it and new connections on listeners registered with it
iNetworkPacketThe application writes an implementation of the network packet interface and a new instance of that implementation is passed to the network manager with each new connection registered
iNetworkSocketThis interface represents a network socket
iNetworkSocket2A network socket
csNodeIteratorA node iterator
csNotebookA notebook (also called "property sheet") is a collection of dialogs enclosed in a single window
csNovaHaloThis halo has a center with a number of spokes
iNovaHaloThis is a halo which resembles a nova
csNovaHalo::NovaHaloINovaHalo implementation
csNullCacheManagerThis is a general cache that doesn't cache anything at all
iNullMeshStateThis interface describes the API for the null mesh object
csOBBOriented bounding box (OBB)
csOBBFrozenVersion of the csOBB with frozen corners (for optimization purposes)
csObjectA generic csObject class
iObjectThis interface is an SCF interface for encapsulating csObject
iObjectIteratorThis is an iterator for child objects of a csObject
csObjectModelHelper class to make it easier to implement iObjectModel in mesh objects
iObjectModelThis interface represents data related to some geometry in object space
iObjectModelListenerImplement this class if you're interested in hearing about when the object model changes
csObjectPool< T >This class defines a 'pool' class for the given type
csObjectRegistryThis is an implementation of iObjectRegistry
iObjectRegistryThis interface serves as a registry of other objects
iObjectRegistryIteratorUse an instance of this class to iterate over objects in the object registry
iObjectWatcherThis is a generic object watcher
csObjectWatcherThis class implements iObjectWatcher and is capable of keeping track of lights and movables
iObjectWatcherListenerImplement this class if you're interested in hearing about object watcher events
iOffscreenCanvasCallbackWhen you create an offscreen canvas (CreateOffscreenCanvas()) then you can use this callback to get informed when the texture has been modified (FinishDraw() called) or a palette entry is modified
csOptionDescriptionConfiguration option description
csOrthoTransformA class which defines a reversible transformation from one coordinate system to another by maintaining an inverse transformation matrix
iOSXAssistantThis is an interface for an object which provides assistance to MacOS/X-specific canvases and Objective-C bridging code for application run-loop support
csPaletteExportControl palette export structure
iParameterESMThis interface is a parameter resolver
csPArray< T >An array of pointers
iParticleA iParticle can be used in particle Systems
iParticleStateThis interface describes the API for the particle mesh object
csPathA path in 3D
csPDelArray< T >An array of pointers
iPerfStatsThe performance and statistics plugin
csPixelCoordSimple 2D pixel coordinate
csPixelFormatStructure describing the pixel format
csPixmapThis class is an simple set of inline routines good as an abstraction for simple 2D sprites
csPlane2A plane in 2D space
csPlane3A plane in 3D space
iPluginIteratorAn iterator to iterate over all plugins in the plugin manager
csPluginLoaderThis utility class helps to load plugins based on request, config file, and commandline
csPluginManagerThis is the standard implementation of the plugin manager
iPluginManagerThis is the plugin manager
csPointA 2D point object
csPoly2DThe following class represents a general 2D polygon with a bounding box
csPoly2DEdgesThe following class represents a general 2D polygon represented with edges instead of vertices
csPoly2DEdgesPoolThis is an object pool which holds objects of type csPoly2DEdges
csPoly2DFactoryThis factory is responsible for creating csPoly2D objects or subclasses of csPoly2D
csPoly2DPoolThis is an object pool which holds objects of type csPolygon2D
csPoly3DThe following class represents a general 3D polygon
iPolygon3DThis is the interface to dynamic part of a 3D polygon
iPolygon3DStaticThis is the interface to the static part of a 3D polygon
iPolygonBufferThis interface represents a black-box polygon buffer
csPolygonClipperCan be used for clipping any polygon against any other convex polygon
iPolygonMeshThis interface reprents a mesh of polygons
csPolygonMeshEdgeA definition of one edge
csPolygonMeshToolsA set of tools to work with iPolygonMesh instances
iPolygonTextureThis is a interface to an object responsible for containing the data required for a lighted texture on a polygon
csPolyIndexedThe following class represents a general polygon
csPooledVertexArrayPoolThis is another implementation of csVertexArrayPool
csPoolEventThis class is a system event designed for the pool system
iPortalThis is the interface to the Portal objects
iPortalCallbackWhen a sector is missing this callback will be called
csPrefixConfigThis is an implementation of iConfigFile that stores an ID string at construction, which it then prepends to all config keys on read/write operations
csProcDotsRandom dots (demonstration procedural texture)
csProcFirePlasma
csProcPlasmaPlasma
csProcSkyA sky, this represents a whole sphere of sky - so multiple polygons can be rendered to
csProcSkyTextureA polygon of a sky
csProcTextureGeneric superclass for procedural textures
csProcWaterPlasma
iProgressMeterThis is a general interface for a progress meter
csProgressPulseSimple twirling textual cursor built out of the characters '-', '\', '|', and '/'
csPtr< T >A normal pointer
csQuaternionClass for a quaternion
csRadioButtonClose child of csButton class
iRainStateThis interface describes the API for the rain mesh object
csRandomGenPortable random number generator class
csRectRectangle class: simple class for manipulating 2D rectangles
csRectRegionA rect region is a class that implements splittable 2d rectangles
csRef< T >A smart pointer
csRefArray< T >An array of smart pointers
csRefArrayObject< T >This class implements a typed array that correctly keeps track of reference count and also is able to find by name
csRefCountThis is a class which provides basic reference-counting semantics
iReferenceThis is a reference to some other object
iReferencedObjectThis is an object which is referenced by other objects
iRegionA region
csRegionA region
csRegionListList of 3D engine regions
iRegionListA list of region objects
iRender3DNew 3D Interface
csRender3dCapsA triangle
iRenderBufferThis is a general buffer to be used by the renderer
csRenderContextThis structure keeps track of the current render context
csRenderContextFrustumThis structure holds the current render context frustum
csRenderQueueSetThis class contains a list of rendering queues, each of which is a list of mesh wrappers
csRenderViewThis structure represents all information needed for drawing a scene
iRenderViewThis interface represents all information needed to render some object in a current draw context
iReporterThis is the interface for the error/message reporter plugin
csReporterHelperHelper class for csReport()
iReporterIteratorAn iterator to iterate over all messages in the reporter
iReporterListenerImplement this interface if you're interested in hearing about new messages on the reporter
csReversibleTransformA class which defines a reversible transformation from one coordinate system to another by maintaining an inverse transformation matrix
csRGBcolorAn RGB color
csRGBpixelAn RGB pixel
csRGBVectorThis is a vector class that expects you to push csRGBcolor structs onto it
iRigidBodyThis is the interface for a rigid body
csRunnableAbstract interface for objects which can be run in a thread
iSaverThis interface is used to serialize the engine contents
iSaverPluginThis is a plugin to save with
iSCFISCF is the interface that allows using SCF functions from shared classes
csScheduleEasy way to get timers in applications
csScopedMutexLockThis is a utility class for locking a Mutex
iScript@@ Please document iScript with Doxygen comments
csScrollBarThe ScrollBar component class is used to scroll left/right or up/down windows whose content does not fit into their size
csScrollBarSkinThis class defines the interface for a scrollbar skin slice
csScrollBarStatusScroll bar range structure
iSectorThe iSector interface is used to work with "sectors"
csSectorA sector is a container for objects
iSectorCallbackSet a callback which is called when this sector is traversed
iSectorIteratorAn iterator to iterate over sectors
csSectorLightListA list of lights for a sector
iSectorListA list of sectors
csSectorListList of 3D engine sectors
csSectorMeshListA list of meshes for a sector
csSegment2A 2D line segment
csSegment3A 3D line segment
csSemaphoreA platform-independent semaphore object
iSequenceA sequence of operations tagged with relative time information
iSequenceConditionA sequence condition
iSequenceManagerThe sequence manager
iSequenceOperationA sequence operation
iSequenceTimedOperationA timed operation for the engine sequence manager
iSequenceTriggerA sequence trigger
iSequenceWrapperA sequence wrapper
iShaderSpecific shader
iShaderManagerA manager for all shaders
iShaderPassDescription of a single pass in a shader
iShaderProgramA shader-program is either a vertexprogram, fragmentprogram or any other type of "program" utilizied by shader
iShaderTechniqueOne specific technique used by shader
iShadowBlockA block of shadows represent the shadows that are casted by one iShadowCaster object
csShadowBlockA single block of shadows
iShadowBlockListThis is a list of shadow blocks
csShadowBlockListA list of shadow blocks
iShadowCasterAn object that can cast shadows
csShadowFrustumThis class is a csFrustum especially used for the lighting calculations
iShadowIteratorA shadow iterator allows someone to iterate over all shadows in a iShadowBlock or iShadowBlockList
csShadowIteratorAn iterator to iterate over a list of shadows
iShadowReceiverAn object that is interested in getting shadow information
csSharedVariableA SharedVariable is a refcounted floating point value
iSharedVariableISharedVariable implements a refcounted float value which can be shared across many objects and updated efficiently
iSharedVariableListA list of shared variables
csSharedVariableListList of 3D engine SharedVariables
csSimplePixmapThis is the simple implementation of csPixmap that uses a single texture
csSingleIndexVertexSetThis class can be used to construct objects which use a single index for vertex
iSkeletonThis interface describes the API for the main skeleton itself
iSkeletonBoneA bone in the skeleton system
iSkeletonConnectionThis interface describes the API for a connection in the skeleton system
iSkeletonConnectionStateThis interface describes the API for a connection state in the skeleton system
iSkeletonLimbThis interface describes the API for a limb in the skeleton system
iSkeletonLimbStateThis interface describes the API for a limb state in the skeleton system
iSkeletonStateThis interface describes the API for the skeleton state itself
csSkinThis class defines the interface for a container of skins
csSkinSliceA `skin slice' is responsible for managing the external view of a certain component
iSnowStateThis interface describes the API for the snow mesh object
iSoundDataThe sound data is a template used to play sounds
iSoundDriverThis is the interface for the low-level, system-dependent sound driver that is used by the software sound renderer
csSoundFormatThe sound format
iSoundHandleThe sound handle is a sound in the state that is needed by the sound renderer
iSoundListenerThe sound listener is a unique object created by the sound renderer
iSoundLoaderThe sound loader is used to load sound files given a raw input data stream
iSoundRenderThe sound renderer is used to play previously loaded sounds or music
iSoundSourceThe sound source is an instance of a sound
iSoundWrapperThis class is a csObject (iObject) wrapper for sound handles
csSparse3DGeneral 3D sparse matrix class
csSparseGridIf cells are populated with data or components, we need to store this somewhere and thats what the SparseGrid is for
csSphereThis class represents a sphere
csSpinBoxThe 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
csSpinBoxItemSpin box item structure
csSpinBoxLimitsSpin box upper/lower limits
iSpiralStateThis interface describes the API for the spiral mesh object
csSplineA spline superclass
csSplitterThis is a splitter control that draws vertical and/or horizontal lines in its parent canvas
iSprite2DFactoryStateThis interface describes the API for the sprite factory mesh object
iSprite2DStateThis interface describes the API for the sprite factory mesh object
iSprite2DUVAnimationThe animation works by having all frames of an animation sequence in a texture at different (u,v) locations, hence the name
iSprite2DUVAnimationFrameThis is a single frame in a UV animation
csSprite2DVertexA single 2D Sprite vertex
iSprite3DFactoryStateThis interface describes the API for the 3D sprite factory mesh object
iSprite3DStateThis interface describes the API for the 3D sprite mesh object
iSpriteActionAn action frameset for 3D sprite animation
csSpriteBuilderThis is a generic sprite builder interface
csSpriteBuilderFileThis sprite builder writes the data to a buffer
csSpriteBuilderMeshThis sprite builder takes a sprite factory and adds the input information
iSpriteFrameA frame for 3D sprite animation
iSpriteSocketA socket for specifying where sprites can plug into other sprites
csSquaredDistSome functions to perform squared distance calculations
csStackedVertexArrayPoolThis is another implementation of csVertexArrayPool
iStandardReporterListenerInterface to control the settings of the reporter listener plugin
iStarsStateThis interface describes the API for the stars mesh object
csStaticThe Static component class represents a decorative control (widget) which usually does not have functionality, but serves as a decoration
csStaticArrayHelper class for CS_DECLARE_STATIC_ARRAY
iStatLightThe iStatLight interface is the SCF interface for the csStatLight class
csStatLightClass for a static light
csStatLight::eiStaticLightIStatLight implementation
StatsClass containing statistics information for the renderer
iStreamA stream
csStreamDescriptionStream description structure
iStreamFormatStream format
iStringThis is a SCF-compatible interface for csString
csStringThis is a string class with a range of useful operators and typesafe overloads
scfStringThis is a thin SCF wrapper around csString
csStringHashThe string hash is a hash of strings, all with different content
csStringHashIteratorAn iterator to iterate over elements in a csStringHash
csStringSetThe string set is a list of strings, all with different content
csStringSetIteratorAn iterator to iterate over elements in a csStringSet
scfStrVectorThis class is a thin wrapper around csStrVector with SCF capability
iStrVectorThis is a SCF-compatible interface for csStrVector
csStrVectorCsStrVector is a version of csVector which assumes its components were allocated with 'new char *[]'
csSubRectSub-rectangle
csSubRectanglesA class managing allocations of sub-rectangles
iSyntaxServiceThis component provides services for other loaders to easily parse properties of standard CS world syntax
csSystemDriverThis is the interface to operating system
iTerrainHeightFunctionThis class represents a function for the terrain engine
iTerrainNormalFunctionThis class represents a function for the terrain engine
iTerrBigStateThis class associates a file created using the terrbig conversion to the terrbig object
iTerrFuncStateThis interface describes the API for the terrain object
csTesselatorA general purpose tesselation mechanism
csTesselator::GridCellA tesselation grid cell
csTextProgressMeterDisplays a simple percentage-style textual progress meter
iTextureCallbackA callback for when a iTextureWrapper is used
iTextureHandleA texture handle as returned by iTextureManager
csTextureLayerThis structure represents an extra texture layer which is applied on top of the previous one
csTextureListThis class is used to hold a list of textures
iTextureListThis class represents a list of texture wrappers
iTextureManagerThis is the standard texture manager interface
csTextureTransThis is a static class which encapsulates a few functions that can transform texture information into a texture matrix/vector
iTextureWrapperA texture wrapper is an engine-level object that wraps around an actual texture (iTextureHandle)
csTextureWrapperCsTextureWrapper represents a texture and its link to the iTextureHandle as returned by iTextureManager
iThingEnvironmentThis interface is implemented by the iObjectType for things
iThingFactoryStateThis is the state interface to access the internals of a thing mesh factory
iThingStateThis is the state interface to access the internals of a thing mesh object
csThreadA platform-independent thread object
csTimerTimer is a pseudo-component class which counts time and generates a cscmdTimerPulse command to its parent each time timer crosses bound between two periods
csTinyDocumentSystemThis is an SCF compatible wrapper for the TinyXml parser in csutil
csTitleBarThe TitleBar class represents a bar with a text string written across which is usually drawn at the top of complex windows :-)
csTitlebarSkinThis class defines the interface for a window titlebar skin slice
csTransformA class which defines a transformation from one coordinate system to another
csTreeBoxRectangle which contains a number of subrectangles, each of which is recursively similar to its parent
csTreeItemThis class encapsulates a tree item
csTreeNodeA generic tree class
csTriangleA triangle
csTriangleMeshA mesh of triangles
csTriangleVertexThe representation of a vertex in a triangle mesh
csTriangleVerticesA class which holds vertices and connectivity information for a triangle mesh
csTypedObjectIteratorHelper class for CS_DECLARE_OBJECT_ITERATOR macro
csUtilDebugHelperThis is a class that does unit testing (and other debug stuff) for some of csutil classes
csVariantVariant, means that type of contained data is set at runtime
csVector
csVector2A 2D vector
csVector3A 3D vector
csVector3ArrayThis is actually the same class as csPoly3D
csVector4A 4D vector
csVertexArrayPoolThis is a generalized vertex array pool
iVertexBufferThis interface represents a black-box vertex buffer
iVertexBufferManagerThis interface represents the vertex buffer manager
iVertexBufferManagerClientObjects using services provided by the vertexbuffermanager can register with the manager to receive information about it current state, e.g
csVertexStatusThe clipper can output additional information about each vertex in output polygon
iVFSThe Virtual Filesystem Class is intended to be the only way for Crystal Space engine to access the files
csVfsCacheManagerThis is a general cache that can cache data on VFS
csVideoPreferencesThis class is a video preference editor
iVideoStreamA video stream
csVideoStreamDescriptionVideo stream description structure
csViewEncapsulates the top-level Crystal Space renderer interface
iViewEncapsulates the top-level Crystal Space renderer interface
iVirtualClockA virtual game clock
csVirtualClockThis is an implementation of a virtual clock
iVisibilityCullerThis interface represents a visibility culling system
iVisibilityObjectAn object that wants to know if it is visible or not for some visibility culler needs to implement this interface
iVisibilityObjectIteratorIterator to iterate over some visibility objects
csWideSparse3DThis 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))
csWindowA csWindow object is a rectangular area of screen with border which optionally contains a titlebar, a menubar and a client component
csWindowListWindow List class
csWindowSkinThis class defines the interface for a window skin slice
csWSTextureTexture representation within the windowing system
csWSTexVectorThis class is a vector of csWSTexture's
csXRotMatrix3An instance of csMatrix3 that is initialized as a rotation about X
csXScaleMatrix3An instance of csMatrix3 that is initialized to scale the X dimension
csYRotMatrix3An instance of csMatrix3 that is initialized as a rotation about Y
csYScaleMatrix3An instance of csMatrix3 that is initialized to scale the Y dimension
csZRotMatrix3An instance of csMatrix3 that is initialized as a rotation about Z
csZScaleMatrix3An instance of csMatrix3 that is initialized to scale the Z dimension

Generated for Crystal Space by doxygen 1.2.14