Public API Reference

Crystal Space 1.2.1 Class List

Here are the classes, structs, unions and interfaces with brief descriptions:
_csKeyModifiersFlags for all currently pressed modifiers
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::AllocatorMallocA default memory allocator that allocates with cs_malloc()
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::Utility::Implementation::CompileAssertFailure< true >
CS::Utility::Implementation::CompileAssertTest< x >
CS::Threading::ConditionCondition variable
CS::CowWrapper< T, MemoryAllocator >Copy-on-write wrapper for arbitrary types
csAddonReferenceAn object representing an addon
csAlphaModeDescribes how to deal with alpha values in textures
csAnimatedPixmapA pixmap with a 2d animation
csAnimationTemplateA 2d animation template. This class is used to create animated pixmaps
csAnsiParserHelper to parse a string for ANSI codes
csAnsiParser::CommandParamsParameters to ANSI command
csApplicationFrameworkApplication framework class
csApplicationRunner< T >Helper template to run a csApplicationFramework-derived application class
csArchiveThis class can be used to work with standard ZIP archives
csArray< T, ElementHandler, MemoryAllocator, CapacityHandler >A templated array class
csArray< T, ElementHandler, MemoryAllocator, CapacityHandler >::ConstIteratorIterator for the Array<> class
csArray< T, ElementHandler, MemoryAllocator, CapacityHandler >::IteratorIterator for the 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
csArrayThresholdVariableCsArray variable threshold for capacity handlers
csBakeKeyColorFunctions to bake keycolor into the alpha channel of images
csBaseEventHandlerBase implementation of a generic event handler
csBaseEventHandler::EventHandlerImplActual iEventHandler implementation
csBaseRenderStepLoaderBase class for render step loaders
csBaseRenderStepTypeBase class for render step loaders
csBaseTextureFactoryBase class for texture factories, with support for common parameters
csBigEndianBig endian to native conversion routines
csBitArrayA 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
csBitmapMetricsMetrics for a glyph that are dependent from whether a simple or antialiased image is used
csBitmaskToStringSmall helper to get a "pretty" string for a combination of bit masks
csBitmaskToString::MaskNamesStructure 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
csBox2A bounding box in 2D space
csBox2IntA 2D bounding box with integer coordinates
csBox3A bounding box in 3D space
csBox3::OutlineThis table also contains an array of sides visible from that region
csBoxClipperAble to clip convex polygons to a rectangle (such as the screen)
csBSplineA B-spline
csBSPTreeThis BSP-tree is a binary tree that organizes a triangle mesh
csCallStackCall stack
csCallStackHelperHelper to create a call stack
csCatmullRomSplineA CatmullRom spline
csChainHull2DThis is Andrew's monotone chain 2D convex hull algorithm
csClipInfoStructure for use with ClipToPlane
csClipperAbstract parent to all 2D clipping objects
csCLQAttenuationConstant, Linear, Quadratic attenuation Out = in /(const + distance*lin + distance^2*quad)
csColliderActorWith csColliderActor you can more easily manage collision detection of a player or character model with gravity handling
csColliderHelperThis is a class containing a few static member functions to help work with csColliderWrapper and collision detection in general
csColliderWrapperThis is a convenience object that you can use in your own games to attach an iCollider object (from the CD plugin system) to any other csObject (including CS entities)
csCollisionPairA structure used to return collision pairs
csColorA class used to represent a color in RGB space
csColor4A class used to represent a color in RGBA space
csColorQuantizerColor quantizer
csCommandEventDataStructure that collects the data a command event carries
csCommandEventHelperHelper class to conveniently deal with command events
csCommandLineHelperThis class can be used to help parsing the commandline
csCommandLineOptionRepresentation of a commandline option
csCommandLineParserUtility class that makes it easier to parse the command line
csCommonImageFileA base class for image loader plugin iImage implementations
csCommonImageFileLoaderBase 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 >
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
csCompressVertexThis structure is used by csVector3Array::CompressVertices()
csCompressVertexInfoThis structure is used by csVertexCompressor::Compress()
csConditionA condition object
csConfigAccessThis is a simple convenience class that can be used to deal with the sytem config manager
csConfigDocumentIConfigFile implementation for configurations stored in documents
csConfigFileConfiguration file which implements the iConfigFile SCF interface
csConfigManagerA 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
csCoreRenderMeshData required by the renderer to draw a mesh
csCoverageTileCoverage tile
csCtoWHelper class to convert char* (UTF-8 encoded )to wchar_t* strings for use as function parameters
csCubicSplineA cubic spline
csCursorConverterHelper class to convert images into data formats suitable for mouse cursor creation on various platforms and toolkits
csDebugImageWriterHelper class allowing in debug builds for to quickly dump an iImage object onto disk for visual inspection
csDIntersect3Some functions to perform various intersection calculations with 3D line segments
csDirectionalLightProc< AttenuationProc >Preform directional light lighting calculation without shadowing
csDirectionalLightProc< AttenuationProc >::PerVertex
csDirectXErrorObtain 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
csDMath3Various assorted 3D mathematical functions
csDMatrix3A 3x3 matrix
csDocumentAttributeCommonPartial iDocumentAttribute implementation with commonly duplicated logic
csDocumentNodeCommonPartial iDocumentNode implementation with commonly duplicated logic
csDocumentNodeReadOnlyPartial iDocumentNode implementation with commonly duplicated logic and dummy implementations for manipulation methods
csDPlaneA plane in 3D space
csDSquaredDistSome functions to perform squared distance calculations
csDVector3A 3D vector
csEllipsoidThis class represents an ellipsoid
csEmptyDocumentAttributeIteratorDocument attribute iterator does not return any attributes
csEmptyDocumentNodeIteratorDocument node iterator does not return any nodes
csEngineToolsThis is a class with static helper functions for working on engine data
csEventThis class represents a system event
csEventCordEvent cord
csEventFlattenerStandard event flattener(also known as serializer)
csEventHandlerRegistryThe 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
csEventNameRegistryThe 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)
csEventOutletA class which implements the iEventOutlet interface
csEventQueueThis class represents a general event queue
csEventQueue::iTypedFrameEventDispatcherAs a transitional measure, the csevPreProcess, csevProcess, csevPostProcess and csevFinalProcess events are actually sub-events dispatched by a csevFrame handler
csEventTimerThis class implements a timer
csEventTreeThis class is used to represent the event namespace (tree)
csEventTree::SubscriberIteratorThe 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
csFileReadHelperConvenience class for simple file element reading
csFileTimeFile time structure - used to query and set the last-modification time of a file
csFixed16Encapsulation of a 16.16 fixed-point number
csFixed24Encapsulation 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 >::DefaultDisposerDefault disposer mixin, just reporting leaks
csFixedSizeAllocator< Size, Allocator >::FreeNode
csFlagsSet of flags which can be accessed through masks
csFmtDefaultReader< T >Standard format string source for csPrintfFormatter
csFmtDefaultWriter< T >Standard formatted string destination for csPrintfFormatter
csFogSector fog structure
csFogInfoInformation for vertex based fog
csFogMathFog math utilities
csFontCacheA cache for font glyphs
csFontCache::FontDeleteNotifyFont deletion callback
csFontCache::GlyphCacheDataSome basic data associated with a glyph
csFontCache::KnownFontA font known to the cache
csFontCache::LRUEntryAn entry in the LRU list
csFontCache::PlaneGlyphsArray 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
csFrustumA general frustum
csFrustumContextThis 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
csGenerateImageThis class will compute a texture for a terrain
csGenerateImageLayerThis class is used to store the layers of textures per value
csGenerateImageTextureA base class which represents a texture that can be displayed on the terrain
csGenerateImageTextureBlendClass for a texture that is made by blending together other textures based on a value
csGenerateImageTextureSingleA class for a single texture
csGenerateImageTextureSolidA class for a solid coloured texture
csGenerateImageValueA base class which represents a value that can be computed for blending purposes for each pixel
csGenerateImageValueFuncThis class will generate a value using a given function
csGenerateImageValueFuncConstThis class will generate a constant value
csGenerateImageValueFuncTexThis class will generate a value using a texture
csGeomDebugHelperThis is a class that does unit testing (and other debug stuff) for most of csgeom classes
csGetFromAddressSized data type access helpers
csGLDriverDatabaseOpenGL driver database
csGLExtensionFlagsStruct containing all GL extension test flags
csGLExtensionFunctionsStruct containing all GL extension functions
csGLExtensionManagerGL extensions manager
csGLFontCacheOpenGL font cache
csGLScreenShotOpenGL screen shot
csGLStateCacheOpenGL state cache
csGlyphMetricsMetrics for a glyph that are independent from whether a simple or antialiased image is used
csGradientA simple color gradient
csGradientShadeAn entry in an iGradient gradient
csGraphics2DThis is the base class for 2D canvases
csGraphics2DGLCommonBasic OpenGL version of the 2D driver class
csGraphics3DCapsInformation 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 >::ConstGlobalIteratorAn const iterator class for the hash
csHash< T, K, ArrayMemoryAlloc >::ConstIteratorAn const iterator class for the hash
csHash< T, K, ArrayMemoryAlloc >::Element
csHash< T, K, ArrayMemoryAlloc >::GlobalIteratorAn iterator class for the hash
csHash< T, K, ArrayMemoryAlloc >::IteratorAn 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
csHitBeamResultReturn structure for the iMeshWrapper->HitBeam() routines
csIdentStringsHelper class that contains a list of identifiers and their names
csIEEEfloatConvert IEEE 32-bit floats from or to native machine floats
csImageAreaThis structure is used for saving/restoring areas of screen
csImageBaseBase class for iImage implementations
csImageCubeMapMakerWrapper class to create a cube map from a number of 2D images as the cube faces
csImageIOFileFormatDescriptionDescription for a file format supported by an image loader
csImageLoaderOptionsParserHelper class to parse options strings passed to iImageIO::Save()
csImageManipulateHelper class to manipulate iImage objects
csImageMemoryMemory image
csImageToolsSome helper functions to deal with iImage objects
csImageVolumeMakerWrapper class to create a volume aka 3D texture from a number of 2D images as the volume slices
csInitializerThis class contains several static member functions that can help setup an application
csInputBinderUse this class to bind input events (keypress, button press, mouse move, etc
csInputDefinitionThis 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
csInputDriverSuperclass of all the generic input drivers
csInputEventHelperHelper class to conveniently pull generic data out of input events
csInstallationPathsHelperA helper class containing a number of functions to deal with Crystal Space installation paths
csInterleavedSubBufferOptionsStructure describing the properties of the individual buffers to be interleaved
csIntersect2Some functions to perform various intersection calculations with 2D line segments
csIntersect3Some functions to perform various intersection calculations with 3D line segments
csIntersectingTriangleAn intersection triangle for CollideRay
csInverseAttenuationInverse linear attenuation
csJoystickDriverGeneric Joystick driver
csJoystickEventDataStructure that collects the data a joystick event carries
csJoystickEventHelperHelper class to conveniently deal with joystick events
csKDTreeA KD-tree
csKDTreeChildA child in the KD-tree (usually some object)
csKeyboardDriverGeneric Keyboard Driver
csKeyEventDataStructure that collects the data a keyboard event carries
csKeyEventHelperHelper class to conveniently deal with keyboard events
csKeyValuePairA Key Value pair
csLibraryReferenceAn object representing a reference to a library
csLightPropertiesLight properties, as needed by the attenuation and lighting functors
csLightShaderVarCacheHelper to cache names of shader variables relevant to lighting
csLinearAttenuationLinear attenuation
csList< T >A lightweight double-linked list template
csList< T >::csListElementTemplate which describes the data stored in the linked list For example a list of ints uses csListElement<int>
csList< T >::IteratorIterator for the list
csLittleEndianLittle endian to native conversion routines
csLockedHeightDataLocked height data
csLockedMaterialMapLocked height data
csMapNodeA node
csMath2Various functions in 2D, such as 2D vector functions
csMath3Various assorted 3D mathematical functions
csMatrix2A 2x2 matrix
csMatrix3A 3x3 matrix
csMD5This is an encapsulation of a C-implementation of MD5 digest algorithm by Peter Deutsch <>
csMD5::DigestAn MD5 digest is 16 unsigned characters (not 0-terminated)
csMemFileEssentially a raw memory buffer which implements the abstract iFile interface
csMemoryMappedIODefines a simple memory-mapped IO class that is portable
csMemoryMappingMemory mapping, as returned by csMemoryMappedIO::GetData()
csMemoryPoolA quick-allocation pool for storage of arbitrary data
csMeshedPolygonA polygon
csMeshFactoryThis is the abstract implementation of iMeshObjectFactory
csMeshObjectThis is an abstract implementation of iMeshObject
csMeshOnTextureThis class manages the rendering of a mesh on a texture
csMeshTypeThis is the abstract implementation of iMeshObjectType
csMouseDriverGeneric Mouse Driver
csMouseEventDataStructure that collects the data a mouse event carries
csMouseEventHelperHelper class to conveniently deal with mouse events
csMutexA mutual-exclusion object
csNewtonianParticleSystemThis class has a set of particles that behave with physics
csNoAttenuationNo attenuation
csNodeIteratorA node iterator
csNormalCalculatorA normal calculator
csNormalizationCubeAccessorShader variable accessor for a normalization cubemap
csNormalMappingToolsSome helpers for stuff related to normal maps
csNullCacheManagerThis is a general cache that doesn't cache anything at all
csOBBOriented bounding box (OBB)
csOBBFrozenVersion of the csOBB with frozen corners (for optimization purposes)
csObjectA generic csObject class
csObjectModelHelper class to make it easier to implement iObjectModel in mesh objects
csObjectRegistryThis is an implementation of iObjectRegistry
csOptionDescriptionConfiguration option description
csOrthoTransformA class which defines a reversible transformation from one coordinate system to another by maintaining an inverse transformation matrix
csPackRGBRGB data packing
csPackRGBARGBA data packing
csParasiticDataBufferA databuffer pointing into another databuffer
csParasiticDataBufferBaseBase class for pooled and unpooled parasitic data buffer
csParasiticDataBufferPooledA databuffer pointing into another databuffer, pooled version
csPartialOrder< T >A generic finite partial order class
csPartialOrder< T >::Node
csParticleData representation of a single particle
csParticleAuxAuxiliary data per particle, not used as often
csParticleBufferBuffer holder for particle buffers
csParticleSystemThis class represents a particle system
csPathA path in 3D
csPathsListClass to manage a list of paths
csPathsList::EntryThis structure contains information about a plugin path
csPathsUtilitiesA helper class with path-related utilities
csPDelArray< T >An array of pointers
csPDelArrayElementHandler< T >
csPenA pen specialized for CS
csPhysicalFileAn implementation of the abstract iFile interface for real files within the physical filesystem
csPixelCoordSimple 2D pixel coordinate
csPixelFormatStructure describing the pixel format
csPixmapThis class is an simple set of inline routines good as an abstraction for simple 2D sprites
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
csPlane2A plane in 2D space
csPlane3A plane in 3D space
csPlatformMemoryMappingDummyMemory mapping for platforms without memory mapping support - it does nothing, so the software emulation kicks in when csMemoryMappedIO is used
csPlatformMemoryMappingPosixMemory mapping for platforms with POSIX mmap() support
csPlatformMemoryMappingWin32Memory mapping for Win32
csPluginLoaderThis utility class helps to load plugins based on request, config file, and commandline
csPluginManagerThis is the standard implementation of the plugin manager
csPluginRequestThis class represents a single plugin request for csInitializer::RequestPlugins()
csPointLightProc< AttenuationProc >Preform pointlight lighting calculation without shadowing
csPointLightProc< AttenuationProc >::PerVertex
csPoly2DThe following class represents a general 2D polygon
csPoly2DFactoryThis factory is responsible for creating csPoly2D objects or subclasses of csPoly2D
csPoly2DPoolThis is an object pool which holds objects of type csPoly2D
csPoly3DThe following class represents a general 3D polygon
csPolygonClipperCan be used for clipping any polygon against any other convex polygon
csPolygonMeshA convenience polygon mesh implementation that you can feed with vertices and polygons from another source
csPolygonMeshBoxA convenience polygon mesh implementation that represents a cube
csPolygonMeshEdgeA definition of one edge
csPolygonMeshToolsA set of tools to work with iPolygonMesh instances
csPolygonRangeA range structure for specifing polygon ranges
csPolyIndexedThe following class represents a general polygon
csPoolEventThis class is a system event designed for the pool system
csPrefixConfigThis is an implementation of iConfigFile that stores an ID string at construction, which it then prepends to all config keys on read/write operations
csPrimitivesA primitive mesh generator
csPrintfFormatter< Twriter, Treader >Templated class for printf()-style string formatting
csProcAnimatedProcedural texture for animated images
csProcessorCapabilityThis class is used to identify capabilities in the processor such as support for MMX and SSE
csProcTextureGeneric superclass for procedural textures
csProgressPulseSimple 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
csQuaternionClass for a quaternion
csRadixSorterA radix-sorter for signed and unsigned integers as well as floats
csRandomFloatGenFast simple random number generator for floating point values
csRandomGenPortable random number generator class
csRandomVectorGenRandom number generator that generates random vector with spherical distribution
csRealisticAttenuationInverse quadratic attenuation
csRectRectangle class: simple class for manipulating 2D rectangles
csRectRegionA rect region is a class that implements splittable 2d rectangles
csRedBlackTree< K >A red-black-tree
csRedBlackTree< K >::NodeA 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
csRefCountThis is a class which provides basic reference-counting semantics
csRefTrackerAccessHelper to facilitate access to the global reference tracker
csRegExpMatchInformation about (sub)expression matches
csRegExpMatcherMatcher for regular expressions
csRenderBufferRender buffer - basic container for mesh geometry data
csRenderBuffer::PropsTo scrape off a few bytes use bitfields; assumes values are in sane limits
csRenderBufferHolderHolder of standard renderbuffers
csRenderBufferLock< T, TbufferKeeper >Helper class for convenient locking/unlocking of an iRenderBuffer
csRenderContextThis structure keeps track of the current render context
csRenderMeshMesh data as returned by mesh plugins
csRenderMeshHolderHelper class to retrieve an unused csRenderMesh
csRenderMeshListThis class is used when we need to store, sort and then render a list of rendermeshes
csRenderMeshModesMesh render mode information
csRenderStepParserParser for render steps and render step lists
csReporterHelperHelper class for csReport()
csReversibleTransformA class which defines a reversible transformation from one coordinate system to another by maintaining an inverse transformation matrix
csRGBcolorAn RGB color
csRGBpixelAn RGB pixel
csRunnableAbstract interface for objects which can be run in a thread
csSafeCopyArray< T >Convenience class to make a version of csArray<> that does a safe-copy in case of reallocation of the array
csSaverFileAn object containing information about where to save a file
csScfStringSetThe string set is a collection of unique strings
csScheduleEasy way to get timers in applications
csScopedLock< T >
csScopedMutexLockThis is a utility class for locking a Mutex
csScreenBoxResultReturn structure for iMeshWrapper->GetScreenBoundingBox()
csScreenShotSimple iImage implementation for canvas screenshots
csScreenTargetResultThis structure is returned by csEngineTools::FindScreenTarget()
csScriptCommonThis intermediate class can be subclassed by implementors of iScript
csScriptObjectCommonThis intermediate class can be subclassed by implementors of iScriptObject
csSectorHitBeamResultReturn structure for the iSector->HitBeam() routines
csSegment2A 2D line segment
csSegment3A 3D line segment
csSemaphoreA semaphore object
csSet< T, Allocator >This class implements a basic set for objects
csSet< T, Allocator >::GlobalIteratorAn iterator class for the set
csSetToAddressSized data type access helpers
csShaderExpressionAn evaluable expression attached to a shader variable
csShaderExpressionAccessorShader variable accessor that evaluates a shader expression when the SV value is queried
csShaderMetadataShader metadata
csShaderProgramBase class for iShaderProgram plugins
csShaderProgram::ProgramParamProgram parameter, either a SV reference or a const value
csShaderProgram::VariableMapEntryHolder of variable mapping
csShaderVarBlockAlloc< ObjectDispose >A block allocator for shader variables
csShaderVariableStorage class for "shader vars", inheritable variables in the shader system
csShaderVariableContextComplete SCF class implementing iShaderVariableContext
csShaderVariableFrameHolderHelper class to obtain a shader variable that was guaranteedly not used in a frame yet
csShaderVarMappingMapping of a shader variable to some shader-specific destination
csShortestDistanceResultResult structure for csEngineTools::FindShortestDistance()
csSimplePixmapThis is the simple implementation of csPixmap that uses a single texture
csSimpleRenderMeshA simple render mesh
csSndSysSoundFormatThe sound format
csSoftFontCacheFont cache base class for software canvases
csSoftFontCacheImpl< Tpixel, Tpixmixer >An actual implementation of a font cache for software canvases
csSolidSpaceThis structure keeps track of solid space
csSparse3DGeneral 3D sparse matrix class
csSphereThis class represents a sphere
csSplineA spline superclass
csSpotLightProc< AttenuationProc >Perform spotlight lighting calculation without shadowing
csSpotLightProc< AttenuationProc >::PerVertex
csSprite2DVertexA single 2D Sprite vertex
csSquaredDistSome functions to perform squared distance calculations
csStringThin wrapper around csStringFast<> with its default buffer size
csStringArrayAn array of strings
csStringBaseThis 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 >
csStringHashA string-to-ID hash table
csStringReaderThis is a convenience class that reads an input buffer line by line
csStringSetThe string set is a collection of unique strings
csSwapBytesMethods to unconditionally swap the byte order of specifically sized types
csTerrainColliderCollideSegmentResultReturn structure for the iTerrainCollider->CollideSegment() routines
csTestRectDataA structure used by TestRectangle() and initialized by PrepareTestRectangle()
csTextProgressMeterDisplays a simple percentage-style textual progress meter
csTextureHandleThis class is the top-level representation of a texture
csTextureManagerGeneral version of the texture manager
csTextureTransThis is a static class which encapsulates a few functions that can transform texture information into a texture matrix/vector
csThreadRepresentation of a thread of executation
csTiledCoverageBufferThe tiled coverage Buffer
csTinyDocumentSystemThis is an SCF compatible wrapper for the TinyXml parser in csutil
csTraceBeamResultReturn structure for the csColliderHelper::TraceBeam() method
csTransformA class which defines a transformation from one coordinate system to another
csTreeNodeA generic tree class
csTriangleA triangle
csTriangleLODAlgoAlgorithm class that calculates the cost of a vertex
csTriangleLODAlgoEdgeThis subclass of csTriangleLODAlgo uses a very simple cost metric to calculate the vertex cost
csTriangleMeshA mesh of triangles
csTriangleMeshBoxA convenience triangle mesh implementation that represents a cube
csTriangleMeshEdgeA definition of one edge
csTriangleMeshLODA static class which performs the calculation of the best order to do the collapsing of a triangle mesh
csTriangleMeshPointerA convenience triangle mesh which takes vertex and triangle pointers from another source
csTriangleMeshPolyMeshThis triangle mesh is a temporary class that takes a polygon mesh and wraps it so that it becomes a triangle mesh
csTriangleMeshToolsA set of tools to work with iTriangleMesh instances
csTriangleMinMaxA triangle with minimum/maximum information on x
csTriangleVertexThe representation of a vertex in a triangle mesh
csTriangleVertexCostThe representation of a vertex in a triangle mesh
csTriangleVerticesA class which holds vertices and connectivity information for a triangle mesh
csTriangleVerticesCostA class which holds vertices and connectivity information for a triangle mesh
csTriangleVerticesSortedThis class works closely with csTriangleVerticesCost and maintains a sorted (on cost) view of the vertices
csTriangulate2This 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
csUnicodeTransformContains functions to convert between several UTF encodings
csUserRenderBufferManagerHelper class to manage multiple render buffers, usually provided by the user
csVariantVariant, means that type of contained data is set at runtime
csVector2A 2D vector
csVector3A 3D vector
csVector3ArrayThis is actually the same class as csPoly3D
csVector4A 4D vector with "float" components
csVector4T< T >A 4D vector with variable type components
csVerbosityManagerDefault iVerbosityManager implementation
csVerbosityParserUtility for parsing verbosity flags such as those provided by the --verbose=flags command-line option
csVertexCompressorA 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
csVertexStatusThe clipper can output additional information about each vertex in output polygon
csVfsCacheManagerThis is a general cache that can cache data on VFS
csVfsDirectoryChangerHelper class to change the current VFS directory and restore the previous directory when an instance goes out of scope
csViewEncapsulates the top-level Crystal Space renderer interface
csVirtualClockThis is an implementation of a virtual clock
csWeakRef< T >A weak reference
csWeakRefArray< T >An array of weak references
csWideSparse3DThis implementation of csSparse3D is very suited where the accesses will be very widely spaced (for example: one element at (-1000,0,0) and one at (1000,0,0))
csWin32CustomCursorsClass to create native Win32 mouse cursors from images
csWin32RegistryConfigAn iConfigFile, storing the settings in the Windows registry
cswinCallStackHelperCall stack creation helper (Win32-specific)
cswinCtoASmall helper to convert an UTF-8 to an ANSI string, useful when passing arguments to a function
cswinMinidumpWriterHelper to write minidumps on Win32
cswinWtoASmall helper to convert a wide to an ANSI string, useful when passing arguments to a function
csWtoCHelper class to convert wchar_t* to char* (UTF-8 encoded) strings for use as function parameters
csXRotMatrix3An instance of csMatrix3 that is initialized as a rotation about X
csXScaleMatrix3An instance of csMatrix3 that is initialized to scale the X dimension
csYRotMatrix3An instance of csMatrix3 that is initialized as a rotation about Y
csYScaleMatrix3An instance of csMatrix3 that is initialized to scale the Y dimension
csZRotMatrix3An instance of csMatrix3 that is initialized as a rotation about Z
csZScaleMatrix3An instance of csMatrix3 that is initialized to scale the Z dimension
CS::Memory::CustomAllocatedClass that overrides operator new/operator delete/etc
CS::DataBuffer< Allocator >This is an implementation of iDataBuffer interface
DirectDetectionMaster class of the device detection of direct3d and directdraw
DirectDetectionDeviceDescription of DirectDraw device
CS::DocSystem::Implementation::FilterDocumentNodeIterator< T >Filtering iDocumentNodeIterator
FrameBegin3DDrawFrameBegin3DDraw handles every csevFrame event in the 3D phase
FramePrinterFramePrinter handles every csevFrame event in the FRAME (final) phase
getopt_optionDescribe the long-named options requested by the application
CS::Memory::HeapA separate heap from which memory can be allocated
CS::Memory::HeapAccessPointer< HeapContainer >Heap accessor for AllocatorHeapBase
iAddonReferenceThis interface represents a reference to an addon
iAnimatedImageIf an image file has animation capabilities, this interface is exhibited
iAnimTimeUpdateHandlerBy 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
iBaseThis is the basic interface: all other interfaces should be derived from this one, this will allow us to always use at least some minimal functionality given any interface pointer
iBaseHaloThis is the basic interface for all types of halos
iBezierFactoryStateThis is the state interface to access the internals of a bezier mesh factory
iBezierStateThis is the state interface to access the internals of a bezier mesh object
iBinaryLoaderPluginThis is a binary plugin for the loader
iBodyGroupBody Group is a collection of bodies which don't collide with each other
iBugPlugUsing this interface you can communicate with the BugPlug plugin
iBugPlugRenderObjectAn application/module can implement this interface to render something
iCacheManagerA generic cache system
iCameraCamera class
iCameraPositionA camera position
iCameraPositionListA list of camera position objects
iCameraSectorListenerImplement this interface if you are interested in learning when the camera changes sector
iCEGUIInterface for the CS CEGUI wrapper
iClipper2DThis interfaces represents a 2D clipper for polygons
iColliderA mesh collider
iCollideSystemThis is the Collide plug-in
iCommandLineParserA utility class that makes it easier to parse the command line
iComponentThis interface describes a generic component in Crystal Space
iConfigFileConfiguration file interface
iConfigIteratorIterator which allows sequential access to configuration information contained in an iConfigFile object
iConfigManagerThe configuration manager is used to make a number of iConfigFile object appear like a single object
iConsoleExecCallbackCommand execution callback
iConsoleInputThis is a plugin that can handle keyboard input and display it on an associated console
iConsoleOutputThis is the Crystal Space Console interface
iConsoleWatcherThis interface is implemented by objects interested in knowing when the console's visibility status has changed
iCrossHaloThis is a halo which resembles a cross
iCursorThis interface is used to access the custom cursor plugin, which handles processing for displaying pixmaps as cursors
iCurveThis is the interface for a curve
iDataBufferThe iDataBuffer interface can be used to exchange buffers with abstract data between plugins
iDebugHelperSome object that wants to implement unit testing, debugging and/or benchmarking can implement this interface
iDecalA decal created by the decal manager
iDecalBuilderInterface for mesh objects to use to build decals for their mesh object
iDecalManagerCreates and manages decals
iDecalTemplateInterface for a decal template which dictates the appearance of a newly created decal
CS::PluginCommon::SoftShader::iDefaultScanlineRendererDefault software scanline renderer
CS::PluginCommon::SoftShader::iDefaultShaderSoftware renderer default shader plugin
iDocumentRepresentation of a document containing a hierarchical structure of nodes
iDocumentAttributeAn attribute for an iDocumentNode
iDocumentAttributeIteratorAn iterator over iDocumentNode attributes
iDocumentNodeRepresentation of a node in a document
iDocumentNodeIteratorAn iterator over iDocumentNode
iDocumentSystemAn iDocument factory
iDynamicsThis is the interface for the actual plugin
iDynamicsColliderCollisionCallbackThis is the interface for attaching a collider callback to the body
iDynamicsCollisionCallbackThis is the interface for attaching a collider callback to the body
iDynamicsMoveCallbackThis is the interface for a dynamics move callback
iDynamicsStepCallbackThis is the interface for a dynamics step callback
iDynamicsSystemColliderThis is the interface for a dynamics system collider
iDynamicSystemThis is the interface for the dynamics core
iEmitBoxBox value emitter - returns points in an (axis aligned) box
iEmitConeCone value emitter - returns points in a cone
iEmitCylinderCylinder value emitter - returns values in a cylinder
iEmitCylinderTangentCylinder tangential value emitter - gives direction tangential to cylinder Uses the given point, gives a tangential direction for that
iEmitFactoryStateThis interface describes the API for the emitter mesh factory object
iEmitFixedFixed value emitter - returns a particular point value
iEmitGen3DThis interface is for objects that can generate 3d vectors, which are used for emitting
iEmitLineLine value emitter - returns values on the line between start and end
iEmitMixMix value emitter - returns a weighted random mix of other emitters
iEmitSphereSphere value emitter - returns points in a sphere
iEmitSphereTangentSphere tangential value emitter - gives direction tangential to sphere Uses the given point, gives a tangential direction for that
iEmitStateThis interface describes the API for the emitter mesh object
iEngineThis interface is the main interface to the 3D engine
iEngineFrameCallbackA callback that will be fired whenever the engine starts drawing a frame
iEngineSectorCallbackA callback that will be fired whenever a sector is created or removed from the engine
iEngineSequenceManagerSequence manager specifically designed for working on the engine
iEngineSequenceParametersAn interface for passing on parameters to the engine sequence manager
iEventThis interface describes any system event
iEventAttributeIteratorEvent attribute iterator
iEventCordThe iEventCord is an interface provided by an event queue to any event handlers wanting to receive some subclasses of events ASAP in a specified priority, bypassing the queue itself
iEventHandlerThis interface describes an entity that can receive events
iEventHandlerRegistryThis interface represents a general event handler registry/resolver
iEventNameRegistryThis interface represents a general event name resolver
iEventOutletThe iEventOutlet is the interface to an object that is provided by an event queue to every event plug when it registers itself
iEventPlugEvent plug interface, also referred as "event source"
iEventQueueThis interface represents a general event queue
iEventTimerA timer
iFactoryIFactory is an interface that is used to create instances of shared classes
iFileA replacement for FILE type in the virtual file space
iFireTextureInterface to the 'fire' procedural texture
iFlareHaloThis is a halo which resembles a (solar) flare
iFontA font object
iFontDeleteNotifyCalled before a font is deleted
iFontServerA font server interface
iFrustumViewThis structure represents all information needed for the frustum visibility calculator
iFrustumViewUserdataUser data which can be attached to iFrustumView
iGeneralFactoryStateThis interface describes the API for the general mesh factory
iGeneralMeshCommonStateThe common interface between genmesh meshes and factories
iGeneralMeshStateThis interface describes the API for the general mesh object
iGenerateImageFunctionThis class represents a function for csGenerateImageValueFunc
iGenericRenderStepA generic render step
iGenMeshAnimationControlImplementing this class allows the creation of classes that control animation of vertex, texel, normal, and color data right before it is being used
iGenMeshAnimationControlFactoryThis class is a factory for creating animation controls
iGenMeshAnimationControlStateThis interface describes the API for setting up the animation control as implemented by the 'gmeshanim' plugin
iGenMeshAnimationControlTypeThis class is the animation control type
iGenMeshSkeletonControlStateThis interface describes the API for setting up the skeleton animation control as implemented by the 'gmeshskelanim' plugin
iGradientA simple color gradient
iGradientShadesAn array of gradient shades
iGraphics2DThis is the interface for 2D renderer
iGraphics3DThis is the standard 3D graphics interface
iGraphicsMemoryThis is the interface used to access the csGraphicsMemory plugin
iHaloIHalo: used to render halos (aka "light globes")
iHazeFactoryStateThis interface describes the API for the sprite factory mesh object
iHazeHullA mesh specially meant for use by the haze
iHazeHullBoxA predefined hull
iHazeHullConeA predefined hull
iHazeHullCreationThis interface is implemented by the haze factory in order to be able to create the predefined haze hulls
iHazeStateThis interface describes the API for the sprite factory mesh object
iImageThe iImage interface is used to work with image objects
iImageFileLoaderAn image file loader
iImageIOThe iImageIO interface is used to save and load graphic files
iImposterIImposter defines the interface a mesh (or other) class must implement to be used as imposter mesh by the engine
iInputBinderSCF interface for csInputBinder, used to bind input events (keypress, button press, mouse move, etc
iInstancingFactoryStateThis interface describes the API for the instancing mesh factory
iInstancingMeshCommonStateThe common interface between instancing meshes and factories
iInstancingMeshStateThis interface describes the API for the instancing mesh object
iJobA unit of work passed to iJobQueue
iJobQueueInterface to simple job management
iJointThis is the interface for a joint
iJoystickDriverGeneric Joystick driver
iKDTreeObjectDescriptorIf you implement this interface then you can give that to the KDtree
iKDTreeUserDataThe data type for user data to be attached to the KDTree
iKeyboardDriverGeneric Keyboard Driver
iKeyComposerKeyboard input handler
iKeyValuePairA Key Value pair
iKitchenSinkInterface to interact with a kitchen sink
iLibraryReferenceThis interface represents a reference to a library file
iLightThe iLight interface is the SCF interface for the csLight class
iLightCallbackSet a callback which is called when this light color is changed
iLightingInfoThis interface is implemented by mesh objects that have some kind of lighting system
iLightingProcessDataThe iLightingProcessData interface can be implemented by a mesh object so that it can attach additional information for the lighting process
iLightingProcessInfoThe iLightingProcessInfo interface holds information for the lighting system
iLightIteratorIterator to iterate over all static lights in the engine
iLightListThis structure represents a list of lights
iLightManagerAn engine (3D or iso) can implement this interface for the benefit of mesh objects so that they can request lighting information from the engine
iLightSectorInfluenceA light-sector influence (LSI)
iLightVisibleCallbackA callback that is fired whenever a light is visible
iLoaderThis interface represents the map loader
iLoaderContextThis interface gives the context for the loader
iLoaderPluginThis is a plugin for the loader based on document tree
iLoaderStatusAn object to query about the status of the threaded loader
iLODControlThe iLODControl interface represents an object that has controllable LOD features
CS::ImageAutoConvertSmall wrapper class to automatically convert an image into a different storage format, if needed
iMapNodeA node
iMaterialThis class represents a material as seen from the engine view
iMaterialEngineThis interface represents the engine part of the material definition
iMaterialListThis class represents a list of materials
iMaterialWrapperA material wrapper is an engine-level object that wraps around an actual material (iMaterial)
iMemoryTrackerThis interface is used with CS_MEMORY_TRACKER
iMeshDrawCallbackSet a callback which is called just before the object is drawn
iMeshFactoryListA list of mesh factories
iMeshFactoryWrapperA mesh factory wrapper is an engine-level object that wraps around a mesh object factory (iMeshObjectFactory)
iMeshGeneratorIMeshGenerator defines the interface for a mesh generator
iMeshGeneratorGeometryThis interface defines one piece of geometry for the mesh generator
iMeshListA list of meshes
iMeshObjectThis is a general mesh object that the engine can interact with
iMeshObjectDrawCallbackSet a callback which is called just before the object is drawn
iMeshObjectFactoryThis object is a factory which can generate mesh objects of a certain type
iMeshObjectTypeThis plugin describes a specific type of mesh objects
iMeshWrapperA mesh wrapper is an engine-level object that wraps around an actual mesh object (iMeshObject)
iMeshWrapperIteratorThis is an iterator mesh wrappers
iMissingLoaderDataThis callback is called when the loader can't find some material, texture, factory, mesh, light, shader, or sector
iModelLoaderSome loader plugins implement this as an easier way to load a factory from code
iMouseDriverGeneric Mouse Driver
iMovableThis interface represents the position and orientation of an object relative to its parent (this is the transformation between local object space of the model and world space (i.e
iMovableListenerImplement this class if you're interested in hearing about movable changes
iMovieRecorderUsing this interface you can communicate with the MovieRecorder plugin
CS::Utility::ImportKitCrystal Space Import Kit
CS::Utility::ImportKit::ContainerContains multiple models
CS::Utility::ImportKit::Container::MaterialA material for a mesh
CS::Utility::ImportKit::Container::ModelA model
CS::Utility::ImportKit::Container::Model::MeshModel mesh, contains actual geometry
iNativeWindowThis interface represents a native window
iNativeWindowManagerThis interface represents the native window manager system
iNovaHaloThis is a halo which resembles a nova
CS::PluginCommon::SoftShader::InterpolateEdgePerspInterpolator for a polygon edge
CS::PluginCommon::SoftShader::InterpolateEdgePersp::PerFloatA single interpolated buffer value
CS::PluginCommon::SoftShader::InterpolateScanlinePersp< maxFloats >Interpolator over a scanline
CS::PluginCommon::SoftShader::InterpolateScanlinePersp< 0 >
CS::PluginCommon::SoftShader::InterpolateScanlinePerspCommonInterpolator over a scanline, common code
iNullFactoryStateThis interface describes the API for the null mesh object factory
iNullMeshStateThis interface describes the API for the null mesh object
iObjectThis interface is an SCF interface for encapsulating csObject
iObjectIteratorThis is an iterator for child objects of a csObject
iObjectModelThis interface represents data related to some geometry in object space
iObjectModelListenerImplement this class if you're interested in hearing about when the object model changes
iObjectNameChangeListenerA callback that you can implement to get notified of name changes in an iObject
iObjectRegistryThis interface serves as a registry of other objects
iObjectRegistryIteratorUse an instance of this class to iterate over objects in the object registry
iObjectWatcherThis is a generic object watcher
iObjectWatcherListenerImplement this class if you're interested in hearing about object watcher events
iODEAMotorJointODE AMotor joint
iODEBallJointODE ball and socket joint (contrainted translation and free rotation)
iODEDynamicStateThis class exposes parameters specific to odedynam as an implementation of iDynamics
iODEDynamicSystemStateThis class exposes parameters specific to odedynam as an implementation of iDynamics
iODEFrameUpdateCallbackThis class can be passed in as a callback during the physics update it is only called if FrameRate is enabled
iODEGeneralJointStateGeneral joint state
iODEHinge2JointODE hinge 2 joint
iODEHingeJointODE hinge joint (contrainted translation and 1 free rotation axis)
iODEJointStateGeneral joint state
iODEUniversalJointA universal joint is like a ball and socket joint that constrains an extra degree of rotational freedom
iOffscreenCanvasCallbackWhen you create an offscreen canvas (CreateOffscreenCanvas()) then you can use this callback to get informed when the texture has been modified (FinishDraw() called) or a palette entry is modified
iOpenGLDriverDatabaseInterface to read custom GL driver databases
iOpenGLInterfaceA common interface to be implemented by the platform specific opengl canvases
iOSXAssistantThis is an interface for an object which provides assistance to MacOS/X-specific canvases and Objective-C bridging code for application run-loop support
iPagingFormerStateIPagingFormerState exposes implementation specific methods for the PagingTerraformer plugin
iParameterESMThis interface is a parameter resolver
iParticleA iParticle can be used in particle Systems
iParticleBuiltinEffectorFactoryFactory for builtin effectors
iParticleBuiltinEffectorForceSimple force/acceleration applied to particles
iParticleBuiltinEffectorLinColorSimple linear interpolation of particle color based on particle lifetime
iParticleBuiltinEffectorVelocityFieldVelocity field effector
iParticleBuiltinEmitterFactoryFactory for builtin emitter-types
iParticleEffectorBase interface for particle effector
iParticleEmitterA particle emitter
iParticleStateThis interface describes the API for the particle mesh object
iParticleSystemProperties for particle system object
iParticleSystemBaseBase properties for particle system
iParticleSystemFactoryProperties for particle system factory
iPathA path in 3D
iPenA pen is used to draw vector shapes
iPluginConfigInterface to a configurator object
iPluginIteratorAn iterator to iterate over all plugins in the plugin manager
iPluginManagerThis is the plugin manager
iPolygonHandleThis is an interface that can be used to represent a polygon in situations where a SCF object is required
iPolygonMeshThis interface reprents a mesh of polygons
iPortalThis is the interface to the Portal objects
iPortalCallbackWhen a sector is missing this callback will be called
iPortalContainerA container for portals
iProcTexCallbackA callback for when a iTextureWrapper is used
iProcTextureInterface to a texture factory
iProfilerInterface to profiler
iProfilerFactoryInterface to profile factory
iProgressMeterThis is a general interface for a progress meter
iProtoFactoryStateThe proto mesh is a demonstration or tutorial mesh
iProtoMeshStateThis interface describes the API for the proto mesh object
iRefTrackerThe reference tracker interface
iRegionA region
iRegionListA list of region objects
iRenderBufferThis is a general buffer
iRenderBufferAccessorInterface for renderbuffer accessor
iRenderBufferCallbackCallback function used upon destruction of render buffer
iRenderBufferPersistenceRender buffer persistence information
iRendererLightmapA lightmap registered with a renderer
iRenderLoopRender loop
iRenderLoopManagerRender loop manager
iRenderStepContainerContainer for render steps
iRenderStepFactoryInterface to a render step factory
iRenderStepTypeRender step type
iRenderViewThis interface represents all information needed to render some object in a current draw context
iReporterThis is the interface for the error/message reporter plugin
iReporterIteratorAn iterator to iterate over all messages in the reporter
iReporterListenerImplement this interface if you're interested in hearing about new messages on the reporter
iRigidBodyThis is the interface for a rigid body
iSaverThis interface is used to serialize the engine contents
iSaverFileThis interface represents a CS file to save to
iSaverPluginThis is a plugin to save with
CS::PluginCommon::SoftShader::iScanlineRendererSoftware renderer scanline renderer
CS::PluginCommon::SoftShader::iScanlineRenderer::RenderInfoMeshInformation for setting up rendering a mesh, filled by the scanline renderer
CS::PluginCommon::SoftShader::iScanlineRenderer::RenderInfoTriangleInformation for setting up rendering a triangle, filled by the scanline renderer
iSceneNodeThis interface represents a node in the scene graph
iSceneNodeArrayAn array of scene node interfaces
iSCFISCF is the interface that allows using SCF functions from shared classes
iScriptThis provides the interface to a scripting language interpreter
iScriptObjectThis provides the interface to an object in an object-oriented scripting language
iScriptValueThis 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
iSectorThe iSector interface is used to work with "sectors"
iSectorCallbackSet a callback which is called when this sector is traversed
iSectorIteratorAn iterator to iterate over sectors
iSectorListA list of sectors
iSectorMeshCallbackSet a callback which is called when a mesh is added or removed from this sector
iSelfDestructAn object implementing this interface can remove itself from its 'natural parent'
iSequenceA sequence of operations tagged with relative time information
iSequenceConditionA sequence condition
iSequenceManagerThe sequence manager
iSequenceOperationA sequence operation
iSequenceTimedOperationA timed operation for the engine sequence manager
iSequenceTriggerA sequence trigger
iSequenceWrapperA sequence wrapper
iShaderSpecific shader
iShaderCompilerCompiler of shaders
iShaderDestinationResolverInterface to allow resolution of friendly destination names
iShaderManagerA manager for all shaders
iShaderPriorityListA list of priorities as returned by iShaderCompiler->GetPriorities()
iShaderProgramA helper for shaders that which to use the general plugins
iShaderProgramPluginPlugins which provide iShaderProgram should implement this as a factory for iShaderProgram
iShaderVariableAccessorInterface to an accessorcallback for shadervariables
iShaderVariableContextThis is a baseclass for all interfaces which provides shadervariables both dynamically and static
iShadowBlockA block of shadows represent the shadows that are casted by one iShadowCaster object
iShadowBlockListThis is a list of shadow blocks
iShadowCasterAn object that can cast shadows
iShadowIteratorA shadow iterator allows someone to iterate over all shadows in a iShadowBlock or iShadowBlockList
iShadowReceiverAn object that is interested in getting shadow information
iSharedVariableISharedVariable implements a refcounted value which can be shared across many objects and updated efficiently
iSharedVariableListA list of shared variables
iSharedVariableListenerA listener so that you can get notified when a variable is changed
iSimpleFormerStateISimpleFormerState exposes implementation specific methods for the SimpleTerraformer plugin
iSkeletonThe skeleton interface provides needed functionality of a skeleton animation
iSkeletonAnimationThis interface provides animation of a skeleton
iSkeletonAnimationCallbackThis is a callback function of an animation
iSkeletonAnimationInstanceThis interface provides played animation instance of a skeleton
iSkeletonAnimationKeyFrameThe script key frame contains all bones that will be transformed in a specific time of a skeleton script
iSkeletonBoneThe skeleton bone class
iSkeletonBoneFactoryThe skeleton bone factory is class that is used to create skeleton bones of a iSkeleton object
iSkeletonBoneUpdateCallbackThis callback fires every time when bone changes it's transform
iSkeletonFactoryThe skeleton factory is class that is used to create skeleton objects in the scene
iSkeletonGraveyardISkeletonGraveyard is the interface that cares for all skeleton factories
iSkeletonSocketThe skeleton socket object wraps a relative transform of a bone
iSkeletonSocketFactoryThe skeleton socket factory is class that is used to create skeleton sockets of a iSkeleton object
iSkeletonUpdateCallbackThis is a callback function of a skeleton
iSndSysDataThe sound data is an interface to the container object controlling raw sound data
iSndSysEventRecorderAn interface designed for the debugging needs of the sound system
iSndSysListenerThe sound listener is a unique object created by the sound renderer
iSndSysLoaderThe sound loader is used to load sound files given a raw input data stream
iSndSysManagerThis is the sound manager for Crystal Space
iSndSysRendererCallbackSound System renderer interface for callback notification
iSndSysRendererSoftwareSoftware renderer specific interface extensions
iSndSysSoftwareDriverThis is the interface for the low-level, system-dependent sound driver that is used by the software sound renderer
iSndSysSoftwareFilter3DA sound filter is an interface to an object that modifies sequences of sound samples
iSndSysSoftwareOutputFilterTemporary filter interface definition
iSndSysStreamThe primary interface for a sound stream used by the audio system
iSndSysStreamCallbackSound System stream interface for callback notification
iSndSysWrapperA wrapper/holder for a loaded sound
CS::PluginCommon::SoftShader::iSoftShaderRenderInterfaceInterface specific to the software renderer to allow shaders to communicate with it
iSprite2DFactoryStateThis interface describes the API for the sprite factory mesh object
iSprite2DStateThis interface describes the API for the sprite factory mesh object
iSprite2DUVAnimationThe animation works by having all frames of an animation sequence in a texture at different (u,v) locations, hence the name
iSprite2DUVAnimationFrameThis is a single frame in a UV animation
iSprite3DFactoryStateThis interface describes the API for the 3D sprite factory mesh object
iSprite3DStateThis interface describes the API for the 3D sprite mesh object
iSpriteActionAn action frameset for 3D sprite animation
iSpriteCal3DFactoryStateThis interface describes the API for the 3D sprite factory mesh object
iSpriteCal3DSocketA socket for specifying where sprites can plug into other sprites
iSpriteCal3DStateThis interface describes the API for changing the Cal3D sprite mesh object's animations playing and other current traits
iSpriteFrameA frame for 3D sprite animation
iSpriteSocketA socket for specifying where sprites can plug into other sprites
CS::Meta::IsReference< Type >Check if Type is a reference or simple type
CS::Meta::Implementation::IsReferenceImpl< T >
CS::Meta::IsSame< Type1, Type2 >Check if two types are the same
CS::Meta::Implementation::IsSameImpl< T, U >
iStandardReporterListenerInterface to control the settings of the reporter listener plugin
iStreamDataCallbackThis callback will be fired when the data is ready
iStreamSourceThis interface represents a stream source
iStringThis is a SCF-compatible interface for csString
iStringArrayThis is an SCF-compatible interface for csStringArray
iStringSetThe string set is a collection of unique strings
iSuperLightmapA super light map
iSyntaxServiceThis component provides services for other loaders to easily parse properties of standard CS world syntax
iTerraFormerTerraFormer objects are used to retrieve terrain data
iTerrainCellTerrain cell class
iTerrainCellCollisionPropertiesThis is a base class for per-cell collider-specific properties
iTerrainCellFeederPropertiesThis is a base class for per-cell feeder-specific properties
iTerrainCellHeightDataCallbackCallbacks for cell height data modifications
iTerrainCellLoadCallbackCallbacks for cell load/unload events
iTerrainCellRenderPropertiesThis is a base class for per-cell renderer-specific properties
iTerrainColliderProvides an interface for custom collision
iTerrainCollisionPairArrayClass for an array of csCollisionPair. Used for communication with plugins
iTerrainDataFeederProvides an interface for reading cell data
iTerrainFactoryProvides an interface for creating terrain system
iTerrainFactoryCellFactory representation of a cell
iTerrainFactoryStateAllows the setting of a set of generic terrain parameters outside any specific algorithm
iTerrainObjectStateThis will override the settings for material in the parent
iTerrainRendererProvides an interface for custom rendering
iTerrainSystemThis class represents the terrain object as a set of cells
iTerrainVector3ArrayClass for an array of csVector3. Used for communication with plugins
iTerraSamplerTerraSampler objects are used for the actual queries of terrain data Sampler regions are requested from the iTerraFormer plugin, and sampled for data via the Sample methods
iTextureCallbackA callback for when a iTextureWrapper is used
iTextureFactoryInterface to a texture factory
iTextureHandleA texture handle as returned by iTextureManager
iTextureListThis class represents a list of texture wrappers
iTextureLoaderContextInterface passed to a texture loader, holding some common texture properties
iTextureManagerThis is the standard texture manager interface
iTextureTypeTexture type
iTextureWrapperA texture wrapper is an engine-level object that wraps around an actual texture (iTextureHandle)
iThingEnvironmentThis interface is implemented by the iObjectType for things
iThingFactoryStateThis is the state interface to access the internals of a thing mesh factory
iThingStateThis is the state interface to access the internals of a thing mesh object
iTimerEventA timer event
iTranslatorTranslator interface
iTriangleMeshThis interface reprents a mesh of triangles
iTriangleMeshIteratorIterator to iterate over all data mesh ID's in an object model
iUserRenderBufferIteratorInterface to iterate over all buffers stored in a csUserRenderBufferManager
iVerbosityManagerHelper interface which applications and plugins can use to determine whether they should be verbose
iVertexLightCalculatorInterface to calculate lighting for a number of vertices
iVFSThe Virtual Filesystem Class is intended to be the only way for Crystal Space engine to access the files
iViewEncapsulates the top-level Crystal Space renderer interface
iVirtualClockA virtual game clock
iVisibilityCullerThis interface represents a visibility culling system
iVisibilityCullerListenerImplement this interface when you want to get notified about visible objects detected by the visibility cullers
iVisibilityObjectAn object that wants to know if it is visible or not for some visibility culler needs to implement this interface
iVisibilityObjectIteratorIterator to iterate over some visibility objects
iWin32AssistantThis interface describes actions specific to the Windows platform
iWin32CanvasThis interface provides some extra functionality for Win32 canvases
iWxWindowInterface to communicate with with a wxWidgets-based canvas
CS::Memory::LocalBufferAllocator< T, N, ExcessAllocator >An allocator with a small local buffer
CS::MeasureTimeSimple helper class to measure execution time of a block
CS::Threading::MutexImpl< BaseMutex >General mutex class
CS::DocSystem::NodeAttributeCompareNode comparator
CS::DocSystem::NodeAttributeRegexpTestCheck if a regular expression matches(case-insensitive) with the value of the given attribute
CS::DocSystem::NodeAttributeValueTestCompare (case-sensitive) node attribute to given
CS::DocSystem::NodeNameCompareNode comparator
CS::DocSystem::NodeValueTestCompare (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::NoTypeBoolean false type
CS::NumberedFilenameHelperHelper to deal with numbered filename
CS::Math::Ode45Embedded Runge-Kutta 4/5th order ODE solver for non-stiff ODEs
CS::SndSys::PCMSampleConverterA PCMSampleConverter object converts PCM data from one format to another
CS::Utility::PriorityQueue< T, Container >An implementation of a priority queue
CS::SndSys::QEntry< T >
CS::SndSys::Queue< T >
CS::SndSys::QueueIterator< T >
CS::RenderBufferPersistentRender buffer wrapper with additional persistence information
CS::RenderViewClipperHelper to clip in the context of a render view
CS::Threading::RunnableAbstract base class for objects to be run in threads
CS::PluginCommon::SoftShader::ScanlineCompUndivided buffer values
CS::PluginCommon::SoftShader::ScanlineCompDivZBuffer values div Z
scfArray< IF, Backend >Implementation for iArrayReadOnly<>-, iArrayChangeElements<>- and iArrayChangeAll<>-derived interfaces, backed by a per-instance array
scfArrayWrap< IF, Backend >Implementation for iArrayReadOnly<>-, iArrayChangeElements<>- and iArrayChangeAll<>-derived interfaces, backed by a reference to another array
scfArrayWrapConst< IF, Backend >Implementation for iArrayReadOnly<>-derived interfaces, backed by a reference to another array
scfFakeInterface< If >Fugly helper to resolve some bad situations
scfFakeInterface< If >::InterfaceTraits
scfImplementation< Class >Baseclass for the SCF implementation templates
scfImplementation0< Class >
scfImplementation1< Class, I1 >
scfImplementation2< Class, I1, I2 >
scfImplementation3< Class, I1, I2, I3 >
scfImplementation4< Class, I1, I2, I3, I4 >
scfImplementation5< Class, I1, I2, I3, I4, I5 >
scfImplementation6< Class, I1, I2, I3, I4, I5, I6 >
scfImplementation7< Class, I1, I2, I3, I4, I5, I6, I7 >
scfImplementationExt0< Class, Super >
scfImplementationExt1< Class, Super, I1 >
scfImplementationExt2< Class, Super, I1, I2 >
scfImplementationExt3< Class, Super, I1, I2, I3 >
scfImplementationExt4< Class, Super, I1, I2, I3, I4 >
scfImplementationExt5< Class, Super, I1, I2, I3, I4, I5 >
scfImplementationExt6< Class, Super, I1, I2, I3, I4, I5, I6 >
scfImplementationExt7< Class, Super, I1, I2, I3, I4, I5, I6, I7 >
scfImplementationPooled< Super, Allocator >Derive an SCF implementation from this class to have it pooled
scfImplementationPooled< Super, Allocator >::Pool
scfInterfaceTraits< Interface >Interface information query class
scfStringThis is a thin SCF wrapper around csString
scfStringArrayThis 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::ShaderVariableContextImplSimple implementation for iShaderVariableContext
CS::ShaderVarNameHelper class to obtain an ID for a shader variable
CS::SndSys::SndSysBasicStream::StreamNotificationEventStructure containing the data for each notification event
CS::SndSys::SoundCyclicBufferAn implementation of a cyclic buffer oriented for sound functionality
CS::StructuredTextureFormatStructured representation of a texture format
CS::SubRectanglesA class managing allocations of sub-rectangles
CS::SubRectanglesCompactA variation of SubRectangles that tries to place rectangles in a rectangular fashion
CS::TextureFormatStringsTexture format string parser routines
CS::Threading::ThreadObject representing a separate execution thread
CS::Threading::ThreadGroupA group of threads handled as one unit
CS::Meta::Implementation::TraitAnd< b1, b2, b3, b4, b5, b6, b7 >
CS::Meta::Implementation::TraitAnd< true, true, true, true, true, true, true >
CS::TriangleIndicesStream< T >Helper class to extract triangles from an index buffer
CS::TriangleT< T >A templated triangle
CS::UberScreenshotMakerHelper to create "&uuml;berscreenshots", screenshots with a resolution larger than the current framebuffer resolution
CS::Utility::WeakReferencedThis is a class which provides basic weak reference-counting semantics
CS::Meta::Implementation::Wrap< T >Simple dummy-wrapper

Generated for Crystal Space 1.2.1 by doxygen 1.5.3