Crystal Space Class List
Here are the classes, structs, unions and interfaces with brief descriptions:| _csKeyModifiers | Flags for all currently pressed modifiers | 
| ADDRESS64 | |
| CS::Memory::AllocatorAlign< A > | This class implements an allocator policy which aligns the first element on given byte boundary | 
| CS::Memory::AllocatorHeap< HeapPtr > | A memory allocator that allocates from a heap | 
| CS::Memory::AllocatorHeapBase< HeapAccess > | A memory allocator that allocates from a heap | 
| CS::Memory::AllocatorMalloc | A default memory allocator that allocates with cs_malloc() | 
| CS::Memory::AllocatorPointerWrapper< T, Allocator > | Class to store a pointer that is allocated from Allocator, to eliminate overhead from a possibly empty Allocator | 
| CS::AllocPlatform | |
| CrystalSpace::COMPILE_ASSERT_FAILURE< x > | |
| CrystalSpace::COMPILE_ASSERT_FAILURE< true > | |
| CrystalSpace::CompileAssertTest< x > | |
| CS::ConditionAnd< T1, T2 > | |
| CS::CowWrapper< T, MemoryAllocator > | Copy-on-write wrapper for arbitrary types | 
| csAddonReference | An object representing an addon | 
| csAlphaMode | Describes how to deal with alpha values in textures | 
| csAnimatedPixmap | A pixmap with a 2d animation | 
| csAnimationTemplate | A 2d animation template. This class is used to create animated pixmaps | 
| csAnsiParser | Helper to parse a string for ANSI codes | 
| csAnsiParser::CommandParams | Parameters to ANSI command | 
| csAnsiParser::CursorParams | |
| csApplicationFramework | Application framework class | 
| csApplicationRunner< T > | Helper template to run a csApplicationFramework-derived application class | 
| csArchive | This class can be used to work with standard ZIP archives | 
| csArray< T, ElementHandler, MemoryAllocator, CapacityHandler > | A templated array class | 
| csArray< T, ElementHandler, MemoryAllocator, CapacityHandler >::ConstIterator | Iterator for the Array<> class | 
| csArray< T, ElementHandler, MemoryAllocator, CapacityHandler >::Iterator | Iterator for the Array<> class | 
| csArrayCapacityDefault | |
| csArrayCapacityLinear< Threshold > | CsArray capacity handler | 
| 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 | 
| csArraySafeCopyElementHandler< T > | Special element handler for csArray that makes sure that when the array is reallocated that the objects are properly constructed and destructed at their new position | 
| csArrayThresholdFixed< N > | CsArray fixed threshold for capacity handlers | 
| csArrayThresholdVariable | CsArray variable threshold for capacity handlers | 
| csBakeKeyColor | Functions to bake keycolor into the alpha channel of images | 
| csBaseEventHandler | Base implementation of a generic event handler | 
| csBaseEventHandler::EventHandlerImpl | Actual iEventHandler implementation | 
| csBaseRenderStepLoader | Base class for render step loaders | 
| csBaseRenderStepType | Base class for render step loaders | 
| csBaseTextureFactory | Base class for texture factories, with support for common parameters | 
| csBigEndian | Big endian to native conversion routines | 
| csBitArray | A one-dimensional array of bits, similar to STL bitset | 
| csBitArrayTweakable< InlinedBits, Allocator > | A one-dimensional array of bits, similar to STL bitset | 
| csBitArrayTweakable< InlinedBits, Allocator >::BitProxy | |
| csBitmapMetrics | Metrics for a glyph that are dependent from whether a simple or antialiased image is used | 
| csBitmaskToString | Small helper to get a "pretty" string for a combination of bit masks | 
| csBitmaskToString::MaskNames | Structure containing a name for possible bit masks | 
| csBlockAllocator< T, Allocator, ObjectDispose > | This class implements a memory allocator which can efficiently allocate objects that all have the same size | 
| csBlockAllocatorDisposeDelete< T > | Block allocator disposal mixin that just destructs an instance | 
| csBlockAllocatorDisposeLeaky< T > | Block allocator disposal mixin that destructs, unless upon final cleanup, where a warning is emitted stating that objects leaked | 
| csBox2 | A bounding box in 2D space | 
| csBox2Int | A 2D bounding box with integer coordinates | 
| csBox3 | A bounding box in 3D space | 
| csBox3::bEdge | |
| csBox3::Outline | This table also contains an array of sides visible from that region | 
| csBoxClipper | Able to clip convex polygons to a rectangle (such as the screen) | 
| csBSpline | A B-spline | 
| csBSPTree | This BSP-tree is a binary tree that organizes a triangle mesh | 
| csCallStack | Call stack | 
| csCallStackHelper | Helper to create a call stack | 
| csCatmullRomSpline | A CatmullRom spline | 
| csChainHull2D | This is Andrew's monotone chain 2D convex hull algorithm | 
| csClipInfo | Structure for use with ClipToPlane | 
| csClipper | Abstract parent to all 2D clipping objects | 
| csCLQAttenuation | Constant, Linear, Quadratic attenuation Out = in /(const + distance*lin + distance^2*quad) | 
| csColliderActor | With csColliderActor you can more easily manage collision detection of a player or character model with gravity handling | 
| csColliderHelper | This is a class containing a few static member functions to help work with csColliderWrapper and collision detection in general | 
| csColliderWrapper | This 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) | 
| csCollisionPair | A structure used to return collision pairs | 
| csColor | A class used to represent a color in RGB space | 
| csColor4 | A class used to represent a color in RGBA space | 
| csColorQuantizer | Color quantizer | 
| csCommandEventData | Structure that collects the data a command event carries | 
| csCommandEventHelper | Helper class to conveniently deal with command events | 
| csCommandLineHelper | This class can be used to help parsing the commandline | 
| csCommandLineOption | Representation of a commandline option | 
| csCommandLineParser | Utility class that makes it easier to parse the command line | 
| csCommonImageFile | A base class for image loader plugin iImage implementations | 
| csCommonImageFile::LoaderJob | |
| csCommonImageFileLoader | Base image loader implementation | 
| csComparator< T1, T2 > | A template providing various comparison and ordering functions | 
| csComparator< const char *, const char * > | CsComparator<> specialization for strings that uses strcmp() | 
| csComparator< csBitArray, csBitArray > | CsComparator<> specialization for csBitArray to allow its use as e.g | 
| csComparator< csInputDefinition, csInputDefinition > | CsComparator<> specialization for csInputDefinition to allow its use as e.g | 
| csComparator< csRGBcolor *, csRGBcolor * > | CsComparator<> specialization for csColor* | 
| csComparator< csRGBcolor, csRGBcolor > | CsComparator<> specialization for csRGBcolor | 
| csComparator< csString, csString > | CsComparator<> specialization for csString that uses strcmp() | 
| csComparator< csStringBase, csStringBase > | |
| csComparator< csStrKey, csStrKey > | CsComparator<> specialization for csStrKey that uses strcmp() | 
| csComparatorBitArray< BitArray > | Base comparator for bit arrays | 
| csComparatorString< T > | Template that can be used as a base class for comparators for string types | 
| csComparatorStruct< T > | Template that can be used as a base class for comparators for POD (plain old data) types | 
| csCompressVertex | This structure is used by csVector3Array::CompressVertices() | 
| csCompressVertexInfo | This structure is used by csVertexCompressor::Compress() | 
| csCondition | A condition object | 
| csConfigAccess | This is a simple convenience class that can be used to deal with the sytem config manager | 
| csConfigDocument | IConfigFile implementation for configurations stored in documents | 
| csConfigFile | Configuration file which implements the iConfigFile SCF interface | 
| csConfigManager | A configuration manager makes a number of individual iConfigFile objects appear to be a single configuration object | 
| csCoreRenderMesh | Data required by the renderer to draw a mesh | 
| csCoverageTile | Coverage tile | 
| csCtoW | Helper class to convert char* (UTF-8 encoded )to wchar_t* strings for use as function parameters | 
| csCubicSpline | A cubic spline | 
| csCursorConverter | Helper class to convert images into data formats suitable for mouse cursor creation on various platforms and toolkits | 
| csDataBuffer | This is an implementation of iDataBuffer interface | 
| csDebuggingGraph | This is a static class that helps with debugging | 
| csDebugImageWriter | Helper class allowing in debug builds for to quickly dump an iImage object onto disk for visual inspection | 
| csDIntersect3 | Some functions to perform various intersection calculations with 3D line segments | 
| csDirectionalLightProc< AttenuationProc > | Preform directional light lighting calculation without shadowing | 
| csDirectionalLightProc< AttenuationProc >::PerVertex | |
| csDirectXError | Obtain symbols and descriptions for DirectX error codes | 
| csDirtyAccessArray< T, ElementHandler > | A templated array class | 
| csDirtyAccessArrayRefCounted< T, ElementHandler > | A variant of csDirtyAccessArray with reference-counted contents | 
| csDMath3 | Various assorted 3D mathematical functions | 
| csDMatrix3 | A 3x3 matrix | 
| csDocumentAttributeCommon | Partial iDocumentAttribute implementation with commonly duplicated logic | 
| csDocumentNodeCommon | Partial iDocumentNode implementation with commonly duplicated logic | 
| csDocumentNodeReadOnly | Partial iDocumentNode implementation with commonly duplicated logic and dummy implementations for manipulation methods | 
| csDPlane | A plane in 3D space | 
| csDSquaredDist | Some functions to perform squared distance calculations | 
| csDVector3 | A 3D vector | 
| csEllipsoid | This class represents an ellipsoid | 
| csEmptyDocumentAttributeIterator | Document attribute iterator does not return any attributes | 
| csEmptyDocumentNodeIterator | Document node iterator does not return any nodes | 
| csEngineTools | This is a class with static helper functions for working on engine data | 
| csEvent | This class represents a system event | 
| csEventAttributeIterator | |
| csEventCord | Event cord | 
| csEventCord::PluginData | |
| csEventFlattener | Standard event flattener(also known as serializer) | 
| csEventHandlerRegistry | The csEventHandlerRegistry maintains a global one-to-one mapping from strings to csHandlerIDs, and a one-to-(zero or one) mapping from csHandlerIDs to iEventHandler pointers | 
| csEventNameRegistry | The csEventNameRegistry transforms textual event names (e.g., "crystalspace.input.joystick.3.button") into easier-to-manage csEventIDs (which, in non-debug builds, are really just csStringIDs) | 
| csEventOutlet | A class which implements the iEventOutlet interface | 
| csEventQueue | This class represents a general event queue | 
| csEventQueue::FinalProcessFrameEventDispatcher | |
| csEventQueue::iTypedFrameEventDispatcher | As a transitional measure, the csevPreProcess, csevProcess, csevPostProcess and csevFinalProcess events are actually sub-events dispatched by a csevFrame handler | 
| csEventQueue::PostProcessFrameEventDispatcher | |
| csEventQueue::PreProcessFrameEventDispatcher | |
| csEventQueue::ProcessFrameEventDispatcher | |
| csEventTimer | This class implements a timer | 
| csEventTree | This class is used to represent the event namespace (tree) | 
| csEventTree::SubscriberIterator | The SubscriberIterator is a wrapper for the messy internals of figuring out which event handler to call next | 
| csFIFO< T, ElementHandler, MemoryAllocator > | A FIFO implemented on top of csArray<>, but faster than using just a single array | 
| csFileReadHelper | Convenience class for simple file element reading | 
| csFileTime | File time structure - used to query and set the last-modification time of a file | 
| csFixed16 | Encapsulation of a 16.16 fixed-point number | 
| csFixed24 | Encapsulation of a 8.24 fixed-point number | 
| csFixedSizeAllocator< Size, Allocator > | This class implements a memory allocator which can efficiently allocate objects that all have the same size | 
| csFixedSizeAllocator< Size, Allocator >::BlockKey | |
| csFixedSizeAllocator< Size, Allocator >::BlocksWrapper | |
| csFixedSizeAllocator< Size, Allocator >::DefaultDisposer | Default disposer mixin, just reporting leaks | 
| csFixedSizeAllocator< Size, Allocator >::FreeNode | |
| csFlags | Set of flags which can be accessed through masks | 
| csFmtDefaultReader< T > | Standard format string source for csPrintfFormatter | 
| csFmtDefaultWriter< T > | Standard formatted string destination for csPrintfFormatter | 
| csFog | Sector fog structure | 
| csFogInfo | Information for vertex based fog | 
| csFogMath | Fog math utilities | 
| csFontCache | A cache for font glyphs | 
| csFontCache::FontDeleteNotify | Font deletion callback | 
| csFontCache::GlyphCacheData | Some basic data associated with a glyph | 
| csFontCache::KnownFont | A font known to the cache | 
| csFontCache::LRUEntry | An entry in the LRU list | 
| csFontCache::PlaneGlyphElementHandler | |
| csFontCache::PlaneGlyphs | Array of a number of glyphs | 
| csFrameDataHolder< T > | Helper template to retrieve an instance of some type that has not yet been used in a frame | 
| csFrustum | A general frustum | 
| csFrustumContext | This structure keeps track of the current frustum context | 
| csG2DDrawBox< Tpixel, Tpixmixer > | Draw a box to a (software) canvas | 
| csG2DDrawLine< Tpixel, Tpixmixer > | Class to draw a line | 
| csG2DDrawText< Tpixel, Tpixmixer1, Tpixmixer2, Tpixmixer3 > | Class to write some text | 
| csGenerateImage | This class will compute a texture for a terrain | 
| csGenerateImageLayer | This class is used to store the layers of textures per value | 
| csGenerateImageTexture | A base class which represents a texture that can be displayed on the terrain | 
| csGenerateImageTextureBlend | Class for a texture that is made by blending together other textures based on a value | 
| csGenerateImageTextureSingle | A class for a single texture | 
| csGenerateImageTextureSolid | A class for a solid coloured texture | 
| csGenerateImageValue | A base class which represents a value that can be computed for blending purposes for each pixel | 
| csGenerateImageValueFunc | This class will generate a value using a given function | 
| csGenerateImageValueFuncConst | This class will generate a constant value | 
| csGenerateImageValueFuncTex | This class will generate a value using a texture | 
| csGeomDebugHelper | This is a class that does unit testing (and other debug stuff) for most of csgeom classes | 
| csGetFromAddress | Sized data type access helpers | 
| csGLDriverDatabase | OpenGL driver database | 
| csGLExtensionFlags | Struct containing all GL extension test flags | 
| csGLExtensionFunctions | Struct containing all GL extension functions | 
| csGLExtensionManager | GL extensions manager | 
| csGLFontCache | OpenGL font cache | 
| csGLScreenShot | OpenGL screen shot | 
| csGLStateCache | OpenGL state cache | 
| csGLStateCacheContext | |
| csGlyphMetrics | Metrics for a glyph that are independent from whether a simple or antialiased image is used | 
| csGradient | A simple color gradient | 
| csGradient::scfGradientShadesArray | |
| csGradientShade | An entry in an iGradient gradient | 
| csGraphics2D | This is the base class for 2D canvases | 
| csGraphics2DGLCommon | Basic OpenGL version of the 2D driver class | 
| csGraphics2DGLCommon::csGLPixelFormatPicker | |
| csGraphics3DCaps | Information about 3d renderer capabilities | 
| csHash< T, K, ArrayMemoryAlloc > | A generic hash table class, which grows dynamically and whose buckets are unsorted arrays | 
| csHash< T, K, ArrayMemoryAlloc >::ConstGlobalIterator | An const iterator class for the hash | 
| csHash< T, K, ArrayMemoryAlloc >::ConstIterator | An const iterator class for the hash | 
| csHash< T, K, ArrayMemoryAlloc >::Element | |
| csHash< T, K, ArrayMemoryAlloc >::GlobalIterator | An iterator class for the hash | 
| csHash< T, K, ArrayMemoryAlloc >::Iterator | An iterator class for the hash | 
| csHashComputer< T > | Template for hash value computing | 
| csHashComputer< const char * > | CsHashComputer<> specialization for strings that uses csHashCompute() | 
| csHashComputer< const csEventID > | |
| csHashComputer< const csHandlerID > | |
| csHashComputer< csBitArray > | CsHashComputer<> specialization for csBitArray to allow its use as hash key type | 
| csHashComputer< csInputDefinition > | CsHashComputer<> specialization for csInputDefinition to allow its use as hash key type | 
| csHashComputer< double > | |
| csHashComputer< float > | |
| csHashComputer< iEventHandler * > | |
| csHashComputer< int > | |
| csHashComputer< long > | |
| csHashComputer< longlong > | |
| csHashComputer< ulonglong > | |
| csHashComputer< unsigned int > | |
| csHashComputer< unsigned long > | |
| csHashComputer< void * > | CsHashComputer<> specialization for an integral type | 
| csHashComputerBitArray< BitArray > | Base hash computer for bit arrays | 
| csHashComputerIntegral< T > | Template for hash value computing, suitable for integral types and types that can be casted to such | 
| csHashComputerString< T > | Template that can be used as a base class for hash computers for string types (must support cast to const char*) | 
| csHashComputerStruct< T > | Template that can be used as a base class for hash computers for POD structs | 
| csHashReversible< T, K > | A csHash<> that maintains a reverse hash for indexing keys by values | 
| csHitBeamResult | Return structure for the iMeshWrapper->HitBeam() routines | 
| csIdentStrings | Helper class that contains a list of identifiers and their names | 
| csIdentStrings::csIdentString | |
| csIEEEfloat | Convert IEEE 32-bit floats from or to native machine floats | 
| csImageArea | This structure is used for saving/restoring areas of screen | 
| csImageBase | Base class for iImage implementations | 
| csImageCubeMapMaker | Wrapper class to create a cube map from a number of 2D images as the cube faces | 
| csImageIOFileFormatDescription | Description for a file format supported by an image loader | 
| csImageLoaderOptionsParser | Helper class to parse options strings passed to iImageIO::Save() | 
| csImageManipulate | Helper class to manipulate iImage objects | 
| csImageMemory | Memory image | 
| csImageTools | Some helper functions to deal with iImage objects | 
| csImageVolumeMaker | Wrapper class to create a volume aka 3D texture from a number of 2D images as the volume slices | 
| csInitializer | This class contains several static member functions that can help setup an application | 
| csInputBinder | Use this class to bind input events (keypress, button press, mouse move, etc | 
| csInputDefinition | This class holds a description of a physical source of input events, such as a keyboard key, mouse or joystick button, or a mouse or joystick axis | 
| csInputDriver | Superclass of all the generic input drivers | 
| csInputEventHelper | Helper class to conveniently pull generic data out of input events | 
| csInstallationPathsHelper | A helper class containing a number of functions to deal with Crystal Space installation paths | 
| csInterleavedSubBufferOptions | Structure describing the properties of the individual buffers to be interleaved | 
| csIntersect2 | Some functions to perform various intersection calculations with 2D line segments | 
| csIntersect3 | Some functions to perform various intersection calculations with 3D line segments | 
| csIntersectingTriangle | An intersection triangle for CollideRay | 
| csInverseAttenuation | Inverse linear attenuation | 
| csJoystickDriver | Generic Joystick driver | 
| csJoystickEventData | Structure that collects the data a joystick event carries | 
| csJoystickEventHelper | Helper class to conveniently deal with joystick events | 
| csKDTree | A KD-tree | 
| csKDTreeChild | A child in the KD-tree (usually some object) | 
| csKeyboardDriver | Generic Keyboard Driver | 
| csKeyComposer | |
| csKeyEventData | Structure that collects the data a keyboard event carries | 
| csKeyEventHelper | Helper class to conveniently deal with keyboard events | 
| csKeyValuePair | A Key Value pair | 
| csLibraryReference | An object representing a reference to a library | 
| csLightProperties | Light properties, as needed by the attenuation and lighting functors | 
| csLightShaderVarCache | Helper to cache names of shader variables relevant to lighting | 
| csLinearAttenuation | Linear attenuation | 
| csLineOperation | |
| csList< T > | A lightweight double-linked list template | 
| csList< T >::csListElement | Template which describes the data stored in the linked list For example a list of ints uses csListElement<int> | 
| csList< T >::Iterator | Iterator for the list | 
| csLittleEndian | Little endian to native conversion routines | 
| csMapNode | A node | 
| csMath2 | Various functions in 2D, such as 2D vector functions | 
| csMath3 | Various assorted 3D mathematical functions | 
| csMatrix2 | A 2x2 matrix | 
| csMatrix3 | A 3x3 matrix | 
| csMD5 | This is an encapsulation of a C-implementation of MD5 digest algorithm by Peter Deutsch <ghost@aladdin.com> | 
| csMD5::Digest | An MD5 digest is 16 unsigned characters (not 0-terminated) | 
| csMD5::md5_state_t | |
| csMemFile | Essentially a raw memory buffer which implements the abstract iFile interface | 
| csMemoryMappedIO | Defines a simple memory-mapped IO class that is portable | 
| csMemoryMapping | Memory mapping, as returned by csMemoryMappedIO::GetData() | 
| csMemoryPen | The memory pen is a caching pen object | 
| csMemoryPool | A quick-allocation pool for storage of arbitrary data | 
| csMeshedPolygon | A polygon | 
| csMeshFactory | This is the abstract implementation of iMeshObjectFactory | 
| csMeshObject | This is an abstract implementation of iMeshObject | 
| csMeshOnTexture | This class manages the rendering of a mesh on a texture | 
| csMeshType | This is the abstract implementation of iMeshObjectType | 
| csMouseDriver | Generic Mouse Driver | 
| csMouseEventData | Structure that collects the data a mouse event carries | 
| csMouseEventHelper | Helper class to conveniently deal with mouse events | 
| csMutex | A mutual-exclusion object | 
| csNewtonianParticleSystem | This class has a set of particles that behave with phsyics | 
| csNoAttenuation | No attenuation | 
| csNodeIterator | A node iterator | 
| csNormalCalculator | A normal calculator | 
| csNormalizationCubeAccessor | Shader variable accessor for a normalization cubemap | 
| csNormalMappingTools | Some helpers for stuff related to normal maps | 
| csNullCacheManager | This is a general cache that doesn't cache anything at all | 
| csOBB | Oriented bounding box (OBB) | 
| csOBBFrozen | Version of the csOBB with frozen corners (for optimization purposes) | 
| csObject | A generic csObject class | 
| csObjectModel | Helper class to make it easier to implement iObjectModel in mesh objects | 
| csObjectRegistry | This is an implementation of iObjectRegistry | 
| csOptionDescription | Configuration option description | 
| csOrthoTransform | A class which defines a reversible transformation from one coordinate system to another by maintaining an inverse transformation matrix | 
| csPackRGB | RGB data packing | 
| csPackRGBA | RGBA data packing | 
| csParasiticDataBuffer | A databuffer pointing into another databuffer | 
| csParasiticDataBufferBase | Base class for pooled and unpooled parasitic data buffer | 
| csParasiticDataBufferPooled | A databuffer pointing into another databuffer, pooled version | 
| csPartialOrder< T > | A generic finite partial order class | 
| csPartialOrder< T >::Node | |
| csParticle | Data representation of a single particle | 
| csParticleAux | Auxiliary data per particle, not used as often | 
| csParticleBuffer | Buffer holder for particle buffers | 
| csParticleSystem | This class represents a particle system | 
| csParticleSystem::PerFrameData | |
| csPath | A path in 3D | 
| csPathsList | Class to manage a list of paths | 
| csPathsList::Entry | This structure contains information about a plugin path | 
| csPathsUtilities | A helper class with path-related utilities | 
| csPDelArray< T > | An array of pointers | 
| csPDelArrayElementHandler< T > | |
| csPen | A pen specialized for CS | 
| csPhysicalFile | An implementation of the abstract iFile interface for real files within the physical filesystem | 
| csPixelCoord | Simple 2D pixel coordinate | 
| csPixelFormat | Structure describing the pixel format | 
| csPixmap | This class is an simple set of inline routines good as an abstraction for simple 2D sprites | 
| csPixMixerCopy< Tpixel > | PixMixer that ignores alpha | 
| csPixMixerNoop< Tpixel > | PixMixer that doesn't do anything | 
| csPixMixerRGBA< Tpixel > | PixMixer that mixes the pixel into the background with alpha | 
| csPlane2 | A plane in 2D space | 
| csPlane3 | A plane in 3D space | 
| csPlatformMemoryMappingDummy | Memory mapping for platforms without memory mapping support - it does nothing, so the software emulation kicks in when csMemoryMappedIO is used | 
| csPlatformMemoryMappingDummy::PlatformMemoryMapping | |
| csPlatformMemoryMappingPosix | Memory mapping for platforms with POSIX mmap() support | 
| csPlatformMemoryMappingPosix::PlatformMemoryMapping | |
| csPlatformMemoryMappingWin32 | Memory mapping for Win32 | 
| csPlatformMemoryMappingWin32::PlatformMemoryMapping | |
| csPluginList | |
| csPluginLoader | This utility class helps to load plugins based on request, config file, and commandline | 
| csPluginLoadRec | |
| csPluginManager | This is the standard implementation of the plugin manager | 
| csPluginRequest | This class represents a single plugin request for csInitializer::RequestPlugins() | 
| csPointLightProc< AttenuationProc > | Preform pointlight lighting calculation without shadowing | 
| csPointLightProc< AttenuationProc >::PerVertex | |
| csPoly2D | The following class represents a general 2D polygon | 
| csPoly2DFactory | This factory is responsible for creating csPoly2D objects or subclasses of csPoly2D | 
| csPoly2DPool | This is an object pool which holds objects of type csPoly2D | 
| csPoly3D | The following class represents a general 3D polygon | 
| csPolygonClipper | Can be used for clipping any polygon against any other convex polygon | 
| csPolygonMesh | A convenience polygon mesh implementation that you can feed with vertices and polygons from another source | 
| csPolygonMeshBox | A convenience polygon mesh implementation that represents a cube | 
| csPolygonMeshEdge | A definition of one edge | 
| csPolygonMeshTools | A set of tools to work with iPolygonMesh instances | 
| csPolygonRange | A range structure for specifing polygon ranges | 
| csPolyIndexed | The following class represents a general polygon | 
| csPoolEvent | This class is a system event designed for the pool system | 
| csPrefixConfig | This is an implementation of iConfigFile that stores an ID string at construction, which it then prepends to all config keys on read/write operations | 
| csPrimitives | A primitive mesh generator | 
| csPrintfFormatter< Twriter, Treader > | Templated class for printf()-style string formatting | 
| csProcAnimated | Procedural texture for animated images | 
| csProcessorCapability | This class is used to identify capabilities in the processor such as support for MMX and SSE | 
| csProcTexture | Generic superclass for procedural textures | 
| csProgressPulse | Simple twirling textual cursor built out of the characters '-', '\', '|', and '/' | 
| csPtr< T > | A normal pointer | 
| csPtrKey< T > | A helper template to use pointers as keys for hashes | 
| csPtrWrap< T > | Simple pointer wrapper class | 
| csQuaternion | Class for a quaternion | 
| csRadixSorter | A radix-sorter for signed and unsigned integers as well as floats | 
| csRandomFloatGen | Fast simple random number generator for floating point values | 
| csRandomGen | Portable random number generator class | 
| csRandomVectorGen | Random number generator that generates random vector with spherical distribution | 
| csRealisticAttenuation | Inverse quadratic attenuation | 
| csRect | Rectangle class: simple class for manipulating 2D rectangles | 
| csRectRegion | A rect region is a class that implements splittable 2d rectangles | 
| csRedBlackTree< K > | A red-black-tree | 
| csRedBlackTree< K >::Node | A node in the tree | 
| csRedBlackTreeMap< K, T > | Key-value-map, backed by csRedBlackTree | 
| csRedBlackTreePayload< K, T > | Helper template to allow storage of a payload together with a key in a csRedBlackTree | 
| csRef< T > | A smart pointer | 
| csRefArray< T, Allocator > | An array of smart pointers | 
| csRefArrayElementHandler< T > | |
| csRefArrayObject< T > | This class implements a typed array that correctly keeps track of reference count and also is able to find by name | 
| csRefCount | This is a class which provides basic reference-counting semantics | 
| csRefTrackerAccess | Helper to facilitate access to the global reference tracker | 
| csRegExpMatch | Information about (sub)expression matches | 
| csRegExpMatcher | Matcher for regular expressions | 
| csRenderBuffer | Render buffer - basic container for mesh geometry data | 
| csRenderBuffer::Props | To scrape off a few bytes use bitfields; assumes values are in sane limits | 
| csRenderBufferHolder | Holder of standard renderbuffers | 
| csRenderBufferLock< T, TbufferKeeper > | Helper class for convenient locking/unlocking of an iRenderBuffer | 
| csRenderContext | This structure keeps track of the current render context | 
| csRenderMesh | Mesh data as returned by mesh plugins | 
| csRenderMeshHolder | Helper class to retrieve an unused csRenderMesh | 
| csRenderMeshList | This class is used when we need to store, sort and then render a list of rendermeshes | 
| csRenderMeshModes | Mesh render mode information | 
| csRenderStepParser | Parser for render steps and render step lists | 
| csReporterHelper | Helper class for csReport() | 
| csReversibleTransform | A class which defines a reversible transformation from one coordinate system to another by maintaining an inverse transformation matrix | 
| csRGBcolor | An RGB color | 
| csRGBpixel | An RGB pixel | 
| csRunnable | Abstract 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 | 
| csSaverFile | An object containing information about where to save a file | 
| csScfStringSet | The string set is a collection of unique strings | 
| csSchedule | Easy way to get timers in applications | 
| csScopedLock< T > | |
| csScopedMutexLock | This is a utility class for locking a Mutex | 
| csScreenBoxResult | Return structure for iMeshWrapper->GetScreenBoundingBox() | 
| csScreenShot | Simple iImage implementation for canvas screenshots | 
| csScreenTargetResult | This structure is returned by csEngineTools::FindScreenTarget() | 
| csSectorHitBeamResult | Return structure for the iSector->HitBeam() routines | 
| csSegment2 | A 2D line segment | 
| csSegment3 | A 3D line segment | 
| csSemaphore | A semaphore object | 
| csSequenceOp | |
| csSet< T, Allocator > | This class implements a basic set for objects | 
| csSet< T, Allocator >::GlobalIterator | An iterator class for the set | 
| csSetToAddress | Sized data type access helpers | 
| csShaderExpression | An evaluable expression attached to a shader variable | 
| csShaderExpression::oper | |
| csShaderExpression::oper_arg | |
| csShaderExpressionAccessor | Shader variable accessor that evaluates a shader expression when the SV value is queried | 
| csShaderMetadata | Shader metadata | 
| csShaderProgram | Base class for iShaderProgram plugins | 
| csShaderProgram::ProgramParam | Program parameter, either a SV reference or a const value | 
| csShaderProgram::VariableMapEntry | Holder of variable mapping | 
| csShaderVarBlockAlloc< ObjectDispose > | A block allocator for shader variables | 
| csShaderVariable | Storage class for "shader vars", inheritable variables in the shader system | 
| csShaderVariableContext | Complete SCF class implementing iShaderVariableContext | 
| csShaderVariableFrameHolder | Helper class to obtain a shader variable that was guaranteedly not used in a frame yet | 
| csShaderVarMapping | Mapping of a shader variable to some shader-specific destination | 
| csShortestDistanceResult | Result structure for csEngineTools::FindShortestDistance() | 
| csSimplePixmap | This is the simple implementation of csPixmap that uses a single texture | 
| csSimpleRenderMesh | A simple render mesh | 
| csSndSysSoundFormat | The sound format | 
| csSoftFontCache | Font cache base class for software canvases | 
| csSoftFontCache::SoftGlyphCacheData | |
| csSoftFontCacheImpl< Tpixel, Tpixmixer > | An actual implementation of a font cache for software canvases | 
| csSolidSpace | This structure keeps track of solid space | 
| csSparse3D | General 3D sparse matrix class | 
| csSphere | This class represents a sphere | 
| csSpline | A spline superclass | 
| csSpotLightProc< AttenuationProc > | Perform spotlight lighting calculation without shadowing | 
| csSpotLightProc< AttenuationProc >::PerVertex | |
| csSprite2DVertex | A single 2D Sprite vertex | 
| csSpriteCal3DActiveAnim | |
| csSquaredDist | Some functions to perform squared distance calculations | 
| csString | Thin wrapper around csStringFast<> with its default buffer size | 
| csStringArray | An array of strings | 
| csStringArrayElementHandler | |
| csStringBase | This is a string class with a range of useful operators and type-safe overloads | 
| csStringFast< LEN > | Subclass of csStringBase that contains an internal buffer which is faster than the always dynamically allocated buffer of csStringBase | 
| csStringFast< 0 > | |
| csStringHash | A string-to-ID hash table | 
| csStringReader | This is a convenience class that reads an input buffer line by line | 
| csStringSet | The string set is a collection of unique strings | 
| csStrKey | This is a simple helper class to make a copy of a const char* | 
| csSubRectangles | A class managing allocations of sub-rectangles | 
| csSubRectangles::SubRect | Sub-rectangle | 
| csSubRectangles::SubRect::AllocInfo | |
| csSwapBytes | Methods to unconditionally swap the byte order of specifically sized types | 
| csTestRectData | A structure used by TestRectangle() and initialized by PrepareTestRectangle() | 
| csTextProgressMeter | Displays a simple percentage-style textual progress meter | 
| csTextureHandle | This class is the top-level representation of a texture | 
| csTextureManager | General version of the texture manager | 
| csTextureTrans | This is a static class which encapsulates a few functions that can transform texture information into a texture matrix/vector | 
| csThread | Representation of a thread of executation | 
| csThreadJobQueue | IJobQueue implementation that lets the jobs run in a thread | 
| csTiledCoverageBuffer | The tiled coverage Buffer | 
| csTinyDocumentSystem | This is an SCF compatible wrapper for the TinyXml parser in csutil | 
| csTraceBeamResult | Return structure for the csColliderHelper::TraceBeam() method | 
| csTransform | A class which defines a transformation from one coordinate system to another | 
| csTreeNode | A generic tree class | 
| csTriangle | A triangle | 
| csTriangleLODAlgo | Algorithm class that calculates the cost of a vertex | 
| csTriangleLODAlgoEdge | This subclass of csTriangleLODAlgo uses a very simple cost metric to calculate the vertex cost | 
| csTriangleMesh | A mesh of triangles | 
| csTriangleMeshLOD | A static class which performs the calculation of the best order to do the collapsing of a triangle mesh | 
| csTriangleMinMax | A triangle with minimum/maximum information on x | 
| csTriangleVertex | The representation of a vertex in a triangle mesh | 
| csTriangleVertexCost | The representation of a vertex in a triangle mesh | 
| csTriangleVertices | A class which holds vertices and connectivity information for a triangle mesh | 
| csTriangleVerticesCost | A class which holds vertices and connectivity information for a triangle mesh | 
| csTriangleVerticesSorted | This class works closely with csTriangleVerticesCost and maintains a sorted (on cost) view of the vertices | 
| csTriangulate2 | This triangulates a simple polygon | 
| csTypedObjectIterator< T > | Typed object iterator class | 
| csUnicodeTransform | Contains functions to convert between several UTF encodings | 
| csUserRenderBufferManager | Helper class to manage multiple render buffers, usually provided by the user | 
| csVariant | Variant, means that type of contained data is set at runtime | 
| csVector2 | A 2D vector | 
| csVector3 | A 3D vector | 
| csVector3Array | This is actually the same class as csPoly3D | 
| csVector4 | A 4D vector with "float" components | 
| csVector4T< T > | A 4D vector with variable type components | 
| csVerbosityManager | Default iVerbosityManager implementation | 
| csVerbosityParser | Utility for parsing verbosity flags such as those provided by the --verbose=flagscommand-line option | 
| csVertexCompressor | A vertex compressor | 
| csVertexLightCalculator< LightProc > | IVertexLightCalculator implementation that takes one of csPointLightProc, csDirectionalLightProc or csSpotLightProc for LightProc to compute lighting for a light of the respective type | 
| csVertexListWalker< Tbase, Tcomplex > | Helper class to make it easier to iterate over elements from renderbuffers, with automatic conversion to Tbase | 
| csVertexStatus | The clipper can output additional information about each vertex in output polygon | 
| csVfsCacheManager | This is a general cache that can cache data on VFS | 
| csVfsDirectoryChanger | Helper class to change the current VFS directory and restore the previous directory when an instance goes out of scope | 
| csView | Encapsulates the top-level Crystal Space renderer interface | 
| csVirtualClock | This is an implementation of a virtual clock | 
| csWeakRef< T > | A weak reference | 
| csWeakRefArray< T > | An array of weak references | 
| csWideSparse3D | This implementation of csSparse3D is very suited where the accesses will be very widely spaced (for example: one element at (-1000,0,0) and one at (1000,0,0)) | 
| csWin32CustomCursors | Class to create native Win32 mouse cursors from images | 
| csWin32RegistryConfig | An iConfigFile, storing the settings in the Windows registry | 
| cswinCallStackHelper | Call stack creation helper (Win32-specific) | 
| cswinCtoA | Small helper to convert an UTF-8 to an ANSI string, useful when passing arguments to a function | 
| cswinMinidumpWriter | Helper to write minidumps on Win32 | 
| cswinWtoA | Small helper to convert a wide to an ANSI string, useful when passing arguments to a function | 
| csWtoC | Helper class to convert wchar_t* to char* (UTF-8 encoded) strings for use as function parameters | 
| csXRotMatrix3 | An instance of csMatrix3 that is initialized as a rotation about X | 
| csXScaleMatrix3 | An instance of csMatrix3 that is initialized to scale the X dimension | 
| csYRotMatrix3 | An instance of csMatrix3 that is initialized as a rotation about Y | 
| csYScaleMatrix3 | An instance of csMatrix3 that is initialized to scale the Y dimension | 
| csZRotMatrix3 | An instance of csMatrix3 that is initialized as a rotation about Z | 
| csZScaleMatrix3 | An instance of csMatrix3 that is initialized to scale the Z dimension | 
| DirectDetection | Master class of the device detection of direct3d and directdraw | 
| DirectDetectionDevice | Description of DirectDraw device | 
| dirent | |
| CS::DocumentHelper::Implementation::FilterDocumentNodeIterator< T > | Filtering iDocumentNodeIterator | 
| FrameBegin3DDraw | FrameBegin3DDraw handles every csevFrame event in the 3D phase | 
| FramePrinter | FramePrinter handles every csevFrame event in the FRAME (final) phase | 
| FrameSignpost_2DConsole | |
| FrameSignpost_3D2D | |
| FrameSignpost_ConsoleDebug | |
| FrameSignpost_DebugFrame | |
| FrameSignpost_Logic3D | |
| getopt_option | Describe the long-named options requested by the application | 
| CS::Memory::Heap | A separate heap from which memory can be allocated | 
| CS::Memory::HeapAccessPointer< HeapContainer > | Heap accessor for AllocatorHeapBase | 
| iAddonReference | This interface represents a reference to an addon | 
| iAnimatedImage | If an image file has animation capabilities, this interface is exhibited | 
| iAnimTimeUpdateHandler | By default, csSpriteCal3DMeshObject::Advance() updates the model's via CalModel::update() with the elapsed time since the last advancement | 
| iArrayChangeAll< T > | Array interface template, completely changeable | 
| iArrayChangeElements< T > | Array interface template, elements are changeable | 
| iArrayReadOnly< T > | Array interface template, read-only | 
| iBase | This is the basic interface: all other interfaces should be derived from this one, this will allow us to always use at least some minimal functionality given any interface pointer | 
| iBaseHalo | This is the basic interface for all types of halos | 
| iBezierFactoryState | This is the state interface to access the internals of a bezier mesh factory | 
| iBezierState | This is the state interface to access the internals of a bezier mesh object | 
| iBinaryLoaderPlugin | This is a binary plugin for the loader | 
| iBinarySaverPlugin | This is a binary plugin to save with | 
| iBodyGroup | Body Group is a collection of bodies which don't collide with each other | 
| iBugPlug | Using this interface you can communicate with the BugPlug plugin | 
| iBugPlugRenderObject | An application/module can implement this interface to render something | 
| iCacheManager | A generic cache system | 
| iCamera | Camera class | 
| iCameraPosition | A camera position | 
| iCameraPositionList | A list of camera position objects | 
| iCameraSectorListener | Implement this interface if you are interested in learning when the camera changes sector | 
| iCEGUI | Interface for the CS CEGUI wrapper | 
| iClipper2D | This interfaces represents a 2D clipper for polygons | 
| iCollection | A collection object is for convenience of the script language | 
| iCollectionList | ICollection list | 
| iCollider | A mesh collider | 
| iCollideSystem | This is the Collide plug-in | 
| iColoredVertices | |
| iCommandLineParser | A utility class that makes it easier to parse the command line | 
| iComponent | This interface describes a generic component in Crystal Space | 
| iConfigFile | Configuration file interface | 
| iConfigIterator | Iterator which allows sequential access to configuration information contained in an iConfigFile object | 
| iConfigManager | The configuration manager is used to make a number of iConfigFile object appear like a single object | 
| iConsoleExecCallback | Command execution callback | 
| iConsoleInput | This is a plugin that can handle keyboard input and display it on an associated console | 
| iConsoleOutput | This is the Crystal Space Console interface | 
| iConsoleWatcher | This interface is implemented by objects interested in knowing when the console's visibility status has changed | 
| iCrossHalo | This is a halo which resembles a cross | 
| iCursor | This interface is used to access the custom cursor plugin, which handles processing for displaying pixmaps as cursors | 
| iCurve | This is the interface for a curve | 
| iDataBuffer | The iDataBuffer interface can be used to exchange buffers with abstract data between plugins | 
| iDebugHelper | Some object that wants to implement unit testing, debugging and/or benchmarking can implement this interface | 
| CS::PluginCommon::SoftShader::iDefaultScanlineRenderer | Default software scanline renderer | 
| CS::PluginCommon::SoftShader::iDefaultShader | Software renderer default shader plugin | 
| iDocument | Representation of a document containing a hierarchical structure of nodes | 
| iDocumentAttribute | An attribute for an iDocumentNode | 
| iDocumentAttributeIterator | An iterator over iDocumentNode attributes | 
| iDocumentNode | Representation of a node in a document | 
| iDocumentNodeIterator | An iterator over iDocumentNode | 
| iDocumentSystem | An iDocument factory | 
| iDynamics | This is the interface for the actual plugin | 
| iDynamicsColliderCollisionCallback | This is the interface for attaching a collider callback to the body | 
| iDynamicsCollisionCallback | This is the interface for attaching a collider callback to the body | 
| iDynamicsMoveCallback | This is the interface for a dynamics move callback | 
| iDynamicsSystemCollider | This is the interface for a dynamics system collider | 
| iDynamicSystem | This is the interface for the dynamics core | 
| iEmitBox | Box value emitter - returns points in an (axis aligned) box | 
| iEmitCone | Cone value emitter - returns points in a cone | 
| iEmitCylinder | Cylinder value emitter - returns values in a cylinder | 
| iEmitCylinderTangent | Cylinder tangential value emitter - gives direction tangential to cylinder Uses the given point, gives a tangential direction for that | 
| iEmitFactoryState | This interface describes the API for the emitter mesh factory object | 
| iEmitFixed | Fixed value emitter - returns a particular point value | 
| iEmitGen3D | This interface is for objects that can generate 3d vectors, which are used for emitting | 
| iEmitLine | Line value emitter - returns values on the line between start and end | 
| iEmitMix | Mix value emitter - returns a weighted random mix of other emitters | 
| iEmitSphere | Sphere value emitter - returns points in a sphere | 
| iEmitSphereTangent | Sphere tangential value emitter - gives direction tangential to sphere Uses the given point, gives a tangential direction for that | 
| iEmitState | This interface describes the API for the emitter mesh object | 
| iEngine | This interface is the main interface to the 3D engine | 
| iEngineFrameCallback | A callback that will be fired whenever the engine starts drawing a frame | 
| iEngineSectorCallback | A callback that will be fired whenever a sector is created or removed from the engine | 
| iEngineSequenceManager | Sequence manager specifically designed for working on the engine | 
| iEngineSequenceParameters | An interface for passing on parameters to the engine sequence manager | 
| iEvent | This interface describes any system event | 
| iEventAttributeIterator | Event attribute iterator | 
| iEventCord | The iEventCord is an interface provided by an event queue to any event handlers wanting to receive some subclasses of events ASAP in a specified priority, bypassing the queue itself | 
| iEventHandler | This interface describes an entity that can receive events | 
| iEventHandlerRegistry | This interface represents a general event handler registry/resolver | 
| iEventNameRegistry | This interface represents a general event name resolver | 
| iEventOutlet | The iEventOutlet is the interface to an object that is provided by an event queue to every event plug when it registers itself | 
| iEventPlug | Event plug interface, also referred as "event source" | 
| iEventQueue | This interface represents a general event queue | 
| iEventTimer | A timer | 
| iFactory | IFactory is an interface that is used to create instances of shared classes | 
| iFile | A replacement for FILE type in the virtual file space | 
| iFireTexture | Interface to the 'fire' procedural texture | 
| iFlareHalo | This is a halo which resembles a (solar) flare | 
| iFont | A font object | 
| iFontDeleteNotify | Called before a font is deleted | 
| iFontServer | A font server interface | 
| iFrameEventSignpost | |
| iFrustumView | This structure represents all information needed for the frustum visibility calculator | 
| iFrustumViewUserdata | User data which can be attached to iFrustumView | 
| iGeneralFactoryState | This interface describes the API for the general mesh factory | 
| iGeneralMeshCommonState | The common interface between genmesh meshes and factories | 
| iGeneralMeshState | This interface describes the API for the general mesh object | 
| iGeneralMeshSubMesh | |
| iGenerateImageFunction | This class represents a function for csGenerateImageValueFunc | 
| iGenericRenderStep | A generic render step | 
| iGenMeshAnimationControl | Implementing this class allows the creation of classes that control animation of vertex, texel, normal, and color data right before it is being used | 
| iGenMeshAnimationControlFactory | This class is a factory for creating animation controls | 
| iGenMeshAnimationControlState | This interface describes the API for setting up the animation control as implemented by the 'gmeshanim' plugin | 
| iGenMeshAnimationControlType | This class is the animation control type | 
| iGenMeshSkeletonControlState | This interface describes the API for setting up the skeleton animation control as implemented by the 'gmeshskelanim' plugin | 
| iGradient | A simple color gradient | 
| iGradientShades | An array of gradient shades | 
| iGraphics2D | This is the interface for 2D renderer | 
| iGraphics3D | This is the standard 3D graphics interface | 
| iGraphicsMemory | This is the interface used to access the csGraphicsMemory plugin | 
| iHalo | IHalo: used to render halos (aka "light globes") | 
| iHazeFactoryState | This interface describes the API for the sprite factory mesh object | 
| iHazeHull | A mesh specially meant for use by the haze | 
| iHazeHullBox | A predefined hull | 
| iHazeHullCone | A predefined hull | 
| iHazeHullCreation | This interface is implemented by the haze factory in order to be able to create the predefined haze hulls | 
| iHazeState | This interface describes the API for the sprite factory mesh object | 
| iImage | The iImage interface is used to work with image objects | 
| iImageFileLoader | An image file loader | 
| iImageIO | The iImageIO interface is used to save and load graphic files | 
| iImposter | IImposter defines the interface a mesh (or other) class must implement to be used as imposter mesh by the engine | 
| iInputBinder | SCF interface for csInputBinder, used to bind input events (keypress, button press, mouse move, etc | 
| iInstancingFactoryState | This interface describes the API for the instancing mesh factory | 
| iInstancingMeshCommonState | The common interface between instancing meshes and factories | 
| iInstancingMeshState | This interface describes the API for the instancing mesh object | 
| iJob | A unit of work passed to iJobQueue | 
| iJobQueue | Interface to simple job management | 
| iJoint | This is the interface for a joint | 
| iJoystickDriver | Generic Joystick driver | 
| iKDTreeObjectDescriptor | If you implement this interface then you can give that to the KDtree | 
| iKDTreeUserData | The data type for user data to be attached to the KDTree | 
| iKeyboardDriver | Generic Keyboard Driver | 
| iKeyComposer | Keyboard input handler | 
| iKeyValuePair | A Key Value pair | 
| iKitchenSink | Interface to interact with a kitchen sink | 
| iLibraryReference | This interface represents a reference to a library file | 
| iLight | The iLight interface is the SCF interface for the csLight class | 
| iLightCallback | Set a callback which is called when this light color is changed | 
| iLightingInfo | This interface is implemented by mesh objects that have some kind of lighting system | 
| iLightingManager | |
| iLightingProcessData | The iLightingProcessData interface can be implemented by a mesh object so that it can attach additional information for the lighting process | 
| iLightingProcessInfo | The iLightingProcessInfo interface holds information for the lighting system | 
| iLightIterator | Iterator to iterate over all static lights in the engine | 
| iLightIterRenderStep | |
| iLightList | This structure represents a list of lights | 
| iLightManager | An engine (3D or iso) can implement this interface for the benefit of mesh objects so that they can request lighting information from the engine | 
| iLightningFactoryState | |
| iLightningState | |
| iLightRenderStep | |
| iLightSectorInfluence | A light-sector influence (LSI) | 
| iLightVisibleCallback | A callback that is fired whenever a light is visible | 
| iLoader | This interface represents the map loader | 
| iLoaderContext | This interface gives the context for the loader | 
| iLoaderPlugin | This is a plugin for the loader based on document tree | 
| iLoaderStatus | An object to query about the status of the threaded loader | 
| iLODControl | The iLODControl interface represents an object that has controllable LOD features | 
| CS::ImageAutoConvert | Small wrapper class to automatically convert an image into a different storage format, if needed | 
| IMAGEHLP_LINE64 | |
| IMAGEHLP_LINEW64 | |
| IMAGEHLP_MODULE64 | |
| IMAGEHLP_MODULEW64 | |
| IMAGEHLP_STACK_FRAME | |
| iMapNode | A node | 
| iMaterial | This class represents a material as seen from the engine view | 
| iMaterialEngine | This interface represents the engine part of the material definition | 
| iMaterialList | This class represents a list of materials | 
| iMaterialWrapper | A material wrapper is an engine-level object that wraps around an actual material (iMaterial) | 
| iMemoryTracker | This interface is used with CS_MEMORY_TRACKER | 
| iMeshDrawCallback | Set a callback which is called just before the object is drawn | 
| iMeshFactoryList | A list of mesh factories | 
| iMeshFactoryWrapper | A mesh factory wrapper is an engine-level object that wraps around a mesh object factory (iMeshObjectFactory) | 
| iMeshGenerator | IMeshGenerator defines the interface for a mesh generator | 
| iMeshGeneratorGeometry | This interface defines one piece of geometry for the mesh generator | 
| iMeshList | A list of meshes | 
| iMeshObject | This is a general mesh object that the engine can interact with | 
| iMeshObjectDrawCallback | Set a callback which is called just before the object is drawn | 
| iMeshObjectFactory | This object is a factory which can generate mesh objects of a certain type | 
| iMeshObjectType | This plugin describes a specific type of mesh objects | 
| iMeshWrapper | A mesh wrapper is an engine-level object that wraps around an actual mesh object (iMeshObject) | 
| iMeshWrapperIterator | This is an iterator mesh wrappers | 
| iMissingLoaderData | This callback is called when the loader can't find some material, texture, factory, mesh, light, shader, or sector | 
| iModelLoader | Some loader plugins implement this as an easier way to load a factory from code | 
| iMouseDriver | Generic Mouse Driver | 
| iMovable | This 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 | 
| iMovableListener | Implement this class if you're interested in hearing about movable changes | 
| iMovieRecorder | Using this interface you can communicate with the MovieRecorder plugin | 
| CS::ImportKit | Crystal Space Import Kit | 
| CS::ImportKit::Container | Contains multiple models | 
| CS::ImportKit::Container::Material | A material for a mesh | 
| CS::ImportKit::Container::Model | A model | 
| CS::ImportKit::Container::Model::Mesh | Model mesh, contains actual geometry | 
| iNativeWindow | This interface represents a native window | 
| iNativeWindowManager | This interface represents the native window manager system | 
| iNovaHalo | This is a halo which resembles a nova | 
| CS::PluginCommon::SoftShader::InterpolateEdgePersp | Interpolator for a polygon edge | 
| CS::PluginCommon::SoftShader::InterpolateEdgePersp::PerFloat | A single interpolated buffer value | 
| CS::PluginCommon::SoftShader::InterpolateScanlinePersp< maxFloats > | Interpolator over a scanline | 
| CS::PluginCommon::SoftShader::InterpolateScanlinePersp< 0 > | |
| CS::PluginCommon::SoftShader::InterpolateScanlinePerspCommon | Interpolator over a scanline, common code | 
| iNullFactoryState | This interface describes the API for the null mesh object factory | 
| iNullMeshState | This interface describes the API for the null mesh object | 
| iObject | This interface is an SCF interface for encapsulating csObject | 
| iObjectIterator | This is an iterator for child objects of a csObject | 
| iObjectModel | This interface represents data related to some geometry in object space | 
| iObjectModelListener | Implement this class if you're interested in hearing about when the object model changes | 
| iObjectNameChangeListener | A callback that you can implement to get notified of name changes in an iObject | 
| iObjectRegistry | This interface serves as a registry of other objects | 
| iObjectRegistryIterator | Use an instance of this class to iterate over objects in the object registry | 
| iObjectWatcher | This is a generic object watcher | 
| iObjectWatcherListener | Implement this class if you're interested in hearing about object watcher events | 
| iODEAMotorJoint | ODE AMotor joint | 
| iODEBallJoint | ODE ball and socket joint (contrainted translation and free rotation) | 
| iODEDynamicState | This class exposes parameters specific to odedynam as an implementation of iDynamics | 
| iODEDynamicSystemState | This class exposes parameters specific to odedynam as an implementation of iDynamics | 
| iODEFrameUpdateCallback | This class can be passed in as a callback during the physics update it is only called if FrameRate is enabled | 
| iODEGeneralJointState | General joint state | 
| iODEHinge2Joint | ODE hinge 2 joint | 
| iODEHingeJoint | ODE hinge joint (contrainted translation and 1 free rotation axis) | 
| iODEJointState | General joint state | 
| iODESliderJoint | |
| iODEUniversalJoint | A universal joint is like a ball and socket joint that constrains an extra degree of rotational freedom | 
| iOffscreenCanvasCallback | When 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 | 
| iOpenGLDriverDatabase | Interface to read custom GL driver databases | 
| iOpenGLInterface | A common interface to be implemented by the platform specific opengl canvases | 
| iOSXAssistant | This is an interface for an object which provides assistance to MacOS/X-specific canvases and Objective-C bridging code for application run-loop support | 
| iPagingFormerState | IPagingFormerState exposes implementation specific methods for the PagingTerraformer plugin | 
| iParameterESM | This interface is a parameter resolver | 
| iParticle | A iParticle can be used in particle Systems | 
| iParticleBuiltinEffectorFactory | Factory for builtin effectors | 
| iParticleBuiltinEffectorForce | Simple force/acceleration applied to particles | 
| iParticleBuiltinEffectorLinColor | Simple linear interpolation of particle color based on particle lifetime | 
| iParticleBuiltinEffectorVelocityField | Velocity field effector | 
| iParticleBuiltinEmitterBase | |
| iParticleBuiltinEmitterBox | |
| iParticleBuiltinEmitterCone | |
| iParticleBuiltinEmitterCylinder | |
| iParticleBuiltinEmitterFactory | Factory for builtin emitter-types | 
| iParticleBuiltinEmitterSphere | |
| iParticleEffector | Base interface for particle effector | 
| iParticleEmitter | A particle emitter | 
| iParticleState | This interface describes the API for the particle mesh object | 
| iParticleSystem | Properties for particle system object | 
| iParticleSystemBase | Base properties for particle system | 
| iParticleSystemFactory | Properties for particle system factory | 
| iPath | A path in 3D | 
| iPen | A pen is used to draw vector shapes | 
| iPluginConfig | Interface to a configurator object | 
| iPluginIterator | An iterator to iterate over all plugins in the plugin manager | 
| iPluginManager | This is the plugin manager | 
| iPolygonHandle | This is an interface that can be used to represent a polygon in situations where a SCF object is required | 
| iPolygonMesh | This interface reprents a mesh of polygons | 
| iPortal | This is the interface to the Portal objects | 
| iPortalCallback | When a sector is missing this callback will be called | 
| iPortalContainer | A container for portals | 
| iProcTexCallback | A callback for when a iTextureWrapper is used | 
| iProcTexture | Interface to a texture factory | 
| iProgressMeter | This is a general interface for a progress meter | 
| iProtoFactoryState | The proto mesh is a demonstration or tutorial mesh | 
| iProtoMeshState | This interface describes the API for the proto mesh object | 
| iRefTracker | The reference tracker interface | 
| iRegion | A region | 
| iRegionList | A list of region objects | 
| iRenderBuffer | This is a general buffer | 
| iRenderBufferAccessor | Interface for renderbuffer accessor | 
| iRendererLightmap | A lightmap registered with a renderer | 
| iRenderLoop | Render loop | 
| iRenderLoopManager | Render loop manager | 
| iRenderStep | |
| iRenderStepContainer | Container for render steps | 
| iRenderStepFactory | Interface to a render step factory | 
| iRenderStepType | Render step type | 
| iRenderView | This interface represents all information needed to render some object in a current draw context | 
| iReporter | This is the interface for the error/message reporter plugin | 
| iReporterIterator | An iterator to iterate over all messages in the reporter | 
| iReporterListener | Implement this interface if you're interested in hearing about new messages on the reporter | 
| iRigidBody | This is the interface for a rigid body | 
| iSaver | This interface is used to serialize the engine contents | 
| iSaverFile | This interface represents a CS file to save to | 
| iSaverPlugin | This is a plugin to save with | 
| CS::PluginCommon::SoftShader::iScanlineRenderer | Software renderer scanline renderer | 
| CS::PluginCommon::SoftShader::iScanlineRenderer::RenderInfoMesh | Information for setting up rendering a mesh, filled by the scanline renderer | 
| CS::PluginCommon::SoftShader::iScanlineRenderer::RenderInfoTriangle | Information for setting up rendering a triangle, filled by the scanline renderer | 
| iSceneNode | This interface represents a node in the scene graph | 
| iSceneNodeArray | An array of scene node interfaces | 
| iSCF | ISCF is the interface that allows using SCF functions from shared classes | 
| iScript | This provides the interface to a scripting language interpreter | 
| iScriptObject | This provides the interface to an object in an object-oriented scripting language | 
| iSector | The iSector interface is used to work with "sectors" | 
| iSectorCallback | Set a callback which is called when this sector is traversed | 
| iSectorIterator | An iterator to iterate over sectors | 
| iSectorList | A list of sectors | 
| iSectorMeshCallback | Set a callback which is called when a mesh is added or removed from this sector | 
| iSelfDestruct | An object implementing this interface can remove itself from its 'natural parent' | 
| iSequence | A sequence of operations tagged with relative time information | 
| iSequenceCondition | A sequence condition | 
| iSequenceManager | The sequence manager | 
| iSequenceOperation | A sequence operation | 
| iSequenceTimedOperation | A timed operation for the engine sequence manager | 
| iSequenceTrigger | A sequence trigger | 
| iSequenceWrapper | A sequence wrapper | 
| iShader | Specific shader | 
| iShaderCompiler | Compiler of shaders | 
| iShaderDestinationResolver | Interface to allow resolution of friendly destination names | 
| iShaderManager | A manager for all shaders | 
| iShaderPriorityList | A list of priorities as returned by iShaderCompiler->GetPriorities() | 
| iShaderProgram | A helper for shaders that which to use the general plugins | 
| iShaderProgramPlugin | Plugins which provide iShaderProgram should implement this as a factory for iShaderProgram | 
| iShaderVariableAccessor | Interface to an accessorcallback for shadervariables | 
| iShaderVariableContext | This is a baseclass for all interfaces which provides shadervariables both dynamically and static | 
| iShaderVarStack | |
| iShadowBlock | A block of shadows represent the shadows that are casted by one iShadowCaster object | 
| iShadowBlockList | This is a list of shadow blocks | 
| iShadowCaster | An object that can cast shadows | 
| iShadowIterator | A shadow iterator allows someone to iterate over all shadows in a iShadowBlock or iShadowBlockList | 
| iShadowReceiver | An object that is interested in getting shadow information | 
| iSharedVariable | ISharedVariable implements a refcounted value which can be shared across many objects and updated efficiently | 
| iSharedVariableList | A list of shared variables | 
| iSharedVariableListener | A listener so that you can get notified when a variable is changed | 
| iSimpleFormerState | ISimpleFormerState exposes implementation specific methods for the SimpleTerraformer plugin | 
| iSkeleton | The skeleton interface provides needed functionality of a skeleton animation | 
| iSkeletonBone | The skeleton bone class | 
| iSkeletonBoneFactory | The skeleton bone factory is class that is used to create skeleton bones of a iSkeleton object | 
| iSkeletonBoneRagdollInfo | |
| iSkeletonBoneUpdateCallback | This callback fires every time when bone changes it's transform | 
| iSkeletonFactory | The skeleton factory is class that is used to create skeleton objects in the scene | 
| iSkeletonGraveyard | ISkeletonGraveyard is the interface that cares for all skeleton factories | 
| iSkeletonScript | Skeleton script is the interface that provides animation of a skeleton | 
| iSkeletonScriptCallback | This is a callback function of an animation script | 
| iSkeletonScriptKeyFrame | The script key frame contains all bones that will be transformed in a specific time of a skeleton script | 
| iSkeletonSocket | The skeleton socket object wraps a relative transform of a bone | 
| iSkeletonSocketFactory | The skeleton socket factory is class that is used to create skeleton sockets of a iSkeleton object | 
| iSkeletonUpdateCallback | This is a callback function of a skeleton | 
| iSndSysData | The sound data is an interface to the container object controlling raw sound data | 
| iSndSysEventRecorder | An interface designed for the debugging needs of the sound system | 
| iSndSysListener | The sound listener is a unique object created by the sound renderer | 
| iSndSysLoader | The sound loader is used to load sound files given a raw input data stream | 
| iSndSysManager | This is the sound manager for Crystal Space | 
| iSndSysRenderer | |
| iSndSysRendererCallback | Sound System renderer interface for callback notification | 
| iSndSysRendererSoftware | Software renderer specific interface extensions | 
| iSndSysSoftwareDriver | This is the interface for the low-level, system-dependent sound driver that is used by the software sound renderer | 
| iSndSysSoftwareFilter3D | A sound filter is an interface to an object that modifies sequences of sound samples | 
| iSndSysSoftwareFilter3DProperties | |
| iSndSysSoftwareOutputFilter | Temporary filter interface definition | 
| iSndSysSource | |
| iSndSysSourceSoftware | |
| iSndSysSourceSoftware3D | |
| iSndSysStream | The primary interface for a sound stream used by the audio system | 
| iSndSysStreamCallback | Sound System stream interface for callback notification | 
| iSndSysWrapper | A wrapper/holder for a loaded sound | 
| CS::PluginCommon::SoftShader::iSoftShaderRenderInterface | Interface specific to the software renderer to allow shaders to communicate with it | 
| iSprite2DFactoryState | This interface describes the API for the sprite factory mesh object | 
| iSprite2DState | This interface describes the API for the sprite factory mesh object | 
| iSprite2DUVAnimation | The animation works by having all frames of an animation sequence in a texture at different (u,v) locations, hence the name | 
| iSprite2DUVAnimationFrame | This is a single frame in a UV animation | 
| iSprite3DFactoryState | This interface describes the API for the 3D sprite factory mesh object | 
| iSprite3DState | This interface describes the API for the 3D sprite mesh object | 
| iSpriteAction | An action frameset for 3D sprite animation | 
| iSpriteCal3DFactoryState | This interface describes the API for the 3D sprite factory mesh object | 
| iSpriteCal3DSocket | A socket for specifying where sprites can plug into other sprites | 
| iSpriteCal3DState | This interface describes the API for changing the Cal3D sprite mesh object's animations playing and other current traits | 
| iSpriteFrame | A frame for 3D sprite animation | 
| iSpriteSocket | A socket for specifying where sprites can plug into other sprites | 
| CS::TypeTraits::IsReference< Type > | Check if Type is a reference or simple type | 
| CS::TypeTraits::Implementation::IsReferenceImpl< T > | |
| CS::TypeTraits::IsSame< Type1, Type2 > | Check if two types are the same | 
| CS::TypeTraits::Implementation::IsSameImpl< T, U > | |
| iStandardReporterListener | Interface to control the settings of the reporter listener plugin | 
| iStreamDataCallback | This callback will be fired when the data is ready | 
| iStreamSource | This interface represents a stream source | 
| iString | This is a SCF-compatible interface for csString | 
| iStringArray | This is an SCF-compatible interface for csStringArray | 
| iStringSet | The string set is a collection of unique strings | 
| iSuperLightmap | A super light map | 
| iSyntaxService | This component provides services for other loaders to easily parse properties of standard CS world syntax | 
| iTerraFormer | TerraFormer objects are used to retrieve terrain data | 
| iTerrainFactoryState | Allows the setting of a set of generic terrain parameters outside any specific algorithm | 
| iTerrainObjectState | This will override the settings for material in the parent | 
| iTerraSampler | TerraSampler 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 | 
| iTextureCallback | A callback for when a iTextureWrapper is used | 
| iTextureFactory | Interface to a texture factory | 
| iTextureHandle | A texture handle as returned by iTextureManager | 
| iTextureList | This class represents a list of texture wrappers | 
| iTextureLoaderContext | Interface passed to a texture loader, holding some common texture properties | 
| iTextureManager | This is the standard texture manager interface | 
| iTextureType | Texture type | 
| iTextureWrapper | A texture wrapper is an engine-level object that wraps around an actual texture (iTextureHandle) | 
| iThingEnvironment | This interface is implemented by the iObjectType for things | 
| iThingFactoryState | This is the state interface to access the internals of a thing mesh factory | 
| iThingState | This is the state interface to access the internals of a thing mesh object | 
| iTimerEvent | A timer event | 
| iUserRenderBufferIterator | Interface to iterate over all buffers stored in a csUserRenderBufferManager | 
| iVerbosityManager | Helper interface which applications and plugins can use to determine whether they should be verbose | 
| iVertexLightCalculator | Interface to calculate lighting for a number of vertices | 
| iVFS | The Virtual Filesystem Class is intended to be the only way for Crystal Space engine to access the files | 
| iView | Encapsulates the top-level Crystal Space renderer interface | 
| iVirtualClock | A virtual game clock | 
| iVisibilityCuller | This interface represents a visibility culling system | 
| iVisibilityCullerListener | Implement this interface when you want to get notified about visible objects detected by the visibility cullers | 
| iVisibilityObject | An object that wants to know if it is visible or not for some visibility culler needs to implement this interface | 
| iVisibilityObjectIterator | Iterator to iterate over some visibility objects | 
| iWin32Assistant | This interface describes actions specific to the Windows platform | 
| iWin32Canvas | This interface provides some extra functionality for Win32 canvases | 
| iWxWindow | Interface to communicate with with a wxWidgets-based canvas | 
| KDHELP64 | |
| CS::Memory::LocalBufferAllocator< T, N, ExcessAllocator > | An allocator with a small local buffer | 
| CS::MeasureTime | Simple helper class to measure execution time of a block | 
| MINIDUMP_CALLBACK_INFORMATION | |
| MINIDUMP_CALLBACK_INPUT | |
| MINIDUMP_CALLBACK_OUTPUT | |
| MINIDUMP_DIRECTORY | |
| MINIDUMP_EXCEPTION_INFORMATION | |
| MINIDUMP_HEADER | |
| MINIDUMP_INCLUDE_MODULE_CALLBACK | |
| MINIDUMP_INCLUDE_THREAD_CALLBACK | |
| MINIDUMP_LOCATION_DESCRIPTOR | |
| MINIDUMP_MEMORY_DESCRIPTOR | |
| MINIDUMP_MEMORY_LIST | |
| MINIDUMP_MODULE_CALLBACK | |
| MINIDUMP_THREAD_CALLBACK | |
| MINIDUMP_THREAD_EX_CALLBACK | |
| MINIDUMP_USER_STREAM | |
| MINIDUMP_USER_STREAM_INFORMATION | |
| CS::DocumentHelper::NodeAttributeCompare | Node comparator | 
| CS::DocumentHelper::NodeAttributeRegexpTest | Check if a regular expression matches(case-insensitive) with the value of the given attribute | 
| CS::DocumentHelper::NodeAttributeValueTest | Compare (case-sensitive) node attribute to given | 
| CS::DocumentHelper::NodeNameCompare | Node comparator | 
| CS::DocumentHelper::NodeValueTest | Compare (case-sensitive) node value to given | 
| CS::TypeTraits::Implementation::NoType | Boolean false type | 
| CS::NumberedFilenameHelper | Helper to deal with numbered filename | 
| CS::Math::Ode45 | Embedded Runge-Kutta 4/5th order ODE solver for non-stiff ODEs | 
| OSXDelegate2D | |
| OSXView | |
| OSXWindow | |
| CS::SndSys::PCMSampleConverter | A PCMSampleConverter object converts PCM data from one format to another | 
| CS::PluginCommon::SoftShader::Pixel | |
| CS::PluginCommon::SoftShader::Pixel::tag_c | |
| CS::SndSys::QEntry< T > | |
| CS::SndSys::Queue< T > | A threadsafe, pointer-passing queue (First-In First-Out) implementation for the sound system | 
| CS::SndSys::QueueIterator< T > | A simple iterator over the elements of a queue | 
| CS::PluginCommon::SoftShader::ScanlineComp | Undivided buffer values | 
| CS::PluginCommon::SoftShader::ScanlineCompDivZ | Buffer values div Z | 
| scfArray< IF, Backend > | Implementation for iArrayReadOnly<>-, iArrayChangeElements<>- and iArrayChangeAll<>-derived interfaces, backed by a per-instance array | 
| scfArrayWrap< IF, Backend > | Implementation for iArrayReadOnly<>-, iArrayChangeElements<>- and iArrayChangeAll<>-derived interfaces, backed by a reference to another array | 
| scfArrayWrapConst< IF, Backend > | Implementation for iArrayReadOnly<>-derived interfaces, backed by a reference to another array | 
| scfFakeInterface< If > | Fugly helper to resolve some bad situations | 
| scfFakeInterface< If >::InterfaceTraits | |
| scfImplementation< Class > | Baseclass for the SCF implementation templates | 
| scfImplementation0< Class > | |
| scfImplementation1< Class, I1 > | |
| scfImplementation2< Class, I1, I2 > | |
| scfImplementation3< Class, I1, I2, I3 > | |
| scfImplementation4< Class, I1, I2, I3, I4 > | |
| scfImplementation5< Class, I1, I2, I3, I4, I5 > | |
| scfImplementation6< Class, I1, I2, I3, I4, I5, I6 > | |
| scfImplementation7< Class, I1, I2, I3, I4, I5, I6, I7 > | |
| scfImplementationExt0< Class, Super > | |
| scfImplementationExt1< Class, Super, I1 > | |
| scfImplementationExt2< Class, Super, I1, I2 > | |
| scfImplementationExt3< Class, Super, I1, I2, I3 > | |
| scfImplementationExt4< Class, Super, I1, I2, I3, I4 > | |
| scfImplementationExt5< Class, Super, I1, I2, I3, I4, I5 > | |
| scfImplementationExt6< Class, Super, I1, I2, I3, I4, I5, I6 > | |
| scfImplementationExt7< Class, Super, I1, I2, I3, I4, I5, I6, I7 > | |
| scfImplementationPooled< Super > | Derive an SCF implementation from this class to have it pooled | 
| scfImplementationPooled< Super >::Pool | |
| scfInterfaceTraits< Interface > | Interface information query class | 
| scfString | This is a thin SCF wrapper around csString | 
| scfStringArray | This class is a thin wrapper around csStringArray with SCF capability | 
| CS::ShaderVariableContextImpl | Simple implementation for iShaderVariableContext | 
| CS::ShaderVarName | Helper class to obtain an ID for a shader variable | 
| CS::SndSys::SndSysBasicData | |
| CS::SndSys::SndSysBasicStream | |
| CS::SndSys::SndSysBasicStream::StreamNotificationEvent | Structure containing the data for each notification event | 
| CS::PluginCommon::SoftShader::SoftwareTexture | |
| CS::SndSys::SoundCyclicBuffer | An implementation of a cyclic buffer oriented for sound functionality | 
| CS::SpinLock | |
| STACKFRAME64 | |
| SYMBOL_INFO | |
| SYMBOL_INFOW | |
| CS::TypeTraits::Implementation::TraitAnd< b1, b2, b3, b4, b5, b6, b7 > | |
| CS::TypeTraits::Implementation::TraitAnd< true, true, true, true, true, true, true > | |
| CS::TriangleIndicesStream< T > | Helper class to extract triangles from an index buffer | 
| CS::UberScreenshotMaker | Helper to create "überscreenshots", screenshots with a resolution larger than the current framebuffer resolution | 
| CS::TypeTraits::Implementation::Wrap< T > | Simple dummy-wrapper | 
| ZIP_central_directory_file_header | |
| ZIP_end_central_dir_record | |
| ZIP_local_file_header | 
Generated for Crystal Space by doxygen 1.4.7

