Class List
Here are the classes, structs, unions and interfaces with brief descriptions:
_csKeyModifiers | Flags for all currently pressed modifiers |
CS::Meta::Implementation::AlignmentLogic< A, S > | Select smaller of two alignment values |
CS::Meta::AlignmentOf< T > | Return alignment of type T |
CS::Meta::Implementation::AlignmentOfHack< T > | Helper to handle alignment of small types |
CS::Meta::Implementation::AlignmentOfImpl< T > | Compute alignment for type T |
CS::Meta::AlignSize< T, Alignment > | Return the smallest size bigger than size of T aligned to given alignment |
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::AllocatorMallocPlatform | Memory allocator using the platform's default allocation functions (malloc, free etc |
CS::Memory::AllocatorNew< T > | A default memory allocator that allocates using new T[] |
CS::Memory::AllocatorNewChar< Reallocatable > | A default memory allocator that allocates using new char[] |
CS::Memory::AllocatorPointerWrapper< T, Allocator > | Class to store a pointer that is allocated from Allocator, to eliminate overhead from a possibly empty Allocator |
CS::Threading::AtomicOperationsBase< Impl > | Define low-level atomic operations |
CS::Threading::Barrier | Barrier synchronization class |
CS::Geometry::Box | A box |
CS::Geometry::Capsule | A capsule |
csAnsiParser::CommandParams | Parameters to ANSI command |
CS::Threading::Condition | Condition variable |
csHash< T, K, ArrayMemoryAlloc, ArrayElementHandler >::ConstGlobalIterator | An const iterator class for the hash |
csHash< T, K, ArrayMemoryAlloc, ArrayElementHandler >::ConstIterator | An const iterator class for the hash |
csRedBlackTree< K >::ConstIterator | Const iterator for tree |
csRedBlackTreeMap< K, T >::ConstIterator | Const iterator for map |
csArray< T, ElementHandler, MemoryAllocator, CapacityHandler >::ConstIterator | Iterator for the Array<> class |
csRedBlackTree< K >::ConstReverseIterator | Const reverse iterator for tree |
csRedBlackTreeMap< K, T >::ConstReverseIterator | Const reverse iterator for map |
CS::Utility::ImportKit::Container | Contains multiple models |
CS::Graphics::CoreRenderMesh | Data required by the renderer to draw a mesh |
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 |
csAnimatedMeshBoneInfluence | Represent a single influence of a bone on a single vertex |
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 |
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 |
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 |
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 |
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 |
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 |
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 |
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() |
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() |
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 |
csConstPtrKey< T > | A helper template to use const pointers as keys for hashes |
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 |
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 |
csDirectXError | Obtain symbols and descriptions for DirectX error codes |
csDirtyAccessArray< T, ElementHandler, MemoryAllocator, CapacityHandler > | 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 |
csDualQuaternion | Dual quaternion is a combination q = q0 + e*qe where e is the dual identity element (e^2 = 0) For the background, read "Preliminary Sketch of Biquaternions" [W Clifford, 1873] |
csDVector3 | A 3D vector |
CS::Geometry::csEarClipper | Structure for clipping polygon ears |
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 |
csEventCord | Event cord |
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 |
csEventTimer | This class implements a timer |
csEventTree | This class is used to represent the event namespace (tree) |
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 |
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 |
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 |
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 |
csGlyphMetrics | Metrics for a glyph that are independent from whether a simple or antialiased image is used |
csGradient | A simple color gradient |
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 |
csGraphics3DCaps | Information about 3d renderer capabilities |
csHash< T, K, ArrayMemoryAlloc, ArrayElementHandler > | A generic hash table class, which grows dynamically and whose buckets are unsorted arrays |
csHashComputer< T > | Template for hash value computing |
csHashComputer< const char * > | CsHashComputer<> specialization for strings that uses csHashCompute() |
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< 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 |
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 |
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 |
csList< T, MemoryAllocator > | A lightweight double-linked list template |
csLittleEndian | Little endian to native conversion routines |
csLoadResult | Return structure for the iLoader->Load() routines |
csLockedHeightData | Locked height data |
csLockedMaterialMap | Locked height data |
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> |
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 |
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 |
csNewtonianParticleSystem | This class has a set of particles that behave with physics |
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 |
csParticle | Data representation of a single particle |
csParticleAux | Auxiliary data per particle, not used as often |
csParticleBuffer | Buffer holder for particle buffers |
csParticleParameterSet | Parameters that can be modified based on age for the linear effector (iParticleBuiltinEffectorLinear) |
csParticleSystem | This class represents a particle system |
csPath | A path in 3D |
csPathsList | Class to manage a list of paths |
csPathsUtilities | A helper class with path-related utilities |
csPDelArray< T > | An array of pointers |
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 |
csPlatformMemoryMappingPosix | Memory mapping for platforms with POSIX mmap() support |
csPlatformMemoryMappingWin32 | Memory mapping for Win32 |
csPluginLoader | This utility class helps to load plugins based on request, config file, and commandline |
csPluginManager | This is the standard implementation of the plugin manager |
csPluginReference | An object representing a reference to a library |
csPluginRequest | This class represents a single plugin request for csInitializer::RequestPlugins() |
csPointLightProc< AttenuationProc > | Preform pointlight lighting calculation without shadowing |
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 |
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 |
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 |
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 |
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 |
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 |
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 |
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 |
csScreenBoxResult | Return structure for iMeshWrapper->GetScreenBoundingBox() |
csScreenShot | Simple iImage implementation for canvas screenshots |
csScreenTargetResult | This structure is returned by csEngineTools::FindScreenTarget() |
csScriptCommon | This intermediate class can be subclassed by implementors of iScript |
csScriptObjectCommon | This intermediate class can be subclassed by implementors of iScriptObject |
csSectorHitBeamResult | Return structure for the iSector->HitBeam() routines |
csSegment2 | A 2D line segment |
csSegment3 | A 3D line segment |
csSet< T, Allocator > | This class implements a basic set for objects |
csSetToAddress | Sized data type access helpers |
csShaderExpression | An evaluable expression attached to a shader variable |
csShaderExpressionAccessor | Shader variable accessor that evaluates a shader expression when the SV value is queried |
csShaderMetadata | Shader metadata |
csShaderProgram | Base class for iShaderProgram plugins |
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 |
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 |
csSprite2DVertex | A single 2D Sprite vertex |
csSquaredDist | Some functions to perform squared distance calculations |
csString | Thin wrapper around csStringFast<> with its default buffer size |
csStringArray | An array of strings |
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 |
csStringHash | A string-to-ID hash table |
csStringHashReversible | A csStringHash providing a reverse hash for fast string lookups when given an ID |
csStringReader | This is a convenience class that reads an input buffer line by line |
csStringSet | The string set is a collection of unique strings |
csSwapBytes | Methods to unconditionally swap the byte order of specifically sized types |
csTerrainColliderCollideSegmentResult | Return structure for the iTerrainCollider->CollideSegment() routines |
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 |
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 |
csTriangleMeshBox | A convenience triangle mesh implementation that represents a cube |
csTriangleMeshEdge | A definition of one edge |
csTriangleMeshLOD | A static class which performs the calculation of the best order to do the collapsing of a triangle mesh |
csTriangleMeshPointer | A convenience triangle mesh which takes vertex and triangle pointers from another source |
csTriangleMeshTools | A set of tools to work with iTriangleMesh instances |
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 |
csTuple2< First, Second > | A two length tuple (fixed size collection of elements) Tuples are typically used for quickly bounding grouped values around with a low overhead |
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 |
csWeakRefArrayObject< T > | This class implements a typed array that does not keep track of reference count and is able to find by name |
csWeakRefHash< T, K, ArrayMemoryAlloc > | A hash table class, to be used with csWeakRef<> as the value type |
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 |
CS::Memory::CustomAllocated | Class that overrides operator new/operator delete/etc |
CS::Memory::CustomAllocatedDerived< T > | Class that overrides operator new/operator delete/etc |
CS::DataBuffer< Allocator > | This is an implementation of iDataBuffer interface |
csFixedSizeAllocator< Size, Allocator >::DefaultDisposer | Default disposer mixin, just reporting leaks |
CS::Geometry::DensityTextureMapper | Density based texture mapper |
csMD5::Digest | An MD5 digest is 16 unsigned characters (not 0-terminated) |
DirectDetection | Master class of the device detection of direct3d and directdraw |
DirectDetectionDevice | Description of DirectDraw device |
CS::Meta::EBOptHelper< T > | Helper class for inheriting from a type thats potentially void |
csPathsList::Entry | This structure contains information about a plugin path |
csBaseEventHandler::EventHandlerImpl | Actual iEventHandler implementation |
CS::Utility::FastRefCount< ActualClass > | This is a class which provides basic reference-counting semantics |
CS::DocSystem::Implementation::FilterDocumentNodeIterator< T > | Filtering iDocumentNodeIterator |
csFontCache::FontDeleteNotify | Font deletion callback |
FrameBegin3DDraw | FrameBegin3DDraw handles every csevFrame event in the 3D phase |
FramePrinter | FramePrinter handles every csevFrame event in the FRAME (final) phase |
CS::Geometry::GeneralMeshBuilder | Tools related to creating genmesh instances and factories |
CS::Utility::GenericResourceCache< T, _TimeType, _ResourceSorting, _ReuseCondition, _PurgeCondition > | Generic cache for resources |
getopt_option | Describe the long-named options requested by the application |
csHash< T, K, ArrayMemoryAlloc, ArrayElementHandler >::GlobalIterator | An iterator class for the hash |
csSet< T, Allocator >::GlobalIterator | An iterator class for the set |
csFontCache::GlyphCacheData | Some basic data associated with a glyph |
CS::Utility::GraphEdge | Represent an edge in a graph |
CS::Container::HashElement< T, K > | An element of a hash |
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 |
iAnimatedMesh | State and setting for an instance of an animated mesh |
iAnimatedMeshFactory | State of animated mesh object factory |
iAnimatedMeshFactorySubMesh | Sub mesh (part) of an animated mesh factory |
iAnimatedMeshMorphTarget | A morph target |
iAnimatedMeshSocketFactory | Factory for sockets attached to animated meshes |
iAnimatedMeshSubMesh | Sub mesh (part) of an animated mesh |
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 | } |
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 |
iBulletDynamicSystem | The Bullet implementation of iDynamicSystem also implements this interface |
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 |
iColladaConvertor | Representation of a convertor from COLLADA files to Crystal Space files |
iCollection | A collection is used to store related objects in a simple structure to guarentee that they won't be freed by the engine and to help management |
iCollectionArray | Used for a readonly array of csRef<iCollection> |
iCollider | A mesh collider |
iCollideSystem | This is the Collide plug-in |
iCommandLineParser | A utility class that makes it easier to parse the command line |
iComponent | This interface describes a generic component in Crystal Space |
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 |
iDecal | A decal created by the decal manager |
iDecalBuilder | Interface for mesh objects to use to build decals for their mesh object |
iDecalManager | Creates and manages decals |
iDecalTemplate | Interface for a decal template which dictates the appearance of a newly created decal |
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 |
iDynamicsStepCallback | This is the interface for a dynamics step 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 |
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 |
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 |
iGenMeshAnimationControl1_4 | Enhanced Update() for genmesh animation plugins |
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 |
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 | |
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 |
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 |
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::Utility::ImportKit | Crystal Space Import Kit |
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::Utility::InternalRefCount | This class is used to hold a reference count seperate to the normal one |
CS::PluginCommon::SoftShader::InterpolateEdgePersp | Interpolator for a polygon edge |
CS::PluginCommon::SoftShader::InterpolateScanlinePersp< maxFloats > | Interpolator over a scanline |
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 |
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 |
iParticleBuiltinEffectorLinear | Linear interpolation of various parameters based on particle lifetime |
iParticleBuiltinEffectorVelocityField | Velocity field effector |
iParticleBuiltinEmitterFactory | Factory for builtin emitter-types |
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 |
iPluginReference | This interface represents a reference to a plugin |
iPolygonHandle | This is an interface that can be used to represent a polygon in situations where a SCF object is required |
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 |
iProfiler | Interface to profiler |
iProfilerFactory | Interface to profile 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 |
iRenderBufferCallback | Callback function used upon destruction of render buffer |
iRenderBufferPersistence | Render buffer persistence information |
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 |
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 |
iScriptValue | This provides the interface to a value stored in the scripting language's native format, be it a numeric or string value or a reference to an object |
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 |
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 |
iSkeleton2 | A skeleton instance is a specific copy of a skeleton with base pose and topology defined by the factory but current state internally defined |
iSkeletonAnimation | This interface provides animation of a skeleton |
iSkeletonAnimation2 | Factory for skeletal animations |
iSkeletonAnimationCallback | This is a callback function of an animation |
iSkeletonAnimationInstance | This interface provides played animation instance of a skeleton |
iSkeletonAnimationKeyFrame | The script key frame contains all bones that will be transformed in a specific time of a skeleton script |
iSkeletonAnimationNode2 | Animation node |
iSkeletonAnimationNodeFactory2 | Factory for animation node |
iSkeletonAnimCallback2 | A callback that is called when an animation or animation tree have finished playing |
iSkeletonAnimNode2 | Base type for nodes in the hierarchical blending tree for skeletal animation system |
iSkeletonAnimNodeFactory2 | Base type for nodes in the hierarchical blending tree factory |
iSkeletonAnimPacket2 | A animation packet instance |
iSkeletonAnimPacketFactory2 | Defines a factory for a skeletal animation packet |
iSkeletonBlendNode2 | An animation node that blends together the sub-nodes based on their weights |
iSkeletonBlendNodeFactory2 | Factory for blend node |
iSkeletonBone | The skeleton bone class |
iSkeletonBoneFactory | The skeleton bone factory is class that is used to create skeleton bones of a iSkeleton object |
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 |
iSkeletonFactory2 | A skeleton factory is an object defining the base pose and topology from which skeleton instances can be created |
iSkeletonFSMNodeFactory2 | Factory for FSM animation node |
iSkeletonGraveyard | ISkeletonGraveyard is the interface that cares for all skeleton factories |
iSkeletonManager2 | Skeletal system base object, representing the entire skeletal and skeletal animation system |
iSkeletonPriorityNode2 | An animation node that blends together the sub-nodes based on their priority |
iSkeletonPriorityNodeFactory2 | Factory for priority blend node |
iSkeletonRandomNode2 | An animation node that selects random sub-nodes |
iSkeletonRandomNodeFactory2 | Factory for randomized sub-node blending node |
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 |
CS::Meta::IsLog2< R > | Meta-programming IsLog2 function |
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 |
iSndSysListenerDoppler | Extension to the iSndSysListener interface, allowing Doppler shift effects |
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 | The sound renderer is the core interface for the sound system |
iSndSysRendererCallback | Sound System renderer interface for callback notification |
iSndSysRendererOpenAL | OpenAL renderer specific interface extensions |
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 |
iSndSysSoftwareOutputFilter | Temporary filter interface definition |
iSndSysSource | A sound source is the origin of a sound in Crystal Space |
iSndSysSource3D | Extension to the iSndSysSource interface, allowing sources to be positioned in space |
iSndSysSource3DDirectional | Extension to the iSndSysSource3D interface, allowing directional orientation of sound sources |
iSndSysSource3DDirectionalSimple | Extension to the iSndSysSource3D interface, allowing simple directional orientation of sound sources |
iSndSysSource3DDoppler | Extension to the iSndSysSource3D interface, allowing Doppler shift effects |
iSndSysSourceOpenAL | Interface for OpenAL sound sources |
iSndSysSourceSoftware | Sound source extensions for the software renderer |
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::Meta::IsReference< Type > | Check if Type is a reference or simple type |
CS::Meta::IsSame< Type1, Type2 > | Check if two types are the same |
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 |
iSystemOpenManager | Manager for system open events |
csArray< T, ElementHandler, MemoryAllocator, CapacityHandler >::Iterator | Iterator for the Array<> class |
csHash< T, K, ArrayMemoryAlloc, ArrayElementHandler >::Iterator | An iterator class for the hash |
csRedBlackTreeMap< K, T >::Iterator | Iterator for map |
csRedBlackTree< K >::Iterator | Const iterator for tree |
csList< T, MemoryAllocator >::Iterator | Iterator for the list |
iTerraFormer | TerraFormer objects are used to retrieve terrain data |
iTerrainCell | Terrain cell class |
iTerrainCellCollisionProperties | This is a base class for per-cell collider-specific properties |
iTerrainCellFeederProperties | This is a base class for per-cell feeder-specific properties |
iTerrainCellHeightDataCallback | Callbacks for cell height data modifications |
iTerrainCellLoadCallback | Callbacks for cell load/unload events |
iTerrainCellRenderProperties | This is a base class for per-cell renderer-specific properties |
iTerrainCollider | Provides an interface for custom collision |
iTerrainCollisionPairArray | Class for an array of csCollisionPair. Used for communication with plugins |
iTerrainDataFeeder | Provides an interface for reading cell data |
iTerrainFactory | Provides an interface for creating terrain system |
iTerrainFactoryCell | Factory representation of a cell |
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 |
iTerrainRenderer | Provides an interface for custom rendering |
iTerrainSystem | This class represents the terrain object as a set of cells |
iTerrainVector3Array | Class for an array of csVector3. Used for communication with plugins |
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 |
iTranslator | Translator interface |
iTriangleMesh | This interface reprents a mesh of triangles |
iTriangleMeshIterator | Iterator to iterate over all data mesh ID's in an object model |
csEventQueue::iTypedFrameEventDispatcher | As a transitional measure, the csevPreProcess, csevProcess, csevPostProcess and csevFinalProcess events are actually sub-events dispatched by a csevFrame handler |
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 |
iXWindow | Document me! @@ |
csFontCache::KnownFont | A font known to the cache |
csList< T, MemoryAllocator >::ListElement | Template which describes the data stored in the linked list For example a list of ints uses ListElement<int> |
CS::Memory::LocalBufferAllocator< T, N, ExcessAllocator, SingleAllocation > | An allocator with a small local buffer |
CS::Meta::Log2< R > | Helper for log2 computation |
csFontCache::LRUEntry | An entry in the LRU list |
csBitmaskToString::MaskNames | Structure containing a name for possible bit masks |
CS::Utility::ImportKit::Container::Material | A material for a mesh |
CS::Math::Matrix4 | A 4x4 matrix |
CS::MeasureTime | Simple helper class to measure execution time of a block |
CS::Utility::ImportKit::Container::Model::Mesh | Model mesh, contains actual geometry |
CS::Utility::ImportKit::Container::Model | A model |
CS::Threading::MutexImpl< BaseMutex > | General mutex class |
csRedBlackTree< K >::Node | A node in the tree |
CS::DocSystem::NodeAttributeCompare | Node comparator |
CS::DocSystem::NodeAttributeRegexpTest | Check if a regular expression matches(case-insensitive) with the value of the given attribute |
CS::DocSystem::NodeAttributeValueTest | Compare (case-sensitive) node attribute to given |
CS::DocSystem::NodeNameCompare | Node comparator |
CS::DocSystem::NodeValueTest | Compare (case-sensitive) node value to given |
CS::Implementation::NonCopyable_ | Base-class which ensures that derived classes are not copy-constructible or assignable |
CS::Meta::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 |
CS::Threading::OptionalMutex< _Lock > | Helper that is a (non-recursive) mutex if _Lock is true or does nothing if _Lock is false |
csBox3::Outline | This table also contains an array of sides visible from that region |
CS::Graphics::OverlayShaderVariableContextImpl | IShaderVariableContext implementation that overlays (or merges) it's variables over the variables of a given parent context |
CS::SndSys::PCMSampleConverter | A PCMSampleConverter object converts PCM data from one format to another |
CS::PluginCommon::SoftShader::InterpolateEdgePersp::PerFloat | A single interpolated buffer value |
csFontCache::PlaneGlyphs | Array of a number of glyphs |
CS::Geometry::Primitive | Superclass for all primitives |
CS::Geometry::Primitives | A primitive mesh generator |
CS::Utility::PriorityQueue< T, Container, Comparator > | An implementation of a priority queue |
csShaderProgram::ProgramParam | Program parameter, either a SV reference or a const value |
csRenderBuffer::Props | To scrape off a few bytes use bitfields; assumes values are in sane limits |
CS::Utility::ResourceCache::PurgeConditionAfterTime< TimeType > | Purge condition: a resource is purged after a certain time has passed |
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::RenderBufferPersistent | Render buffer wrapper with additional persistence information |
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 |
CS::Graphics::RenderMesh | Mesh data as returned by mesh plugins |
CS::Graphics::RenderMeshIndexRange | Start and end for a range of indices to render |
CS::Graphics::RenderMeshModes | Mesh render mode information |
CS::RenderViewClipper | Helper to clip in the context of a render view |
CS::Utility::ResourceCache::ReuseConditionAfterTime< TimeType > | Reuse condition: a resource is reused after a certain time has passed |
CS::Utility::ResourceCache::ReuseConditionFlagged | Reuse condition: a resource is reused after being flagged as such |
csRedBlackTreeMap< K, T >::ReverseIterator | Reverse iterator for map |
CS::Threading::Runnable | Abstract base class for objects to be run in threads |
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 |
scfImplementation< Class > | Baseclass for the SCF implementation templates |
scfImplementationHelper | Various helpers for scfImplementation |
scfImplementationPooled< Super, Allocator, Locked > | Derive an SCF implementation from this class to have it pooled |
scfInterfaceMetadata | Metadata about a single interface implemented within a class |
scfInterfaceMetadataList | A chain list of metadata for interfaces implemented within a class |
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::Utility::ScopedDelete< T > | Helper class to delete a pointer when exiting a scope |
CS::Threading::ScopedLock< T > | This is a utility class for locking a Mutex |
CS::Graphics::ShaderVariableContextImpl | Simple implementation for iShaderVariableContext |
CS::ShaderVarName | Helper class to obtain an ID for a shader variable |
CS::Lighting::SimpleStaticLighter | The functions in this class all provide a simple way to initialize the "static color" of a mesh (usually genmesh) to provide a way to do simple static 'lighting' |
CS::Utility::ResourceCache::SortingNone | Resource sorting that does not sort |
CS::SndSys::SoundCyclicBuffer | An implementation of a cyclic buffer oriented for sound functionality |
CS::Geometry::Sphere | A sphere |
CS::SndSys::SndSysBasicStream::StreamNotificationEvent | Structure containing the data for each notification event |
CS::StructuredTextureFormat | Structured representation of a texture format |
CS::SubRectangles::SubRect | Sub-rectangle |
CS::SubRectangles | A class managing allocations of sub-rectangles |
CS::SubRectanglesCompact | A variation of SubRectangles that tries to place rectangles in a rectangular fashion |
csEventTree::SubscriberIterator | The SubscriberIterator is a wrapper for the messy internals of figuring out which event handler to call next |
CS::Geometry::TableTextureMapper | Table texture mapper |
CS::Geometry::TesselatedBox | A Tesselated box |
CS::Geometry::TesselatedQuad | A tesselated quad |
CS::TextureFormatStrings | Texture format string parser routines |
CS::Geometry::TextureMapper | Class for controlling texture mapping on the generated meshes |
CS::Threading::Thread | Object representing a separate execution thread |
CS::Threading::ThreadGroup | A group of threads handled as one unit |
CS::TriangleIndicesStream< T > | Helper class to extract triangles from an index buffer |
CS::TriangleIndicesStreamRandom< T > | Extracts triangles like TriangleIndicesStream, but also provides random access to individual triangles and can be resetted |
CS::TriangleT< T > | A templated triangle |
CS::Geometry::Triangulate3D | Functions |
CS::Meta::TypeOfSize< Size > | Get a unsigned integer type with a given number of bytes of storage |
CS::Meta::TypeWithAlignment< Alignment > | Get type with specified alignment |
CS::UberScreenshotMaker | Helper to create "überscreenshots", screenshots with a resolution larger than the current framebuffer resolution |
csShaderProgram::VariableMapEntry | Holder of variable mapping |
CS::Utility::WeakReferenced | This is a class which provides basic weak reference-counting semantics |
CS::Meta::Implementation::Wrap< T > | Simple dummy-wrapper |
Generated for Crystal Space 1.4.1 by doxygen 1.7.1