| _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 pointer encapsulator |
| 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=flags command-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 |
|
