CrystalSpace

Public API Reference

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

Crystal Space Compound List

Here are the classes, structs, unions and interfaces with brief descriptions:
_csKeyModifiersFlags for all currently pressed modifiers
csAbsoluteLayoutThis is just for completeness
csAlphaModeDescribes how to deal with alpha values in textures
iAnimatedImageIf an image file has animation capabilities, this interface is exhibited
csAnimatedPixmapA pixmap with a 2d animation
csAnimationTemplateA 2d animation template. This class is used to create animated pixmaps
csAnonRenderBufferManagerDocument me! @
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, ElementHandler, MemoryAllocator >A templated array class
csArrayCmp< T, K >A functor template which encapsulates a key and a comparison function for use with key-related csArray<> searching methods, such as FindKey() and FindSortedKey()
csArrayElementHandler< T >The default element handler for csArray
csArrayMemoryAllocator< T >The default allocator for csArray
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
iAwsComponentNode@Document me!
iAwsConnectionKeyDocument me!@
iAwsConnectionNodeFactoryInterface for connection node factories
iAwsDockableWindowDocument me! @
iAwsDockSiteDocument me! @
iAwsFloatKeyDocument me!@
iAwsIntKeyDocument me!@
iAwsKeyDocument me!@
iAwsKeyContainerDocument me!@
iAwsKeyFactoryInterface for key factories
iAwsLayoutManagerDocument me!@
iAwsParmListProvides support for safely passing named parameters through to different functions in a portable manner
iAwsPointKeyDocument me!@
iAwsPrefManagerInterface for the preferences manager (window manager needs one.)
iAwsRectKeyDocument me!@
iAwsRGBKeyDocument me!@
iAwsSinkInterface for sinks
iAwsSinkManagerInterface for the sink manager
iAwsSlotInterface for signal slots (conduits)
iAwsSourceInterface for signal sources
iAwsStringKeyDocument me!@
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
csBaseTextureFactoryBase class for texture factories, with support for common parameters
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
csBitmapMetricsMetrics for a glyph that are dependent from whether a simple or antialiased image is used
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
csBSPTreeThis BSP-tree is a binary tree that organizes a triangle mesh
iBugPlugUsing this interface you can communicate with the BugPlug plugin
iBugPlugRenderObjectAn application/module can implement this interface to render something
csButtonThe Button class implements different types of push buttons
csButtonSkinThis class defines the interface for a button skin slice
iCacheManagerA generic cache system
iCameraCamera class
iCameraPositionA camera position
iCameraPositionListA list of camera position objects
csCatmullRomSplineA CatmullRom spline
csCheckBoxClose child of csButton class
csClipInfoStructure for use with ClipToPlane
csClipperAbstract parent to all 2D clipping objects
iClipper2DThis interfaces represents a 2D clipper for polygons
csCodecDescriptionCodec description structure
iCollectionA collection object is for convenience of the script language
iCollectionListICollection list
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 convenience 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
csCommandLineOptionRepresentation of a commandline option
iCommandLineParserA utility class that makes it easier to parse the command line
csCommandLineParserUtility 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
csCompressVertexThis structure is used by csVector3Array::CompressVertices()
csConditionA condition object
iConfigInterface to a configurator object
csConfigAccessThis is a simple convenience class that can be used to deal with the sytem config manager
csConfigDocumentIConfigFile implementation for configurations stored in documents
iConfigFileConfiguration file interface
csConfigFileConfiguration file which implements the iConfigFile SCF interface
iConfigIteratorIterator which allows sequential access to configuration information contained in an iConfigFile object
iConfigManagerThe configuration manager is used to make a number of iConfigFile object appear like a single object
csConfigManagerA configuration manager makes a number of individual iConfigFile objects appear to be a single configuration 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
csConstCharHashKeyHandlerA hash key handler for const char* strings
csConstraintVectorThe layout classes collect the constraints in here
csCoreRenderMeshData required by the renderer to draw a mesh
iCrossBuilderThe crossbuilder can be used to build things and sprite factories from single objects of imported model files (iModelDataObject)
iCrossHaloThis is a halo which resembles a cross
csCrystalBallThis is an attempt to provide a massdetection of backfaced polygons
csCtoWHelper class to convert (UTF-8)widechar* to char* strings for use as function parameters
csCubicSplineA cubic spline
iCursorThis interface is used to access the custom cursor plugin, which handles processing for displaying pixmaps as cursors
iCurveThis is the interface for a curve
iDataBufferThe iDataBuffer interface can be used to exchange buffers with abstract data between plugins
csDataBufferThis is a implementation of iDataBuffer interface
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
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
csDirtyAccessArray< T >An automatically growing array of objects
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 4D vector with "double" components
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
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
iEngineSequenceManagerSequence manager specifically designed for working on the engine
iEngineSequenceParametersAn interface for passing on parameters to the engine sequence manager
iEventThis interface describes any system event
csEventThis class represents a system event
csEventCommandDataCommand event data in iEvent
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
csEventCordEvent cord
iEventHandlerThis interface describes an entity that can receive events
csEventJoystickDataJoystick event data in iEvent
csEventMouseDataMouse event data in iEvent
iEventOutletThe iEventOutlet is the interface to an object that is provided by an event queue to every event plug when it registers itself
csEventOutletA class which implements the iEventOutlet interface
iEventPlugEvent plug interface, also referred as "event source"
iEventQueueThis interface represents a general event queue
csEventQueueThis class represents a general event queue
csEventTimerThis class implements a timer
iEventTimerA timer
iExplosionStateThis interface describes the API for the explosion mesh object
iFactoryIFactory is an 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
iFireTextureInterface to the 'fire' procedural texture
csFlagsSet of flags which can be accessed through masks
iFlareHaloThis is a halo which resembles a (solar) flare
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
iFrustumViewThis structure represents all information needed for the frustum visibility calculator
iFrustumViewUserdataUser data which can be attached to iFrustumView
G3DCam2TextureTransformInformation about a texture plane
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
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
iGenericRenderStepA generic render step
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
csGlyphMetricsMetrics for a glyph that are independent from whether a simple or antialiased image is used
csGradientA simple color gradient
csGradientShadeAn entry in a csGradient gradient
iGraphics2DThis is the interface for 2D renderer
iGraphics3DThis is the standard 3D graphics interface
csGraphics3DCapsInformation about 3d renderer capabilities
iGraphicsMemoryThis is the interface used to access the csGraphicsMemory plugin
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
csGridLayoutComponents are displayed in a grid fashion
csGridViewThe GridView displays a continuous rectangular region of the grid
iHaloIHalo: used to render halos (aka "light globes")
csHash< T, K, KeyHandler >A generic hash table class, which grows dynamically and whose buckets are unsorted arrays
csHash< T, K, KeyHandler >::GlobalIteratorAn iterator class for the hash
csHash< T, K, KeyHandler >::IteratorAn iterator class for the hash
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
csHashReversible< T, K, KeyHandler, ReverseKeyHandler >A csHash<> that maintains a reverse hash for indexing keys by values
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
csImageMemoryMemory image
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
iInputBinderBooleanRepresents the up or down state of a keyboard key or a mouse or joystick button, shared between plugins
csInputBinderBooleanRepresents the up or down state of a keyboard key or a mouse or joystick button, shared between modules
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
csIntegralHashKeyHandler< T >A hash key handler for integral types and types that can be casted to such
scfInterface< T >Interface query class
csIntersect2Some functions to perform various intersection calculations with 2D line segments
csIntersect3Some functions to perform various intersection calculations with 3D line segments
iJointThis is the interface for a joint
iJoystickDriverGeneric Joystick driver
csJoystickDriverGeneric 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
iKeyboardDriverGeneric Keyboard Driver
csKeyboardDriverGeneric Keyboard Driver
csKeyboardDriver::eiEventHandlerIEventHandler implementation
iKeyComposerKeyboard input handler
csKeyEventDataStructure that collects the data a keyboard event carries
csKeyEventHelperHelper class to conveniently deal with keyboard events
csKeyValuePairA Key Value pair
iKeyValuePairA Key Value pair
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
iLightThe iLight interface is the SCF interface for the csLight class
iLightCallbackSet a callback which is called when this light color is changed
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
iLightingProcessInfoThe iLightingProcessInfo interface holds information for the lighting system
iLightIteratorIterator to iterate over all static lights in the engine
iLightIterRenderStepDocument me!@
iLightListThis structure represents a list of lights
iLightManagerAn engine (3D or iso) can implement this interface for the benefit of mesh objects so that they can request lighting information from the engine
iLightningFactoryStateDocument me! @
iLightRenderStepDocument me!@
csList< T >A lightweight double-linked list template
csList< T >::csListElementTemplate which describes the data stored in the linked list For example a list of ints uses csListElement<int>
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
iLoaderStatusAn object to query about the status of the threaded loader
iLODControlThe iLODControl interface represents an object that has controllable LOD features
csMapNodeA node
iMapNodeA node
iMaterialThis class represents a material as seen from the engine view
iMaterialEngineThis interface represents the engine part of the material definition
iMaterialHandleThis class represents a material handle (compiled material) for the 3D rasterizer
iMaterialListThis class represents a list of materials
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 0-terminated)
csMemFileEssentially a raw memory buffer which implements the abstract iFile interface
csMemoryMappedIODefines a simple memory-mapped IO class that is portable
iMemoryTrackerThis interface is used with CS_MEMORY_TRACKER
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
iMeshFactoryListA list of mesh factories
iMeshFactoryWrapperA mesh factory wrapper is an engine-level object that wraps around a mesh object factory (iMeshObjectFactory)
iMeshListA list of meshes
csMeshObjectThis is an abstract implementation of iMeshObject
iMeshObjectThis is a general mesh object that the engine can interact with
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
iMeshWrapperA mesh wrapper is an engine-level object that wraps around an actual mesh object (iMeshObject)
iMeshWrapperIteratorThis is an iterator mesh wrappers
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
csModelDataActionDocument me!@
iModelDataActionAn action
csModelDataCameraDocument me!@
iModelDataCameraA camera in the scene
csModelDataLightDocument me!@
iModelDataLightA light source in the scene
csModelDataMaterialDocument me!@
iModelDataMaterialThis structure contains the information about a material for an imported model
csModelDataObjectDocument me!@
iModelDataObjectOne object in the scene
csModelDataPolygonDocument me!@
iModelDataPolygonOne polygon in a model
csModelDataTextureDocument me!@
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
csModelDataVerticesDocument me!@
csMouseThis class handles mouse pointer and generates mouse events
iMouseDriverGeneric Mouse Driver
csMouseDriverGeneric Mouse Driver
csMouseDriver::eiEventHandlerIEventHandler implementation
csMousePointerThis class encapsulates mouse pointer
iMovableThis interface represents the position and orientation of an object relative to its parent (this is the transformation between local object space of the model and world space (i.e
iMovableListenerImplement this class if you're interested in hearing about movable changes
iMovieRecorderUsing this interface you can communicate with the MovieRecorder plugin
csMutexA mutual-exclusion object
iNativeWindowThis interface represents a native window
iNativeWindowManagerThis interface represents the native window manager system
csNodeIteratorA node iterator
csNotebookA notebook (also called "property sheet") is a collection of dialogs enclosed in a single window
iNovaHaloThis is a halo which resembles a nova
csNullCacheManagerThis is a general cache that doesn't cache anything at all
iNullFactoryStateThis interface describes the API for the null mesh object factory
iNullMeshStateThis interface describes the API for the null mesh object
csOBBOriented bounding box (OBB)
csOBBFrozenVersion of the csOBB with frozen corners (for optimization purposes)
iObjectThis interface is an SCF interface for encapsulating csObject
csObjectA generic csObject class
iObjectIteratorThis is an iterator for child objects of a csObject
iObjectModelThis interface represents data related to some geometry in object space
csObjectModelHelper class to make it easier to implement iObjectModel in mesh objects
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
iObjectWatcherListenerImplement this class if you're interested in hearing about object watcher events
iODEDynamicStateThis class exposes parameters specific to odedynam as an implementation of iDynamics
iODEDynamicSystemStateThis class exposes parameters specific to odedynam as an implementation of iDynamics
iODEFrameUpdateCallbackThis class can be passed in as a callback during the physics update it is only called if FrameRate is enabled
iODEJointState@ Document me
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
csOrdering< T1, T2 >A template providing various comparison and ordering functions
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
iParticleA iParticle can be used in particle Systems
iParticlesColorCallbackParticles state can be set up to retrieve color via a callback
csParticlesDataRepresentational information of a particle
iParticlesFactoryStateParticles factory state
iParticlesObjectStateParticles state object
iParticlesPhysicsParticles physics interface
iParticlesStateBaseParticles shared state interface
iParticleStateThis interface describes the API for the particle mesh object
iPathA path in 3D
csPathA path in 3D
csPDelArray< T >An array of pointers
csPhysicalFileAn implementation of the abstract iFile interface for real files within the physical filesystem
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
csPluginPathThis structure contains information about a plugin path
csPluginPathsClass to manage a list of plugin paths
csPluginRequestThis class represents a single plugin request for csInitializer::RequestPlugins()
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
iPolygonBuffer@@OR@@ This interface represents a black-box polygon buffer
csPolygonClipperCan be used for clipping any polygon against any other convex polygon
iPolygonHandleThis is an interface that can be used to represent a polygon in situations where a SCF object is required
csPolygonMeshA convenience polygon mesh implementation that you can feed with vertices and polygons from another source
iPolygonMeshThis interface reprents a mesh of polygons
csPolygonMeshBoxA convenience polygon mesh implementation that represents a cube
csPolygonMeshEdgeA definition of one edge
csPolygonMeshToolsA set of tools to work with iPolygonMesh instances
csPolygonRangeA range structure for specifing polygon ranges
csPolygonRenderDataThis structure is used for communicating polygon information to the polygon renderer
csPolygonTreeA polygon tree
csPolyIndexedThe following class represents a general polygon
csPolyTextureMappingThis structure holds mapping information to map the texture and lightmap on a polygon
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
iPortalContainerA container for portals
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)
csProcessorCapabilityThis class is used to identify capabilities in the processor such as support for MMX and SSE
csProcFireFire
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
iProcTextureInterface to a texture factory
csProcWaterWater
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
csRefHashKeyHandler< T >A hash key handler for csRef<> keys
iRefTrackerThe reference tracker interface
csRefTrackerAccessHelper to facilitate access to the global reference tracker
csRegExpMatchInformation about (sub)expression matches
csRegExpMatcherMatcher for regular expressions
iRegionA region
iRegionListA list of region objects
iRenderBufferThis is a general buffer to be used by the renderer
csRenderBufferLock< T >Helper class for convenient locking/unlocking of an iRenderBuffer
csRenderContextThis structure keeps track of the current render context
iRendererLightmapA lightmap registered with a renderer
iRenderLoopRender loop
iRenderLoopManagerRender loop manager
csRenderMeshMesh data as returned by mesh plugins
csRenderMeshHolderMultipleHelper class to retrieve an unused array of csRenderMesh*
csRenderMeshHolderSingleHelper class to retrieve an unused csRenderMesh
csRenderMeshListThis class is used when we need to store, sort and then render a list of rendermeshes
csRenderMeshModesMesh render mode information
iRenderStepDocument me!@
iRenderStepContainerContainer for render steps
iRenderStepFactoryInterface to a render step factory
iRenderStepTypeRender step type
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
csSafeCopyArray< T >Convenience class to make a version of csArray that does a safe-copy in case of reallocation of the array
csSafeCopyArrayMemoryAllocator< T, ElementHandler >Special allocator for csArray that makes sure that when the array is reallocated that the objects are properly constructed and destructed at their new position
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
csScfStringSetThe string set is a list of strings, all with different content
csScheduleEasy way to get timers in applications
csScopedMutexLockThis is a utility class for locking a Mutex
iScriptThis provides the interface to a scripting language interpreter
iScriptObjectThis provides the interface to an object in an object-oriented scripting language
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"
iSectorCallbackSet a callback which is called when this sector is traversed
iSectorIteratorAn iterator to iterate over sectors
iSectorListA list of sectors
csSegment2A 2D line segment
csSegment3A 3D line segment
csSemaphoreA 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
csSet< T, KeyHandler >This class implements a basic set for objects
csSet< T, KeyHandler >::GlobalIteratorAn iterator class for the set
csSet< T, KeyHandler >::IteratorAn iterator class for the set
iShaderSpecific shader
iShaderCompilerCompiler of shaders
csShaderExpressionAn evaluable expression attached to a shader variable
iShaderManagerA manager for all shaders
iShaderPriorityListA list of priorities as returned by iShaderCompiler->GetPriorities()
iShaderRenderInterfaceDocument me!@
csShaderVariableStorage class for inheritable variables in the shader system
iShaderVariableAccessorInterface to an accessorcallback for shadervariables
iShaderVariableContextThis is a baseclass for all interfaces which provides shadervariables both dynamically and static
iShadowBlockA block of shadows represent the shadows that are casted by one iShadowCaster object
iShadowBlockListThis is a list of shadow blocks
iShadowCasterAn object that can cast shadows
iShadowIteratorA shadow iterator allows someone to iterate over all shadows in a iShadowBlock or iShadowBlockList
iShadowReceiverAn object that is interested in getting shadow information
iSharedVariableISharedVariable implements a refcounted value which can be shared across many objects and updated efficiently
iSharedVariableListA list of shared variables
iSharedVariableListenerA listener so that you can get notified when a variable is changed
iSimpleFormerStateISimpleFormerState exposes implementation specific methods for the SimpleTerraformer plugin
csSimplePixmapThis is the simple implementation of csPixmap that uses a single texture
csSimpleRenderMeshA simple render mesh
csSingleIndexVertexSetThis class can be used to construct objects which use a single index for vertex
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
csSoundWrapperDocument me and possible move me to some sound manager! @
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
iSpriteCal3DFactoryStateThis interface describes the API for the 3D sprite factory mesh object
iSpriteCal3DSocketA socket for specifying where sprites can plug into other sprites
iSpriteCal3DStateThis interface describes the API for changing the Cal3D sprite mesh object's animations playing and other current traits
iSpriteFrameA frame for 3D sprite animation
iSpriteSocketA socket for specifying where sprites can plug into other sprites
csSquaredDistSome functions to perform squared distance calculations
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
iStreamA stream
csStreamDescriptionStream description structure
iStreamFormatStream format
scfStringThis is a thin SCF wrapper around csString
csStringThis is a string class with a range of useful operators and type-safe overloads
iStringThis is a SCF-compatible interface for csString
scfStringArrayThis class is a thin wrapper around csStringArray with SCF capability
csStringArrayAn array of strings
iStringArrayThis is an SCF-compatible interface for csStringArray
csStringHashA string-to-ID hash table
csStringHashIteratorAn iterator to iterate over elements in a csStringHash
csStringReaderThis is a convenience class that reads an input buffer line by line
iStringSetThe string set is a list of strings, all with different content
csStringSetThe string set is a list of strings, all with different content
csStringSetIteratorAn iterator to iterate over elements in a csStringSet
csStrKeyThis is a simple helper class to make a copy of a const char*
csStructKeyHandler< T >A hash key handler for struct type keys
csSubRectSub-rectangle
csSubRectanglesA class managing allocations of sub-rectangles
csSubRectangles2A class managing allocations of sub-rectangles
iSuperLightmapA super light map
iSyntaxServiceThis component provides services for other loaders to easily parse properties of standard CS world syntax
iTerraFormerTerraFormer objects are used to retrieve terrain data
iTerrainFactoryStateAllows the setting of a set of generic terrain parameters outside any specific algorithm
iTerrainHeightFunctionThis class represents a function for the terrain engine
iTerrainNormalFunctionThis class represents a function for the terrain engine
iTerrainObjectStateThis will override the settings for material in the parent
iTerraSamplerTerraSampler objects are used for the actual queries of terrain data Sampler regions are requested from the iTerraFormer plugin, and sampled for data via the Sample methods
iTerrFuncStateThis interface describes the API for the terrain object
csTextProgressMeterDisplays a simple percentage-style textual progress meter
iTextureCallbackA callback for when a iTextureWrapper is used
iTextureFactoryInterface to a texture factory
iTextureHandleA texture handle as returned by iTextureManager
csTextureLayerThis structure represents an extra texture layer which is applied on top of the previous one
iTextureListThis class represents a list of texture wrappers
iTextureLoaderContextInterface passed to a texture loader, holding some common texture properties
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
iTextureTypeTexture type
iTextureWrapperA texture wrapper is an engine-level object that wraps around an actual texture (iTextureHandle)
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
csThreadRepresentation of a thread of executation
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
iTimerEventA timer event
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
csTree< T >A generic binary search tree
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
csTriangleMeshLODA static class which performs the calculation of the best order to do the collapsing
csTriangleVertexThe representation of a vertex in a triangle mesh
csTriangleVertexCostThe representation of a vertex in a triangle mesh
csTriangleVerticesA class which holds vertices and connectivity information for a triangle mesh
csTriangleVerticesCostA class which holds vertices and connectivity information for a triangle mesh
csTypedObjectIteratorHelper class for CS_DECLARE_OBJECT_ITERATOR macro
csUnicodeTransformContains functions to convert between several UTF encodings
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
csVector2A 2D vector
csVector3A 3D vector
csVector3ArrayThis is actually the same class as csPoly3D
csVector4A 4D vector with "float" components
iVertexBuffer@@OR@@ This interface represents a black-box vertex buffer
iVertexBufferManager@@OR@@ This 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
iViewEncapsulates the top-level Crystal Space renderer interface
csViewEncapsulates the top-level Crystal Space renderer interface
csVirtualClockThis is an implementation of a virtual clock
iVirtualClockA virtual game clock
iVisibilityCullerThis interface represents a visibility culling system
iVisibilityCullerListenerImplement this interface when you want to get notified about visible objects detected by the visibility cullers
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
iVosA3DLThis is the initial component you retrieve from the registry to access the VOS A3DL plugin
iVosObject3DThis interface bridges between a VOS 3D object and the Crystal Space mesh wrapper created for that object
iVosSectorThis interface bridges between a VOS sector and a Crystal Space sector
csWeakRef< T >A weak reference
csWeakRefArray< T >An array of weak references
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))
iWin32AssistantThis interface describes actions specific to the Windows platform
csWin32RegistryConfigAn iConfigFile, storing the settings in the Windows registry
csWin32RegistryIteratorIterates over a registry key subkeys and values
cswinCallStackHelperCall stack creation helper (Win32-specific)
cswinCtoASmall helper to convert an UTF-8 to an ANSI string, useful when passing arguments to a function
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
cswinMinidumpWriterHelper to write minidumps on Win32
cswinWtoASmall helper to convert a wide to an ANSI string, useful when passing arguments to a function
csWSTextureTexture representation within the windowing system
csWSTexVectorThis class is a vector of csWSTexture's
csWtoCHelper class to convert widechar* to char*(UTF-8) strings for use as function parameters
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.18