CrystalSpace

Public API Reference

Class List

Here are the classes, structs, unions and interfaces with brief descriptions:
_csKeyModifiersFlags for all currently pressed modifiers
CS::Math::Noise::Module::AbsNoise module that outputs the absolute value of the output value from a source module
CS::Math::Noise::Module::AddNoise module that outputs the sum of the two output values from two source modules
CS::Utility::Checksum::Adler32Compute Adler-32 checksum for some data
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::AllocatorImplementation< Allocator >IAllocator implementation, wrapping arbitrary allocator
CS::Memory::AllocatorInterfaceMemory allocator forwarding to an iAllocator implementation
CS::Memory::AllocatorMallocA default memory allocator that allocates with cs_malloc()
CS::Memory::AllocatorMallocPlatformMemory 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::Memory::AllocatorRef< OtherAllocator >Memory allocator forwarding to another allocator
CS::Memory::AllocatorSafe< Allocator >Threadsafe allocator wrapper
CS::Graphics::AlphaTestOptionsAlpha test options
CS::Mesh::AnimatedMeshBoneInfluenceRepresent a single influence of a bone on a single vertex
CS::Animation::AnimatedMeshStateHolds the state of an animesh skeleton for a frame, ie the position and rotation of each bone of the skeleton
CS::Mesh::AnimatedMeshToolsHelper class to generate new CS::Mesh::iAnimatedMesh's
CS::Animation::AnimNodeManagerCommon< ThisType, ManagerInterface, FactoryType >Template class for animation node plugin managers
CS::WX::AppArgConvertHelper to convert wxApp command line arguments into CS' encoding
CS::Threading::AtomicOperationsBase< Impl >Define low-level atomic operations
CS::Utility::AtomicRefCountThis is a class which provides basic atomic reference-counting semantics
CS::Threading::BarrierBarrier synchronization class
CS::Utility::BaseModifiableDescriptionBasic implementation of CS::Utility::iModifiableDescription, suitable for most uses
CS::Utility::BaseModifiableParameterImplementation of some of the most common CS::Utility::iModifiableParameter usage
CS::Engine::BaseMovableA base movable implementation
CS::RenderManager::BeginFinishDrawScopeScope wrapper for setting BeginDraw flags and calling FinishDraw on scope end
CS::Geometry::BIH< ChildType >A Bounding Intervall Hierachy (BIH)
CS::Math::Noise::Module::BillowNoise module that outputs three-dimensional "billowy" noise
CS::Math::Noise::Module::BlendNoise module that outputs a weighted blend of the output values from two source modules given the output value supplied by a control module
CS::Memory::BlockAllocatorSafe< T, Allocator, ObjectDispose, SizeComputer >Thread-safe allocator for objects of a class
CS::Animation::BoneMappingThis class holds the mapping between the bones of a source and a target skeleton
CS::Geometry::BoxA box
CS::Geometry::BVH< ChildType >A Bounding Volume Hierachy (BVH)
CS::Animation::BVHMocapParserTool for parsing BVH (BioVision Hierarchical data) motion capture resource files
CS::Math::Noise::Module::CacheNoise module that caches the last output value generated by a source module
CS::RenderManager::ShadowNone< RenderTree, LayerConfigType >::CachedLightDataShadowing-specific data persistently stored for every light
CS::RenderManager::LightSetup< RenderTree, LayerConfigType, ShadowHandler >::CachedLightDataData persistently stored for every light
CS::Platform::Win32::CacheDLLSmall helper to avoid repeated loading/unloading of DLLs loaded at runtime
CS::Debug::CallStackConvenience wrapper around csCallStack and csCallStackHelper
CS::RenderManager::CameraCacheHelper class to cache clones of cameras
CS::PluginCommon::CanvasCommonBaseThis is the base class for graphics canvases
CS::PluginCommon::GL::CanvasCommonBaseBasic OpenGL version of the graphics canvas class
CS::Geometry::CapsuleA capsule
CS::Math::Noise::Module::CheckerboardNoise module that outputs a checkerboard pattern
CS::Math::Noise::Module::ClampNoise module that clamps the output value from a source module to a range of values
CS::PluginCommon::ShaderProgramPluginGL::ClipPlanesHelper class for user defined OpenGL clip planes
CS::Collisions::CollisionHelperA class to help managing the colliders and physical models of the meshes and scenes
csAnsiParser::CommandParamsParameters to ANSI command
CS::Threading::ConditionCondition variable
CS::Geometry::ConeA Cone
CS::RenderManager::HDR::Exposure::ConfigurableExposure controller wrapping other exposure controllers, allowing the choice of exposure through the configuration system
CS::Math::Noise::Module::ConstNoise module that outputs a constant value
CS::Container::WeakKeyedHash< T, K, ArrayMemoryAlloc, ArrayElementHandler >::ConstGlobalIteratorAn iterator class for WeakKeyedHash
csHash< T, K, ArrayMemoryAlloc, ArrayElementHandler >::ConstGlobalIteratorAn const iterator class for the csHash class
csArray< T, ElementHandler, MemoryAllocator, CapacityHandler >::ConstIteratorIterator for the csArray class
csHash< T, K, ArrayMemoryAlloc, ArrayElementHandler >::ConstIteratorAn const iterator class for the csHash class
csRedBlackTree< K, Allocator, Ordering >::ConstIteratorConst iterator for tree
csRedBlackTreeMap< K, T, Allocator, Ordering >::ConstIteratorConst iterator for map
csRedBlackTree< K, Allocator, Ordering >::ConstReverseIteratorConst reverse iterator for tree
csRedBlackTreeMap< K, T, Allocator, Ordering >::ConstReverseIteratorConst reverse iterator for map
CS::Utility::ImportKit::ContainerContains multiple models
CS::RenderManager::RenderTree< TreeTraits >::ContextNodeA single context node, Groups meshes which should be rendered from the same view to the same target
CS::RenderManager::RenderTreeStandardTraits::ContextNodeExtraDataTypeAny extra data that should be defined for each context node
CS::RenderManager::StandardPortalSetup< RenderTreeType, ContextSetup >::ContextSetupDataData that needs to be passed between portal setup steps by the context setup function
CS::RenderManager::ContextTargetSetup< ContextType >Scope wrapper for setting render target from context settings
CS::Math::Noise::Module::ControlPointThis structure defines a control point
CS::Graphics::CoreRenderMeshData required by the renderer to draw a mesh
CS::CowWrapper< T, MemoryAllocator >Copy-on-write wrapper for arbitrary types
CS::Utility::Checksum::CRC32Compute CRC32 checksum for some data
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
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
csArrayCapacityFixedGrow< N >Shortcut for an array capacity handler with a compile-time fixed rate of growth
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
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
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
csBlockAllocator< T, Allocator, ObjectDispose, SizeComputer >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
csBoxClipperAble to clip convex polygons to a rectangle (such as the screen)
CS::RenderManager::StandardPortalSetup_Base::PersistentData::csBoxClipperCachedCache-helper for box clipper caching
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 print the commandline help, eg when the '-help' option has been used
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()
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()
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
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
csDirectXErrorObtain symbols and descriptions for DirectX error codes
csDirtyAccessArray< T, ElementHandler, MemoryAllocator, CapacityHandler >A templated array class
csDirtyAccessArrayRefCounted< T, ElementHandler, MemoryAllocator, CapacityHandler >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
csDualQuaternionDual 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]
csDVector3A 3D vector
CS::Geometry::csEarClipperStructure for clipping polygon ears
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 csEventID's (which, in non-debug builds, are really just csStringID's)
csEventOutletA class which implements the iEventOutlet interface
csEventQueueThis class represents a general event queue
csEventTimerThis class implements a timer
csEventTreeThis class is used to represent the event namespace (tree)
csFIFO< T, ElementHandler, MemoryAllocator, CapacityHandler >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
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
csFrameDataHolder< T >Helper template to retrieve an instance of some type that has not yet been used in a frame
csFrustumA general frustum
csGetFromAddressSized data type access helpers
csGLDriverDatabaseOpenGL driver database
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, 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< T * >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
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
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, MemoryAllocator >A lightweight double-linked list template
csLittleEndianLittle endian to native conversion routines
csLoaderReturnReturn structure for threaded loader functions
csLoadResultReturn structure for the iLoader::Load() routines
csLockedHeightDataLocked height data
csLockedMaterialMapLocked material data
csLockedNormalDataLocked normal data
csMapNodeA node
csMath2Various functions in 2D, such as 2D vector functions
csMath3Various assorted 3D mathematical functions
csMatrix2A 2x2 matrix
csMatrix3A 3x3 matrix
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
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
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
csOptionDescriptionDescription of a configuration option, to be used by the iPluginConfig interfaces
csOrthoTransformA class which defines a reversible transformation from one coordinate system to another by maintaining an inverse transformation matrix
csOSXAutoGCHelper class to allocate an NSAutoreleasePool at the point of delcaration and release it automatically at the end of the block in which it is declared
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
csParticleData representation of a single particle
csParticleAuxAuxiliary data per particle, not used as often
csParticleBufferBuffer holder for particle buffers
csParticleParameterSetParameters that can be modified based on age for the linear effector (iParticleBuiltinEffectorLinear)
csPathA path in 3D
csPathsListClass to manage a list of paths
csPathsUtilitiesA helper class with path-related utilities
csPDelArray< T, MemoryAllocator, CapacityHandler >An array of pointers
csPenA pen implementation with which you can do various kinds of 2D rendering
csPen3DA pen implementation with which you can do various kinds of 3D line rendering
csPen3DCoordinatePairA coordinate pair
csPenCacheA pen cache
csPenCoordinateA pen coordinate
csPenCoordinatePairA coordinate pair
csPhysicalFileAn implementation of the abstract iFile interface for real files within the physical filesystem
csPixelCoordSimple 2D pixel coordinate
csPixmapThis class is an simple set of inline routines good as an abstraction for simple 2D sprites
csPlane2A plane in 2D space
csPlane3A plane in 3D space
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
csPluginReferenceAn object representing a reference to a library
csPluginRequestThis class represents a single plugin request for csInitializer::RequestPlugins()
csPointLightProc< AttenuationProc >Preform pointlight lighting calculation without shadowing
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
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
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, Allocator, Ordering >A red-black-tree
csRedBlackTreeMap< K, T, Allocator, Ordering >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, CapacityHandler >An array of smart pointers
csRefArrayObject< T, Allocator, CapacityHandler >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
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
csRenderMeshHolderHelper class to retrieve an unused csRenderMesh
csRenderMeshListThis class is used when we need to store, sort and then render a list of rendermeshes
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
csSafeCopyArray< T, Allocator, CapacityHandler >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
csScheduleEasy way to get timers in applications
csScreenBoxResultReturn structure for iMeshWrapper::GetScreenBoundingBox()
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() and iSector::HitBeamPortals() routines
csSectorVisibleRenderMeshesContainer for render meshes for one mesh wrapper
csSegment2A 2D line segment
csSegment3A 3D line segment
csSet< T, Allocator >This class implements a basic set for objects
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
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
csShaderVariableStackA "shader variable stack"
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
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
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
csStringHashReversibleA csStringHash providing a reverse hash for fast string lookups when given an ID
csStringReaderThis is a convenience class that reads an input buffer line by line
csSwapBytesMethods to unconditionally swap the byte order of specifically sized types
csTerrainColliderCollideSegmentResultReturn structure for the iTerrainCollider::CollideSegment(iTerrainCell*, const csVector3&, const csVector3&) routine
csTestRectDataA structure used by csTiledCoverageBuffer::TestRectangle() and initialized by csTiledCoverageBuffer::PrepareTestRectangle()
csTextProgressMeterDisplays a simple percentage-style textual progress meter
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
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, ie a value whose type 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
csViewDefault implementation of a iView
csVirtualClockThis is an implementation of a virtual clock
csWeakRef< T >A weak reference
csWeakRefArray< T, Allocator, CapacityHandler >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
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
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::Math::Noise::Module::CurveNoise module that maps the output value from a source module onto an arbitrary function curve
CS::Memory::CustomAllocatedClass that overrides operator new/operator delete/etc
CS::Memory::CustomAllocatedDerived< T >Class that overrides operator new/operator delete/etc
CS::Math::Noise::Model::CylinderModel that defines the surface of a cylinder
CS::Math::Noise::Module::CylindersNoise module that outputs concentric cylinders
CS::DataBuffer< Allocator >This is an implementation of iDataBuffer interface
csFixedSizeAllocator< Size, Allocator >::DefaultDisposerDefault disposer mixin, just reporting leaks
CS::Container::DefaultRedBlackTreeAllocator< K >Default allocator for red black trees
CS::Utility::DemoApplicationCrystal Space demo application framework class
CS::Geometry::DensityTextureMapperDensity based texture mapper
CS::RenderManager::DependentTargetManager< RenderTree, TargetHandler >Dependent target manager
CS::Utility::Checksum::Digest< Size >Message digest data with a size of Size bytes
CS::Utility::Checksum::DigestFormatHelper class to provide Digest<> formatting methods
CS::Math::Noise::Module::DisplaceNoise module that uses three source modules to displace each coordinate of the input value before returning the output value from a source module
CS::Meta::EBOptHelper< T >Helper class for inheriting from a type thats potentially void
csPathsList::EntryThis structure contains information about a plugin path
CS::EqualComparator< T >A template providing equality comparison
csBaseEventHandler::EventHandlerImplActual iEventHandler implementation
CS::Math::Noise::Module::ExponentNoise module that maps the output value from a source module onto an exponential curve
CS::Utility::FastRefCount< ActualClass >This is a class which provides basic reference-counting semantics
CS::Platform::FileFunctions to abstract platform-specific file access
CS::DocSystem::Implementation::FilterDocumentNodeIterator< T >Filtering iDocumentNodeIterator
CS::Memory::FixedSizeAllocatorSafe< Size, Allocator >Thread-safe allocator for blocks of the same size
CS::Utility::Implementation::FixedSizeBestChoiceLRU< Size >Helper for FixedSizeBestChoiceLRUPolicy
CS::Utility::Implementation::FixedSizeBestChoiceLRU< 1 >Helper for FixedSizeBestChoiceLRUPolicy
CS::Utility::Implementation::FixedSizeBestChoiceLRU< 2 >Helper for FixedSizeBestChoiceLRUPolicy
CS::Utility::FixedSizeBestChoiceLRUPolicyLRU policy deciding between array LRU and pseudo-LRU based on set size
CS::Utility::FixedSizeCache< K, T, CacheSize, Associativity, LRUPolicy, HashFold >Templated fixed size cache class
CS::Utility::Implementation::FixedSizeCacheElement< K, T >Represent one element in the cache with key and data
CS::Utility::Implementation::FixedSizeCacheSet< K, T, SetSize, LRUPolicy >One set in an associative cache
CS::Utility::Implementation::FixedSizeLRU< Size >LRU implemented as a fixed size array storing the indices in order of reference
CS::Utility::Implementation::FixedSizeLRU< 1 >Specialized LRU for one item sets
CS::Utility::Implementation::FixedSizeLRU< 2 >Specialized LRU for two item sets
CS::Utility::FixedSizeLRUPolicyLRU policy using an array based fixed-size LRU
CS::Utility::Implementation::FixedSizePseudoLRU< Size >LRU policy using the tree/pseudo-LRU algorithm for general power-of-two sized sets
CS::Utility::Implementation::FixedSizePseudoLRU< 4 >Specialized pseudo-LRU for set size 4
CS::Utility::Implementation::FixedSizePseudoLRU< 8 >Specialized pseudo-LRU for set size 8
CS::Utility::FixedSizePseudoLRUPolicyLRU policy using bit-tree base pseudo-LRU
csFontCache::FontDeleteNotifyFont deletion callback
FrameBegin3DDrawFrameBegin3DDraw handles every csevFrame event in the 3D phase
CS::RenderManager::AutoFX::FramebufferTex< RenderTree >Render manager helper for automatic framebuffer content textures
CS::RenderManager::AutoFX::FramebufferTex_BaseBase class for FramebufferTex, containing types and members which are independent of the template arguments that can be provided to FramebufferTex
FramePrinterFramePrinter handles every csevFrame event in the FRAME (final) phase
CS::Geometry::GeneralMeshBuilderTools related to creating genmesh instances and factories
CS::Utility::GenericResourceCache< T, _TimeType, _ResourceSorting, _ReuseCondition, _PurgeCondition >Generic cache for resources
getopt_optionDescribe the long-named options requested by the application
CS::GLExtensionFlagsStruct containing all GL extension test flags
CS::GLExtensionFunctionsStruct containing all GL extension functions
CS::GLExtensionManagerGL extensions manager
csSet< T, Allocator >::GlobalIteratorAn iterator class for the set
CS::Container::WeakKeyedHash< T, K, ArrayMemoryAlloc, ArrayElementHandler >::GlobalIteratorAn iterator class for WeakKeyedHash
csHash< T, K, ArrayMemoryAlloc, ArrayElementHandler >::GlobalIteratorAn iterator class for the csHash class
CS::GLXExtensionFlagsStruct containing all GLX extension test flags
CS::GLXExtensionFunctionsStruct containing all GLX extension functions
CS::GLXExtensionManagerGLX extensions manager
csFontCache::GlyphCacheDataSome basic data associated with a glyph
CS::Utility::GraphEdgeRepresent an edge in a graph
CS::PluginCommon::Graphics2DCommonThis is the base class for iGraphics2D implementations
CS::PluginCommon::GL::Graphics2DCommonBasic OpenGL version of the 2D driver class
CS::Container::HashElement< T, K >An element of a hash
CS::HashFunction< T >Unary function for computing a hash
CS::RenderManager::HDRHelperTo help setting up a post effects manager for HDR rendering
CS::RenderManager::HDRSettingsRead HDR settings from a config file
CS::Memory::HeapA separate heap from which memory can be allocated
CS::Memory::HeapAccessPointer< HeapContainer >Heap accessor for AllocatorHeapBase
CS::Physics::Bullet::HitBeamResultReturn structure for the CS::Physics::Bullet::iDynamicSystem::HitBeam() routine
CS::Collisions::HitBeamResultA structure used to return the result of hit beam
iAddonReferenceThis interface represents a reference to an addon
CS::Network::Socket::iAddressAn endpoint to be used with an iSocket connection
CS::Memory::iAllocatorAllocator interface
CS::Physics::Bullet::iAnchorAnimationControlThis class can be implemented in order to update the position of an anchor of a CS::Physics::Bullet::iSoftBody
CS::Physics::iAnchorAnimationControlThis class can be implemented in order to update the position of an anchor of a CS::Physics::iSoftBody
iAnimatedImageIf an image file has animation capabilities, then this interface is exhibited
CS::Mesh::iAnimatedMeshState and setting for an instance of an animated mesh
CS::Mesh::iAnimatedMeshFactoryState of an animated mesh object factory
CS::Mesh::iAnimatedMeshMorphTargetA morph target
CS::Mesh::iAnimatedMeshSocketSockets attached to animated meshes
CS::Mesh::iAnimatedMeshSocketFactoryFactory for sockets attached to iAnimatedMesh's
CS::Mesh::iAnimatedMeshSubMeshSub mesh (part) of an animated mesh
CS::Mesh::iAnimatedMeshSubMeshFactorySub mesh (part) of an animated mesh factory
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
iBinaryLoaderPluginThis is a binary plugin for the loader
iBinarySaverPluginThis is a binary plugin to save with
iBlobA blob
iBlobImageA blob image
iBlobManagerThe blob manager
iBlobViewPortA blob viewport
CS::Physics::Bullet::iBodyA generic body in Bullet's dynamic simulation
CS::Animation::iBodyBoneA body bone holds the physical description of the bone of an CS::Mesh::iAnimatedMesh
CS::Animation::iBodyBoneColliderThese are the properties of the collider associated to a bone
CS::Animation::iBodyBoneJointThese are the properties of the joint associated to a bone
CS::Animation::iBodyBonePropertiesThese are the main properties of a bone's rigid body
CS::Animation::iBodyChainA body chain is a subtree of the skeleton of an CS::Mesh::iAnimatedMesh
CS::Animation::iBodyChainIteratorThis iterator is returned by iBodySkeleton->GetBodyChains()
CS::Animation::iBodyChainNodeA node in a body chain tree
iBodyGroupBody Group is a collection of bodies which don't collide with each other
CS::Animation::iBodyManagerA class to manage the creation and deletion of bodies' skeletons
CS::Animation::iBodySkeletonThis class holds the physical description of the skeleton of an CS::Mesh::iAnimatedMesh
CS::Animation::iBoneIDIteratorThis iterator is returned by iBodySkeleton->GetBodyBones()
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
iCameraListenerImplement this interface if you are interested in learning when the camera changes sector or moves
CS::Utility::iCameraManagerA generic tool to control the motion of the camera through the keyboard and/or the mouse
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
iColladaConvertorRepresentation of a convertor from COLLADA files to Crystal Space files
iCollectionA 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
iCollectionArrayUsed for a readonly array of csRef<iCollection>
iColliderA mesh collider
CS::Collisions::iColliderA base interface for colliders
CS::Collisions::iColliderBoxA box collider
CS::Collisions::iColliderCapsuleA capsule collider
CS::Collisions::iColliderConcaveMeshA static concave mesh collider
CS::Collisions::iColliderConcaveMeshScaledA scaled static concave mesh collider
CS::Collisions::iColliderConeA cone collider
CS::Collisions::iColliderConvexMeshA convex mesh collider
CS::Collisions::iColliderCylinderA cylinder collider
CS::Collisions::iColliderPlaneA static plane collider
CS::Collisions::iColliderSphereA sphere collider
CS::Collisions::iColliderTerrainCellA terrain cell collider, part of a iCollisionTerrain
iCollideSystemThis is the Collide plug-in
CS::Collisions::iCollisionActorA iCollisionActor is dedicated to actor motion controlling, and can be used to manage eg a Player or a Non-Player Character object
CS::Collisions::iCollisionActorFactoryA iCollisionActor is dedicated to actor motion controlling, and can be used to manage eg a Player or a Non-Player Character object
CS::Collisions::iCollisionCallbackThis is the interface for attaching a collision callback to a collision object
CS::Collisions::iCollisionContactA structure used to describe a collision contact between two objects
CS::Collisions::iCollisionDataA structure used to return the collision data between two objects
CS::Collisions::iCollisionDataListA list of CS::Collisions::iCollisionData
CS::Collisions::iCollisionGroupCollision groups allow to filter the collisions occuring between the objects in the system
CS::Collisions::iCollisionObjectThis is the interface of a collision object
CS::Collisions::iCollisionObjectFactoryFactory to create instances of iCollisionObject
CS::Collisions::iCollisionSectorThis is the interface for the collision sector
CS::Collisions::iCollisionSystemThis is the Collision plug-in
CS::Collisions::iCollisionTerrainA collision terrain is associated with a iTerrainSystem mesh, and consists of multiple cell colliders (CS::Collisions::iColliderTerrainCell objects)
CS::Collisions::iCollisionTerrainFactoryFactory to create instances of iCollisionTerrain
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
iConfigListenerConfiguration listener interface
iConfigManagerThe configuration manager is used to make a number of iConfigFile object appear like a single object
iConfigNotifierConfiguration notifier interface
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
CS::Platform::Win32::IconToolsHelpers for dealing with Windows icons
CS::Collisions::iConvexDecomposerPerforms a convex decomposition on a concave mesh
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
iCustomMatrixCameraAn implementation of iCamera that renders a world with a custom projection matrix
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 iDecalManager
iDecalAnimationControlA decal animation control, to be used by the iMeshObject when the vertices of the decal have to be animated
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 iDecal
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
CS::DocSystem::iDocumentPreprocessorInterface to document preprocessor plugin
iDocumentSystemAn iDocument factory
iDynamicsThis is the interface for the actual plugin
iDynamicsColliderCollisionCallbackThis is the interface for attaching a collision callback to a collider
iDynamicsCollisionCallbackThis is the interface for attaching a collider callback to the body
CS::Debug::iDynamicsDebuggerManagerCreation of dynamic system debuggers
iDynamicsMoveCallbackThis is the interface for a dynamics move callback
iDynamicsStepCallbackThis is the interface for a dynamics step callback, eg when a step is performed in the simulation
iDynamicsSystemColliderThis is the interface for a dynamics system collider
CS::Physics::Bullet::iDynamicSystemThe Bullet implementation of iDynamicSystem also implements this interface
iDynamicSystemThis is the interface for the dynamics core
CS::Debug::iDynamicSystemDebuggerA class to help visualization and debugging of physical simulations made through the iDynamicSystem plugin
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
CS::Network::EventManager::iEventCallbackCallback class to derive from if you want to receive notifications about various happening during operation of the event manager
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
CS::Network::EventManager::iEventManagerInterface to the network event manager
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
CS::Animation::iFurAnimatedMeshControlAnimation controller for animated mesh
CS::Animation::iFurAnimationControlSimple Animation Controller
CS::Mesh::iFurMeshState and setting for an instance of a fur mesh
CS::Mesh::iFurMeshFactoryState of a fur mesh object factory
CS::Mesh::iFurMeshMaterialPropertiesStore the material used for the iFurMesh
CS::Mesh::iFurMeshStateAccess to the properties used for the iFurMesh
CS::Mesh::iFurMeshTypeThis plugin describes a specific type of fur mesh objects
CS::Animation::iFurPhysicsControlController that updates the iFurMesh's geometry
iGeneralFactoryStateThis interface describes the API for the general mesh factory
iGeneralFactorySubMeshA submesh of a genmesh factory
iGeneralFactorySubMeshObjectAn instance of a submesh of a genmesh factory
iGeneralMeshCommonStateThe common interface between genmesh meshes and factories
iGeneralMeshStateThis interface describes the API for the general mesh object
iGeneralMeshSubMeshA submesh of a genmesh
iGenMeshAnimationControlImplementing this class allows to control the animation of the vertex, texel, normal, color and bounding box data of the genmesh
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
iGeomA piece of geometry
iGradientA simple color gradient
iGradientShadesAn array of gradient shades
iGraphics2DThis is the interface for 2D renderer
iGraphics3DThis is the standard 3D graphics interface
iGraphicsCanvasThis is the interface for the graphics canvas
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
iHierarchicalCacheA generic, hierarchical cache system
CS::Utility::iHUDManagerA generic tool managing the display of a minimal text-based HUD, eg for applications implementing CS::Utility::DemoApplication or providing a user interface through the keyboard
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
iImageModifierAn image modifier
iImposterFactoryIImposterFactory defines the interface a mesh factory must implement for its meshes to be used as imposters by the engine
iInputBinderSCF interface for csInputBinder, used to bind input events (keypress, button press, mouse move, etc
iJobA unit of work passed to iJobQueue
iJobQueueInterface to simple job management system
iJointA joint that can constrain the relative motion between two iRigidBody
CS::Physics::iJointA joint that can constrain the relative motion between two iPhysicalBody
CS::Physics::iJointFactoryA joint that can constrain the relative motion between two iPhysicalBody
iJoystickDriverGeneric Joystick driver
iKeyboardDriverGeneric Keyboard Driver
iKeyComposerKeyboard input handler
iKeyValuePairA Key Value pair
CS::Physics::Bullet::iKinematicCallbackA callback to be implemented when you are using kinematic bodies
CS::Physics::iKinematicCallbackA callback to be implemented when you are using kinematic bodies
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
iLightFactoryA light factory
iLightFactoryListA list of light factories
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
iLightningFactoryState
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
iLODControlThe iLODControl interface represents an object that has controllable Level Of Detail (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
iMaterialArrayAn array of materials
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)
CS::Media::iMediaBase of media streams
CS::Media::iMediaContainerContainer for the different streams inside a video file
CS::Media::iMediaLoaderThe media loader is used to load and initialize a iMediaContainer
CS::Media::iMediaPlayerThe media player can be used to play a media
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)
iMeshFactoryWrapperIteratorThis is an iterator mesh factory wrappers
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 of 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
CS::Utility::iModifiableThis interface is to be implemented by all objects willing to be modified automatically
CS::Utility::iModifiableConstraintA constraint allows to limit the range of values that a parameter of a CS::Utility::iMovable can take
CS::Utility::iModifiableConstraintBoundedA bounded constraint forces the value of a parameter to either stay under a certain value, over a certain value, or between two values
CS::Utility::iModifiableConstraintEnumAn enum constraint defines a list of values that a parameter can take
iModifiableDataFeederModifiable Terrain data feederclass
CS::Utility::iModifiableDescriptionThe description of an CS::Utility::iModifiable object
CS::Utility::iModifiableListenerListener for the notification of the state changes of a CS::Utility::iModifiable
CS::Utility::iModifiableParameterDescription of a specific parameter of a CS::Utility::iMovable
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 (ie where it is in the world))
iMovableListenerImplement this class if you're interested in hearing about movable changes
iMovieRecorderUsing this interface you can communicate with the MovieRecorder plugin and programmatically start, pause and stop the recorder
iMovingObjectA moving object
CS::Utility::ImportKitCrystal Space Import Kit
iNativeWindowThis interface represents a native window
iNativeWindowManagerThis interface represents the native window manager system
iNovaHaloThis is a halo which resembles a nova
CS::Utility::InternalRefCountThis class is used to hold a reference count seperate to the normal one
iNullFactoryStateThis interface describes the API for the null mesh object factory
iNullMeshStateThis interface describes the API for the null mesh object
CS::InvalidStringID< Tag >An invalid csStringID
CS::Container::InvasiveList< Tag >"Invasive" double-linked list
CS::Math::Noise::Module::InvertNoise module that inverts the output value from a source module
iObjectThis interface is an SCF interface for encapsulating csObject
iObjectCommentThis interface represents a comment that is associated with an object in XML
CS::Geometry::SpatialTree< Self, ChildType >::iObjectDescriptorIf you implement this interface then you can give that to the KDtree
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 iDynamicsSystem
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
iOpenGLCanvasInterface for OpenGL-specific canvas functionality
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
iParticleBuiltinEffectorLightThis effector will create and attach a iLight to each particle of the system
iParticleBuiltinEffectorLinColorSimple linear interpolation of particle color based on particle lifetime
iParticleBuiltinEffectorLinearLinear interpolation of various parameters based on particle lifetime
iParticleBuiltinEffectorPhysicalPhysical forces and collisions applied to particles
iParticleBuiltinEffectorVelocityFieldVelocity field effector
iParticleBuiltinEmitterBaseBase interface for the emitters already built-in
iParticleBuiltinEmitterBoxAn emitter spawning the new particles around a box geometry
iParticleBuiltinEmitterConeAn emitter spawning the new particles around a cone geometry
iParticleBuiltinEmitterCylinderAn emitter spawning the new particles around a cylinder geometry
iParticleBuiltinEmitterFactoryFactory for built-in emitters
iParticleBuiltinEmitterSphereAn emitter spawning the new particles around a sphere geometry
iParticleEffectorBase interface for particle effectors
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
iPerspectiveCameraAn implementation of iCamera that renders a world with a classical perspective
CS::Physics::iPhysicalBodyA base interface of physical bodies
CS::Physics::iPhysicalObjectFactoryCollection of all properties of a physical object
CS::Physics::iPhysicalSectorThis is the interface for the physical sector
CS::Physics::iPhysicalSystemThis is the interface for the actual plugin
CS::Physics::Bullet::iPivotJointA joint to attach to a rigid body in order to manipulate it
iPluginConfigInterface to a configurator object
iPluginIteratorAn iterator to iterate over all plugins in the plugin manager
iPluginManagerThis is the plugin manager
iPluginReferenceThis interface represents a reference to a plugin
iPortalThis is the interface to the Portal objects
iPortalCallbackWhen a sector is missing this callback will be called
iPortalContainerA container for portals
CS::RenderManager::iPostEffectInterface for post processing effects
CS::RenderManager::iPostEffectManagerFactory for post-effects
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
iRenderBufferThis is a general buffer
iRenderBufferAccessorInterface for renderbuffer accessor
iRenderBufferCallbackCallback function used upon destruction of render buffer
iRenderBufferPersistenceRender buffer persistence information
iRenderManagerCommon render manager interface
iRenderManagerPostEffectsInterface to add post-effects layers
iRenderManagerTargetsInterface for automatic view-to-texture rendering
iRenderManagerVisCullInterface for render managers which implement a visibility culler
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
CS::Physics::Bullet::iRigidBodyThe Bullet implementation of iRigidBody also implements this interface
iRigidBodyThis is the interface for a rigid body
CS::Physics::iRigidBodyThis is the interface for a rigid body
CS::Physics::iRigidBodyFactoryCollection of all properties of 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::Meta::IsBaseOf< Type1, Type2 >Check if Type1 is a base of Type2
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
iShaderPassesActivatorInterface to perform shader pass activation
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
iShaderVarStringSetString set for shader variable names
iSharedVariableThis class 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
CS::Animation::iSkeletonA skeleton instance defines the state of a CS::Mesh::iAnimatedMesh
CS::Animation::iSkeletonAnimationData structure for raw skeletal animations
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
CS::Animation::iSkeletonAnimationNodeRaw animation node
CS::Animation::iSkeletonAnimationNodeFactoryFactory for raw animation nodes
CS::Animation::iSkeletonAnimCallbackA callback to be implemented if you want to be notified when the state of an animation or animation tree is changed
CS::Animation::iSkeletonAnimNodeBase type for the animation nodes in the hierarchical blending tree of the skeletal animation system
CS::Animation::iSkeletonAnimNodeFactoryBase type for nodes in the hierarchical blending tree factory of the skeletal animation system
CS::Animation::iSkeletonAnimNodeManager< FactoryInterface >Template for an animation node manager
CS::Animation::iSkeletonAnimPacketAn animation packet instance
CS::Animation::iSkeletonAnimPacketFactoryDefines a factory for a skeletal animation packet (iSkeletonAnimPacket)
CS::Animation::iSkeletonBlendNodeAn animation node that blends together the sub-nodes based on their weights
CS::Animation::iSkeletonBlendNodeFactoryFactory for blend nodes, ie nodes which blend together any number of sub-nodes
iSkeletonBoneThe skeleton bone class
iSkeletonBoneFactoryThe skeleton bone factory is class that is used to create skeleton bones of a iSkeleton object
CS::Animation::iSkeletonBoneModelA bone model holds the physical description of the bone of an CS::Mesh::iAnimatedMesh
CS::Animation::iSkeletonBoneModelIteratorThis iterator is returned by iSkeletonModel::GetBoneModels ()
iSkeletonBoneUpdateCallbackThis callback fires every time when bone changes it's transform
CS::Animation::iSkeletonChainA skeleton chain is a subtree of the skeleton of an CS::Mesh::iAnimatedMesh
CS::Animation::iSkeletonChainIteratorThis iterator is returned by iSkeletonModel::GetSkeletonChains ()
CS::Animation::iSkeletonChainNodeA node in a skeleton chain tree
CS::Animation::iSkeletonDebugNodeAn animation node that let visualize the dynamics of any animation node
CS::Animation::iSkeletonDebugNodeFactoryFactory for the 'debug' animation node (see CS::Animation::iSkeletonDebugNode)
CS::Animation::iSkeletonDebugNodeManagerA class to manage the creation and deletion of debug animation node factories
iSkeletonFactoryThe skeleton factory is class that is used to create skeleton objects in the scene
CS::Animation::iSkeletonFactoryA skeleton factory is an object defining the base pose and topology from which CS::Animation::iSkeleton instances can be created
CS::Animation::iSkeletonFSMNodeAn animation node that uses a Finite State Machine (FSM) to determine the animation to be played
CS::Animation::iSkeletonFSMNodeFactoryFactory for Finite State Machine (FSM) animation nodes
iSkeletonGraveyardISkeletonGraveyard is the interface that cares for all skeleton factories
CS::Animation::iSkeletonIKCCDNodeAn implementation of the CS::Animation::iSkeletonIKNodeFactory based on a quaternion version of the Cyclic Coordinate Descent algorithm
CS::Animation::iSkeletonIKCCDNodeFactoryAn implementation of the CS::Animation::iSkeletonIKNodeFactory based on a quaternion version of the Cyclic Coordinate Descent algorithm
CS::Animation::iSkeletonIKNodeAn animation node that generates an animation for a sub-part of the skeleton (a CS::Animation::iBodyChain) by specifying some geometrical constraints on the effectors placed on the skeleton
CS::Animation::iSkeletonIKNodeFactoryFactory for the Inverse Kinematics animation node
CS::Animation::iSkeletonIKNodeManagerA class to manage the creation and deletion of Inverse Kinematics animation node factories
CS::Animation::iSkeletonIKPhysicalNodeAn implementation of the CS::Animation::iSkeletonIKNode based on physical simulation
CS::Animation::iSkeletonIKPhysicalNodeFactoryAn implementation of the CS::Animation::iSkeletonIKNodeFactory based on physical simulation
CS::Animation::iSkeletonLookAtListenerA listener to be implemented if you want to be notified when the target has been reached or lost
CS::Animation::iSkeletonLookAtNodeAn animation node that controls a bone of an animesh in order to make it look at a target
CS::Animation::iSkeletonLookAtNodeFactoryFactory for the 'LookAt' animation node
CS::Animation::iSkeletonLookAtNodeManagerA class to manage the creation and deletion of 'LookAt' animation node factories
CS::Animation::iSkeletonManagerSkeletal system base object, representing the entire skeletal and skeletal animation system
CS::Animation::iSkeletonModelThis class holds the physical description of the skeleton of an CS::Mesh::iAnimatedMesh
CS::Animation::iSkeletonModelManagerA class to manage the creation and deletion of skeleton models
CS::Animation::iSkeletonNoiseNodeAn animation node that controls the animation of the bones through pseudo-random noise functions from CS::Math::Noise
CS::Animation::iSkeletonNoiseNodeFactoryFactory for the 'noise' animation node (see CS::Animation::iSkeletonNoiseNode)
CS::Animation::iSkeletonNoiseNodeManagerA class to manage the creation and deletion of noise animation node factories
CS::Animation::iSkeletonPriorityNodeAn animation node that blends together the sub-nodes based on their priority
CS::Animation::iSkeletonPriorityNodeFactoryFactory for priority blend nodes, ie nodes blending sub-nodes on the base of their current priority
CS::Animation::iSkeletonRagdollNodeAn animation node that interacts with the dynamic simulation in order to control the animation of the animated mesh, and/or in order to make the mesh collide with the rigid bodies of the simulation
CS::Animation::iSkeletonRagdollNode2An animation node that interacts with the dynamic simulation in order to control the animation of the animated mesh, and/or in order to make the mesh collide with the rigid bodies of the simulation
CS::Animation::iSkeletonRagdollNodeFactoryFactory for the ragdoll animation node
CS::Animation::iSkeletonRagdollNodeFactory2Factory for the ragdoll animation node
CS::Animation::iSkeletonRagdollNodeManagerA class to manage the creation and deletion of ragdoll animation node factories
CS::Animation::iSkeletonRagdollNodeManager2A class to manage the creation and deletion of ragdoll animation node factories
CS::Animation::iSkeletonRandomNodeAn animation node that selects randomly the sub-nodes to be played
CS::Animation::iSkeletonRandomNodeFactoryFactory for blending nodes playing randomly their sub-nodes
CS::Animation::iSkeletonRetargetNodeAn animation node that can retarget an animation from one skeleton to another
CS::Animation::iSkeletonRetargetNodeFactoryFactory for the 'Retarget' animation node
CS::Animation::iSkeletonRetargetNodeManagerA class to manage the creation and deletion of 'Retarget' animation node 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
CS::Animation::iSkeletonSpeedNodeAn animation node that takes some animations of the animesh moving at different speed (eg idle, walking, running), and blend them to achieve any custom speed
CS::Animation::iSkeletonSpeedNodeFactoryFactory for the 'speed' animation node
CS::Animation::iSkeletonSpeedNodeManagerA class to manage the creation and deletion of speed animation node factories
iSkeletonUpdateCallbackThis is a callback function of a skeleton
CS::Meta::IsLog2< R >Meta-programming IsLog2 function
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
iSndSysListenerDopplerExtension to the iSndSysListener interface, allowing Doppler shift effects
iSndSysLoaderThe sound loader is used to load sound files given a raw input data stream
iSndSysManagerThis is the sound manager for Crystal Space
iSndSysRendererThe sound renderer is the core interface for the sound system
iSndSysRendererCallbackSound System renderer interface for callback notification
iSndSysRendererOpenALOpenAL renderer specific interface extensions
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
iSndSysSourceA sound source is the origin of a sound in Crystal Space
iSndSysSource3DExtension to the iSndSysSource interface, allowing sources to be positioned in space
iSndSysSource3DDirectionalExtension to the iSndSysSource3D interface, allowing directional orientation of sound sources
iSndSysSource3DDirectionalSimpleExtension to the iSndSysSource3D interface, allowing simple directional orientation of sound sources
iSndSysSource3DDopplerExtension to the iSndSysSource3D interface, allowing Doppler shift effects
iSndSysSourceOpenALInterface for OpenAL sound sources
iSndSysSourceSoftwareSound source extensions for the software renderer
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::Network::Socket::iSocketA socket connection obtained from iSocketManager
CS::Network::Socket::iSocketArrayAn array of sockets
CS::Network::Socket::iSocketManagerThe iSocketManager interface is the main interface for socket usage
CS::Physics::Bullet::iSoftBodyA soft body is a physical body that can be deformed by the physical simulation
CS::Physics::iSoftBodyA soft body is a physical body that can be deformed by the physical simulation
CS::Animation::iSoftBodyAnimationControlAnimation control for a genmesh animated by a CS::Physics::Bullet::iSoftBody
CS::Animation::iSoftBodyAnimationControl2Animation control for a genmesh animated by a CS::Physics::iSoftBody
CS::Animation::iSoftBodyAnimationControl2FactoryAnimation control factory for a genmesh animated by a CS::Physics::iSoftBody
CS::Animation::iSoftBodyAnimationControl2TypeAnimation control type for a genmesh animated by a CS::Physics::iSoftBody
CS::Animation::iSoftBodyAnimationControlFactoryAnimation control factory for a genmesh animated by a CS::Physics::Bullet::iSoftBody
CS::Animation::iSoftBodyAnimationControlTypeAnimation control type for a genmesh animated by a CS::Physics::Bullet::iSoftBody
CS::Physics::iSoftBodyFactoryFactory for the creation of instances of iSoftBody
CS::Physics::iSoftClothFactoryUsed to create a two-dimensional softbody, typically a cloth
CS::Physics::iSoftMeshFactoryUsed to create an arbitrary softbody defined by a given triangle mesh
CS::Physics::iSoftRopeFactoryUsed to create a one-dimensional softbody
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::IsSame< Type1, Type2 >Check if two types are the same
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
iStringSetGeneral string ID string set
iStringSetBase< Tag >The string set is a collection of unique strings
iSyntaxServiceThis component provides services for other loaders to easily parse properties of standard CS world syntax
iSystemOpenManagerManager for system open events
csArray< T, ElementHandler, MemoryAllocator, CapacityHandler >::IteratorIterator for the csArray class
csList< T, MemoryAllocator >::IteratorIterator for the list
csHash< T, K, ArrayMemoryAlloc, ArrayElementHandler >::IteratorAn iterator class for the csHash class
csRedBlackTree< K, Allocator, Ordering >::IteratorIterator for tree
csRedBlackTreeMap< K, T, Allocator, Ordering >::IteratorIterator for map
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
CS::Physics::Bullet::iTerrainColliderA terrain collider for the dynamic simulation
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
iTerrainModifierTerrain modifier class
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)
iThreadedLoaderThis interface represents the threaded map loader methods
iThreadManagerThis is the thread manager
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
CS::Geometry::SpatialTree< Self, ChildType >::iUserDataThe data type for user data to be attached to the KDTree
iUserRenderBufferIteratorInterface to iterate over all buffers stored in a csUserRenderBufferManager
CS::Physics::iVehicleA physical, wheeled, grounded vehicle
CS::Physics::iVehicleBrakeA brake acts on a given set of wheels with a given amount of force
CS::Physics::iVehicleFactoryA factory to create instances of iVehicle
CS::Physics::iVehicleSteeringDeviceA steering device steers a given set of tires with a given maximum amount
CS::Physics::iVehicleWheelThe wheel of a vehicle
CS::Physics::iVehicleWheelFactoryThe factory for the wheel of a vehicle
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
CS::Media::iVideoMediaVideo stream
iViewViewport and encapsulates the top-level 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
CS::Debug::iVisualDebuggerVisual debugging tools
iWaterFactoryStateThe water mesh is a simple mesh representation for a horizontal square
iWaterMeshStateThis interface describes the API for the water mesh object
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
iXMLShaderAccess XMLShader-specific data
iXWindowDocument me! @@
CS::Geometry::KDTree< ChildType >A KD-tree
csFontCache::KnownFontA font known to the cache
CS::RenderManager::LayerDescLayer descriptor
CS::RenderManager::LayerHelper< RenderTree, LayerConfigType, NewLayersType >Helper to duplicate render layers
CS::RenderManager::LightingSorter::LightInfoInformation associated with a light
CS::RenderManager::LightingSorterLighting sorter
CS::RenderManager::LightingVariablesHelperHelper class to deal with shader variables setup for lighting
CS::RenderManager::LightSettingsCompatibility light settings: if two lights have equal compatibility light settings they can be rendered in one pass; if not, they require different passes
CS::RenderManager::LightSetup< RenderTree, LayerConfigType, ShadowHandler >For each mesh determine the array of affecting lights and generate shader vars for it
CS::Math::Noise::Model::LineModel that defines the displacement of a line segment
CS::RenderManager::HDR::Exposure::LinearA simple exposure controller, just scaling color values by a factor
csList< T, MemoryAllocator >::ListElementTemplate 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::Memory::LocalBufferAllocatorUnchecked< T, N, ExcessAllocator, SingleAllocation >LocalBufferAllocator without safety checks, but suitable for use across modules
CS::Meta::Log2< R >Helper for log2 computation
csFontCache::LRUEntryAn entry in the LRU list
csBitmaskToString::MaskNamesStructure containing a name for possible bit masks
CS::Utility::ImportKit::Container::MaterialA material for a mesh
CS::Material::MaterialBuilderTools related to creating materials
CS::Math::Matrix4A 4x4 matrix
CS::Math::Noise::Module::MaxNoise module that outputs the larger of the two output values from two source modules
CS::Utility::Checksum::MD5Compute a MD5 message digest
CS::MeasureTimeSimple helper class to measure execution time of a block
CS::Media::MediaLanguageUsed to store languages available for a media file
CS::Utility::ImportKit::Container::Model::MeshModel mesh, contains actual geometry
CS::RenderManager::RenderTreeStandardTraits::MeshExtraDataTypeAny extra data per mesh in a single mesh
CS::Utility::MeshFilterStructure holding filtering data in order to restrict the list of meshes from a scene that must be rendered
CS::RenderManager::RenderTree< TreeTraits >::MeshNodeA mesh node is a single list of meshes that can be rendered in one go without any explicit order considerations
CS::RenderManager::RenderTreeStandardTraits::MeshNodeExtraDataTypeAny extra data that should be defined for each mesh node
CS::RenderManager::RenderTreeStandardTraits::MeshNodeKeyTypeThe data type to use as node key for mesh nodes
CS::PluginCommon::ShaderCacheHelper::MicroArchiveA simple archive format
CS::PluginCommon::ShaderCacheHelper::MicroArchiveCacheIHierarchicalCache implementation storing everything in a MicroArchive
CS::Math::Noise::Module::MinNoise module that outputs the smaller of the two output values from two source modules
CS::Animation::MocapParserTool for parsing motion capture resource files and importing them into an animation data suitable for the CS::Mesh::iAnimatedMesh
CS::Animation::MocapParserResultReturn structure for CS::Animation::MocapParser::ParseData()
CS::Utility::ImportKit::Container::ModelA model
CS::Utility::ModifiableConstraintBitMaskValidates a CSVAR_LONG value, checking that its bits satisfy a given mask
CS::Utility::ModifiableConstraintBoundedImplementation of CS::Utility::iModifiableConstraintBounded
CS::Utility::ModifiableConstraintEnumImplements an enum constraint for a CSVAR_LONG CS::Utility::iModifiable field
CS::Utility::ModifiableConstraintTextEntryCan validate a text entry, using minimum/ maximum length and/or a regular expression
CS::Utility::ModifiableConstraintVFSDirAttached to an CS::Utility::iModifiable parameters, verifies that the value entered within is always a VFS directory, relative or absolute
CS::Utility::ModifiableConstraintVFSFileAttached to an CS::Utility::iModifiable parameters, verifies that the value entered within is always a VFS file, not a path or a directory
CS::Utility::ModifiableConstraintVFSPathAttached to an CS::Utility::iModifiable parameters, verifies that the value entered within is always a full VFS path - a directory and a file, relative or absolute
CS::Math::Noise::Module::ModuleAbstract base class for noise modules
CS::Engine::MovableSectorListA list of sectors as the movable uses it
CS::RenderManager::MultipleRenderLayerRender layer implementation providing multiple render layers
CS::Math::Noise::Module::MultiplyNoise module that outputs the product of the two output values from two source modules
CS::Threading::MutexImpl< BaseMutex >General mutex class
CS::Animation::NameBoneMappingHelperThis helper class can generate a bone mapping by simply taking the corresponding bones that have the same name
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::RenderManager::Implementation::NoOperationBlock< IterationObject >Object blocker for iterator methods below
CS::Meta::Implementation::NoTypeBoolean false type
CS::NumberedFilenameHelperHelper to deal with numbered filename
CS::Persistence::ObjectCommentDefault implementation of iObjectComment
CS::Math::Ode45Embedded Runge-Kutta 4/5th order ODE solver for non-stiff ODEs
CS::RenderManager::Implementation::OnceOperationBlock< IterationObject >Object blocker for iterator methods below
CS::RenderManager::Implementation::OnceOperationBlockRef< IterationObject >Object blocker for iterator methods below
CS::RenderManager::Implementation::OperationCaller< Fn, OperationBlock, Type >Helper for dispatching the actual function call in ForEach methods below
CS::RenderManager::Implementation::OperationCaller< Fn, OperationBlock, OperationNumbered >Executor for numbered calls
CS::RenderManager::Implementation::OperationCaller< Fn, OperationBlock, OperationNumberedParallel >Executor for numbered calls
CS::RenderManager::Implementation::OperationCaller< Fn, OperationBlock, OperationUnordered >Executor for unordered calls
CS::RenderManager::Implementation::OperationCaller< Fn, OperationBlock, OperationUnorderedParallel >Executor for unordered calls
CS::RenderManager::OperationNumberedGive each operation a number passed along to functor. Single execution
CS::RenderManager::OperationNumberedParallelGive each operation a number passed along to functor. Possible parallel execution
CS::RenderManager::OperationTraits< T >Unspecialized traits class for operations defining their ordering and parallellization
CS::RenderManager::OperationTraits< CS::Meta::CompositeFunctorType2< Fn1, Fn2 > >Specialized traits class for composite functor
CS::RenderManager::OperationTraits< CS::Meta::CompositeFunctorType3< Fn1, Fn2, Fn3 > >Specialized traits class for composite functor
CS::RenderManager::OperationTraits< StandardMeshSorter< RenderTree > >The sorter is currently non-parallel safe due to how the caching is implemented
CS::RenderManager::OperationUnorderedNo forced order of operation. Single execution
CS::RenderManager::OperationUnorderedParallelNo forced order of operation. Possible parallel execution
CS::Threading::OptionalMutex< _Lock >Helper that is a (non-recursive) mutex if _Lock is true or does nothing if _Lock is false
csBox3::OutlineThis table also contains an array of sides visible from that region
CS::Graphics::OverlayShaderVariableContextImplIShaderVariableContext implementation that overlays (or merges) it's variables over the variables of a given parent context
CS::SndSys::PCMSampleConverterA PCMSampleConverter object converts PCM data from one format to another
CS::Math::Noise::Module::PerlinNoise module that outputs 3-dimensional Perlin noise
CS::RenderManager::AutoFX::ReflectRefract_Base::PersistentDataData used by the helper that needs to persist over multiple frames
CS::RenderManager::StandardPortalSetup_Base::PersistentDataData used by the helper that needs to persist over multiple frames
CS::RenderManager::LightingVariablesHelper::PersistentDataData used by the helper that needs to persist over multiple frames
CS::RenderManager::LightSetup< RenderTree, LayerConfigType, ShadowHandler >::PersistentDataData used by the light setup helper that needs to persist over multiple frames
CS::RenderManager::LightingSorter::PersistentDataData used by the helper that needs to persist over multiple frames
CS::RenderManager::RenderTree< TreeTraits >::PersistentDataData used by the render tree that needs to persist over multiple frames
CS::RenderManager::ShadowNone< RenderTree, LayerConfigType >::PersistentDataData used by the shadow handler that needs to persist over multiple frames
CS::RenderManager::AutoFX::FramebufferTex_Base::PersistentDataData used by the helper that needs to persist over multiple frames
CS::RenderManager::RenderTreeStandardTraits::PersistentDataExtraDataTypeAny extra data that needs to persist between frames
CS::Math::Noise::Model::PlaneModel that defines the surface of a plane
csFontCache::PlaneGlyphsArray of a number of glyphs
CS::RenderManager::StandardPortalSetup_Base::PersistentData::PortalBufferConstraintGenericCache-constraints for PortalBuffer caching
CS::RenderManager::StandardPortalSetup_Base::PersistentData::PortalBuffersCache structure for portal render buffers
CS::RenderManager::RenderTree< TreeTraits >::ContextNode::PortalHolderInformation for a portal
CS::RenderManager::PostEffectLayerInputMapCustom input mapping for a post processing layer
CS::RenderManager::PostEffectLayerOptionsOptions for a post processing layer
CS::RenderManager::PostEffectLayersParserHelper class to parse post processing effect configurations
CS::RenderManager::PostEffectsSupportAdd post effects support to a render manager
CS::Math::Noise::Module::PowerNoise module that raises the output value from a first source module to the power of the output value from a second source module
CS::Geometry::PrimitiveSuperclass for all primitives
CS::Geometry::PrimitivesA primitive mesh generator
CS::Utility::PriorityQueue< T, Container, Comparator >An implementation of a priority queue
CS::Graphics::PriorityShaderVariableContextImplIShaderVariableContext implementation that stacks sv contexts based on the given priority
CS::Platform::ProcessorSpecDetectionClass performing processor specifications and feature detection
csShaderProgram::ProgramParamProgram parameter, either a SV reference or a const value
csShaderProgram::ProgramSourceInformation to obtain the program source data
CS::Math::ProjectionsHelpers to create standard projections
csRenderBuffer::PropsTo 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::Utility::ResourceCache::PurgeIfOnlyOneRefPurge condition: a resource is purged if only one reference is held to it
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::QuoteHelper functions to decorate strings with nice-looking quote characters
CS::Threading::ReadWriteMutexA mutex class which provides concurrent reads and exclusive writes
CS::Container::RedBlackTreeOrderingPartial< K, K2 >Partial ordering (http://en.wikipedia.org/wiki/Partial_order) for red-black-trees
CS::Container::RedBlackTreeOrderingStrictWeak< K, K2 >Strict weak ordering (http://en.wikipedia.org/wiki/Strict_weak_ordering) for red-black-trees
CS::Container::RedBlackTreeOrderingTotal< K, K2 >Total ordering (http://en.wikipedia.org/wiki/Total_ordering) for red-black-trees
CS::RenderManager::AutoFX::ReflectRefract< RenderTree, ContextSetupReflect, ContextSetupRefract >Render manager helper for automatic plane reflection/refraction textures
CS::RenderManager::AutoFX::ReflectRefract_BaseBase class for ReflectRefract, containing types and members which are independent of the template arguments that can be provided to ReflectRefract
CS::RenderBufferPersistentRender buffer wrapper with additional persistence information
CS::RenderManager::RenderCommon< RenderTree >Common mesh render functions
CS::Graphics::RenderMeshMesh data as returned by mesh plugins
CS::Graphics::RenderMeshIndexRangeStart and end for a range of indices to render
CS::Graphics::RenderMeshModesMesh render mode information
CS::Graphics::RenderPriorityRendering priority
CS::RenderManager::RenderTree< TreeTraits >RenderTree is the main data-structure for the rendermanagers
CS::RenderManager::RenderTreeBaseHelper class containing stuff which doesn't require any of the template parameters to RenderTree
CS::RenderManager::RenderTreeStandardTraitsStandard traits for customizing the render tree class
CS::RenderManager::RenderViewThis structure represents all information needed for drawing a scene
CS::RenderManager::RenderViewCacheStores a cache of RenderView objects, mapped by iView objects
CS::RenderViewClipperHelper to clip in the context of a render view
CS::Utility::ResourceCache::ReuseAlwaysReuse condition: allow immediate reuse
CS::Utility::ResourceCache::ReuseConditionAfterTime< TimeType >Reuse condition: a resource is reused after a certain time has passed
CS::Utility::ResourceCache::ReuseConditionFlaggedReuse condition: a resource is reused after being flagged as such
CS::Utility::ResourceCache::ReuseIfOnlyOneRefReuse condition: a resource is reused if only one reference is held to it
csArray< T, ElementHandler, MemoryAllocator, CapacityHandler >::ReverseConstIteratorReverse iterator for the csArray class
csArray< T, ElementHandler, MemoryAllocator, CapacityHandler >::ReverseIteratorReverse iterator for the csArray class
csRedBlackTree< K, Allocator, Ordering >::ReverseIteratorReverse iterator for tree
csRedBlackTreeMap< K, T, Allocator, Ordering >::ReverseIteratorReverse iterator for map
CS::Math::Noise::Module::RidgedMultiNoise module that outputs 3-dimensional ridged-multifractal noise
CS::RenderManager::RMDebugCommon< RenderTreeType >Common debug helpers in render manager plugins
CS::Utility::RootedHierarchicalCacheIHierarchicalCache providing a 'view' into a path of another cache
CS::Math::Noise::Module::RotatePointNoise module that rotates the input value around the origin before returning the output value from a source module
CS::Threading::RunnableAbstract base class for objects acting as executor in separate threads
CS::Math::Noise::Module::ScaleBiasNoise module that applies a scaling factor and a bias to the output value from a source module
CS::Math::Noise::Module::ScalePointNoise module that scales the coordinates of the input value before returning the output value from a source module
CS::Engine::SceneNodeHelperHelper class for iSceneNode
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
scfImplementation0< Class >Base class for an SCF class implementation with the given number of interfaces
scfImplementation1< Class, I1 >Base class for an SCF class implementation with the given number of interfaces
scfImplementation2< Class, I1, I2 >Base class for an SCF class implementation with the given number of interfaces
scfImplementation3< Class, I1, I2, I3 >Base class for an SCF class implementation with the given number of interfaces
scfImplementation4< Class, I1, I2, I3, I4 >Base class for an SCF class implementation with the given number of interfaces
scfImplementation5< Class, I1, I2, I3, I4, I5 >Base class for an SCF class implementation with the given number of interfaces
scfImplementation6< Class, I1, I2, I3, I4, I5, I6 >Base class for an SCF class implementation with the given number of interfaces
scfImplementation7< Class, I1, I2, I3, I4, I5, I6, I7 >Base class for an SCF class implementation with the given number of interfaces
scfImplementationExt0< Class, Super >Base class to extend the SCF class Super with additional interfaces
scfImplementationExt1< Class, Super, I1 >Base class to extend the SCF class Super with additional interfaces
scfImplementationExt2< Class, Super, I1, I2 >Base class to extend the SCF class Super with additional interfaces
scfImplementationExt3< Class, Super, I1, I2, I3 >Base class to extend the SCF class Super with additional interfaces
scfImplementationExt4< Class, Super, I1, I2, I3, I4 >Base class to extend the SCF class Super with additional interfaces
scfImplementationExt5< Class, Super, I1, I2, I3, I4, I5 >Base class to extend the SCF class Super with additional interfaces
scfImplementationExt6< Class, Super, I1, I2, I3, I4, I5, I6 >Base class to extend the SCF class Super with additional interfaces
scfImplementationExt7< Class, Super, I1, I2, I3, I4, I5, I6, I7 >Base class to extend the SCF class Super with additional interfaces
scfImplementationHelperVarious helpers for scfImplementation
scfImplementationPooled< Super, Allocator, Locked >Derive an SCF implementation from this class to have it pooled
scfInterfaceMetadataMetadata about a single interface implemented within a class
scfInterfaceMetadataListA chain list of metadata for interfaces implemented within a class
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::ScfStringSet< IF >The string set is a collection of unique strings
scfVirtImplementation0< Class >Base class for an SCF class implementation with the given number of virtual interfaces
scfVirtImplementation1< Class, I1 >Base class for an SCF class implementation with the given number of virtual interfaces
scfVirtImplementation2< Class, I1, I2 >Base class for an SCF class implementation with the given number of virtual interfaces
scfVirtImplementation3< Class, I1, I2, I3 >Base class for an SCF class implementation with the given number of virtual interfaces
scfVirtImplementation4< Class, I1, I2, I3, I4 >Base class for an SCF class implementation with the given number of virtual interfaces
scfVirtImplementation5< Class, I1, I2, I3, I4, I5 >Base class for an SCF class implementation with the given number of virtual interfaces
scfVirtImplementation6< Class, I1, I2, I3, I4, I5, I6 >Base class for an SCF class implementation with the given number of virtual interfaces
scfVirtImplementation7< Class, I1, I2, I3, I4, I5, I6, I7 >Base class for an SCF class implementation with the given number of virtual interfaces
scfVirtImplementationExt0< Class, Super >Base class to extend the SCF class Super with additional virtually inherited interfaces
scfVirtImplementationExt1< Class, Super, I1 >Base class to extend the SCF class Super with additional virtually inherited interfaces
scfVirtImplementationExt2< Class, Super, I1, I2 >Base class to extend the SCF class Super with additional virtually inherited interfaces
scfVirtImplementationExt3< Class, Super, I1, I2, I3 >Base class to extend the SCF class Super with additional virtually inherited interfaces
scfVirtImplementationExt4< Class, Super, I1, I2, I3, I4 >Base class to extend the SCF class Super with additional virtually inherited interfaces
scfVirtImplementationExt5< Class, Super, I1, I2, I3, I4, I5 >Base class to extend the SCF class Super with additional virtually inherited interfaces
scfVirtImplementationExt6< Class, Super, I1, I2, I3, I4, I5, I6 >Base class to extend the SCF class Super with additional virtually inherited interfaces
scfVirtImplementationExt7< Class, Super, I1, I2, I3, I4, I5, I6, I7 >Base class to extend the SCF class Super with additional virtually inherited interfaces
CS::Utility::ScopedArrayPointer< T >Smart pointer that delete[]s the contained pointer when the scope is exited
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::Utility::ScopedPointer< T >Smart pointer that deletes the contained pointer when the scope is exited
CS::Utility::Implementation::WeakReferenced::ScopedWeakRefOwnersLockHelper to lock the pointers of all weak reference owners
CS::Math::Noise::Module::SelectNoise module that outputs the value selected from one of two source modules chosen by the output value from a control module
CS::Utility::Implementation::SetNumberComputer< Associativity >Helper to compute the number of sets needed for a given hash size and associativity
CS::Utility::Implementation::SetNumberComputer< 0 >Special case, associativity 0 means fully associative
CS::Utility::Checksum::SHA256Compute a SHA-256 message digest
CS::RenderManager::RenderCommon< RenderTree >::ShaderActivatorHelper to manage shader pass activation/setup/teardown/deactivation
CS::PluginCommon::ShaderCacheHelper::ShaderDocHasherComputes a hash for all referenced documents documents (ie external files pulled in via "file" attributes or ?Include? PIs) of a shader document
CS::PluginCommon::ShaderProgramPluginGLCommon code useful for all OpenGL-based shader program plugins
CS::RenderManager::ShaderSetup< RenderTree, LayerConfigType >Default shader setup functor
CS::RenderManager::ShaderSVSetup< RenderTree, LayerConfigType >Standard shader variable stack setup functor for setting up shader variables from given shader and ticket arrays
CS::Graphics::ShaderVariableContextImplSimple implementation for iShaderVariableContext
CS::ShaderVarNameHelper class to obtain an ID for a shader variable
CS::Graphics::ShaderVarNameParserHelper class to extract the actual shader var name and array indices given a shader var identifier containing both
CS::RenderManager::ShadowNone< RenderTree, LayerConfigType >Shadow handler for "no" shadows
CS::RenderManager::ShadowNone< RenderTree, LayerConfigType >::ShadowParametersShadow method specific parameters
CS::RenderManager::ShadowSettingsHelper to read shadow handler settings
CS::RenderManager::SimpleContextRender< RenderTree >Render mesh nodes within one context
CS::RenderManager::SimpleContextRenderByMesh< RenderTree >Render mesh nodes within one context with "by mesh" render grouping
CS::Lighting::SimpleStaticLighterThe 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::RenderManager::SimpleTreeRenderer< RenderTree >Renderer for multiple contexts, grouping them by render target and rendering all layers of each context to same target
CS::RenderManager::RenderTree< TreeTraits >::MeshNode::SingleMeshA single mesh within the tree to be rendered
CS::RenderManager::SingleMeshContextNumbering< RenderTree >Simple operation to assign sequential IDs to all mesh nodes within a context
CS::RenderManager::SingleRenderLayerRender layer implementation for a single render layer
CS::Animation::SkeletonAnimNodeFactoryBase implementation of a CS::Animation::iSkeletonAnimNodeFactory
CS::Animation::SkeletonAnimNodeFactoryMultiBase implementation of a CS::Animation::iSkeletonAnimNodeFactory with more than one child
CS::Animation::SkeletonAnimNodeFactorySingleBase implementation of a CS::Animation::iSkeletonAnimNodeFactory with a single child
CS::Animation::SkeletonAnimNodeSingle< FactoryType >Base implementation of a CS::Animation::iSkeletonAnimNode with a single child
CS::Animation::SkeletonAnimNodeSingleBaseMethods of SkeletonAnimNodeSingle not dependent on the factory type
CS::Animation::SkeletonNoiseA structure holding the noise components for a iSkeletonNoiseNode animation node
CS::Physics::Bullet::SoftBodyHelperGeneral helper class for CS::Physics::Bullet::iSoftBody
CS::Physics::SoftBodyHelperGeneral helper class for CS::Physics::iSoftBody
CS::Utility::ResourceCache::SortingNoneResource sorting that does not sort
CS::SndSys::SoundCyclicBufferAn implementation of a cyclic buffer oriented for sound functionality
CS::Geometry::SphereA sphere
CS::Math::Noise::Model::SphereModel that defines the surface of a sphere
CS::Math::Noise::Module::SpheresNoise module that outputs concentric spheres
CS::RenderManager::StandardMeshSorter< Tree >Standard rendermesh sorter
CS::RenderManager::StandardPortalSetup< RenderTreeType, ContextSetup >Standard setup functor for portals
CS::RenderManager::StandardPortalSetup_BaseBase class for StandardPortalSetup, containing types and members which are independent of the template arguments that can be provided to StandardPortalSetup
CS::RenderManager::StandardSVSetup< RenderTree, LayerConfigType >Standard shader variable stack setup functor
CS::RenderManager::StaticLightsSettingsLayer settings for handling static lights
CS::SndSys::SndSysBasicStream::StreamNotificationEventStructure containing the data for each notification event
CS::Utility::StringArray< Allocator, CapacityHandler >An array of strings
CS::Utility::StringHash< Tag >A string-to-ID hash table
CS::StringID< Tag >An identifier for a string
CS::Utility::StringSet< Tag, Locked >The string set is a collection of unique strings
CS::PluginCommon::ShaderCacheHelper::StringStoreReaderHelper to read strings written with StringStoreWriter
CS::PluginCommon::ShaderCacheHelper::StringStoreWriterHelper to write strings in an efficient way (each string once)
CS::StructuredTextureFormatStructured representation of a texture format
CS::SubRectangles::SubRectSub-rectangle
CS::SubRectanglesA class managing allocations of sub-rectangles
CS::SubRectanglesCompactA variation of SubRectangles that tries to place rectangles in a rectangular fashion
csEventTree::SubscriberIteratorThe SubscriberIterator is a wrapper for the messy internals of figuring out which event handler to call next
CS::RenderManager::SVArrayHolderHolder for SV arrays
CS::Geometry::TableTextureMapperTable texture mapper
CS::RenderManager::ShadowSettings::TargetShadow map target
CS::RenderManager::DependentTargetManager< RenderTree, TargetHandler >::TargetSettingsThe settings for a handle
CS::RenderManager::RenderTree< TreeTraits >::ContextNode::TargetTextureA single render target
CS::Math::Noise::Module::TerraceNoise module that maps the output value from a source module onto a terrace-forming curve
CS::Geometry::TesselatedBoxA Tesselated box
CS::Geometry::TesselatedQuadA tesselated quad
CS::RenderManager::TextureCacheT< ReuseCondition, PurgeCondition >Cache for caching precreated textures
CS::TextureFormatStringsTexture format string parser routines
CS::Geometry::TextureMapperClass for controlling texture mapping on the generated meshes
CS::RenderManager::Implementation::TextureSizeConstraintHelper for generic resource cache storing texture handles
CS::Threading::ThreadObject representing a separate execution thread
CS::Threading::ThreadGroupA group of threads handled as one unit
CS::Threading::ThreadLocal< T >Thread local storage of arbitrary C++ objects
CS::Threading::ThreadLocalBaseThread local storage of a pointer value (void*)
CS::RenderManager::TicketSetup< RenderTree, LayerConfigType >Default shader ticket setup
CS::Math::Noise::Module::TranslatePointNoise module that moves the coordinates of the input value before returning the output value from a source module
CS::RenderManager::TraverseUsedSVs< RenderTree, Fn >Traverser for all meshes in a tree, calling the callback for each SV used by each mesh
CS::RenderManager::TraverseUsedSVSets< RenderTree, Fn >Traverser for all meshes in a tree, returning the set of used shader variables for each mesh
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::Triangulate3DFunctions
CS::Math::Noise::Module::TurbulenceNoise module that randomly displaces the input value before returning the output value from a source module
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::UberScreenshotMakerHelper to create "&uuml;berscreenshots", screenshots with a resolution larger than the current framebuffer resolution
CS::Graphics::UncompressedDXTDataLayoutDescription on how pixel data before compression resp
CS::Graphics::UniversalImageConverterConvert image/texture data between different image/texture formats
csShaderProgram::VariableMapEntryHolder of variable mapping
CS::Utility::VfsHierarchicalCacheThis is a general cache that can cache data on VFS
CS::RenderManager::Implementation::ViscullCallback< RenderTree >Helper class implementing the visculler callback functionality and adds rendermeshes via AddRenderMeshToContext function
CS::Debug::VisualDebuggerHelperHelper class for visual debugging tools
CS::Math::Noise::Module::VoronoiNoise module that outputs Voronoi cells
CS::Container::WeakKeyedHash< T, K, ArrayMemoryAlloc, ArrayElementHandler >Hash type that allows (certain) changes of key objects
CS::Utility::WeakReferencedThis is a class which provides basic weak reference-counting semantics
CS::Utility::Implementation::WeakReferencedBase implementation for objects that are weak referencable
CS::WGLExtensionFlagsStruct containing all WGL extension test flags
CS::WGLExtensionFunctionsStruct containing all WGL extension functions
CS::WGLExtensionManagerWGL extensions manager
CS::Meta::Implementation::Wrap< T >Simple dummy-wrapper

Generated for Crystal Space 2.1 by doxygen 1.6.1