Class List (Crystal Space 2.0 Public API Reference)

| ## Public API Reference

- Main Page
- Related Pages
- Modules
- Namespaces
- Classes
- Files

- Class List
- Class Index
- Class Hierarchy
- Class Members

Class List
Here are the classes, structs, unions and interfaces with brief descriptions:

_csKeyModifiers | Flags for all currently pressed modifiers
CS::Math::Noise::Module::Abs | Noise module that outputs the absolute value of the output value from a source module
CS::Math::Noise::Module::Add | Noise module that outputs the sum of the two output values from two source modules
CS::Utility::Checksum::Adler32 | Compute 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::AllocatorInterface | Memory allocator forwarding to an iAllocator implementation
CS::Memory::AllocatorMalloc | A default memory allocator that allocates with cs_malloc()
CS::Memory::AllocatorMallocPlatform | Memory allocator using the platform's default allocation functions (malloc, free etc.)
CS::Memory::AllocatorNew< T > | A default memory allocator that allocates using new T[]
CS::Memory::AllocatorNewChar< Reallocatable > | A default memory allocator that allocates using new char[]
CS::Memory::AllocatorPointerWrapper< T, Allocator > | Class to store a pointer that is allocated from Allocator, to eliminate overhead from a possibly empty Allocator
CS::Memory::AllocatorRef< OtherAllocator > | Memory allocator forwarding to another allocator
CS::Memory::AllocatorSafe< Allocator > | Threadsafe allocator wrapper
CS::Graphics::AlphaTestOptions | Alpha test options
CS::Mesh::AnimatedMeshBoneInfluence | Represent a single influence of a bone on a single vertex
CS::Animation::AnimatedMeshState | Holds the state of an animesh skeleton for a frame, ie the position and rotation of each bone of the skeleton
CS::Mesh::AnimatedMeshTools | Helper class to generate new CS::Mesh::iAnimatedMesh's
CS::Animation::AnimNodeManagerCommon< ThisType, ManagerInterface, FactoryType > | Template class for animation node plugin managers
CS::Threading::AtomicOperationsBase< Impl > | Define low-level atomic operations
CS::Utility::AtomicRefCount | This is a class which provides basic atomic reference-counting semantics
CS::Threading::Barrier | Barrier synchronization class
CS::RenderManager::BeginFinishDrawScope | Scope wrapper for setting BeginDraw flags and calling FinishDraw on scope end
CS::Math::Noise::Module::Billow | Noise module that outputs three-dimensional "billowy" noise
CS::Math::Noise::Module::Blend | Noise 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::BoneMapping | This class holds the mapping between the bones of a source and a target skeleton
CS::Geometry::Box | A box
CS::Animation::BVHMocapParser | Tool for parsing BVH (BioVision Hierarchical data) motion capture ressource files
CS::Math::Noise::Module::Cache | Noise module that caches the last output value generated by a source module
CS::RenderManager::LightSetup< RenderTree, LayerConfigType, ShadowHandler >::CachedLightData | Data persistently stored for every light
CS::RenderManager::ShadowNone< RenderTree, LayerConfigType >::CachedLightData | Shadowing-specific data persistently stored for every light
CS::Platform::Win32::CacheDLL | Small helper to avoid repeated loading/unloading of DLLs loaded at runtime
CS::Geometry::Capsule | A capsule
CS::Math::Noise::Module::Checkerboard | Noise module that outputs a checkerboard pattern
CS::Math::Noise::Module::Clamp | Noise module that clamps the output value from a source module to a range of values
CS::PluginCommon::ShaderProgramPluginGL::ClipPlanes | Helper class for user defined OpenGL clip planes
csAnsiParser::CommandParams | Parameters to ANSI command
CS::Threading::Condition | Condition variable
CS::Geometry::Cone | A Cone
CS::RenderManager::HDR::Exposure::Configurable | Exposure controller wrapping other exposure controllers, allowing the choice of exposure through the configuration system
CS::Math::Noise::Module::Const | Noise module that outputs a constant value
csHash< T, K, ArrayMemoryAlloc, ArrayElementHandler >::ConstGlobalIterator | An const iterator class for the csHash class
csArray< T, ElementHandler, MemoryAllocator, CapacityHandler >::ConstIterator | Iterator for the csArray class
csHash< T, K, ArrayMemoryAlloc, ArrayElementHandler >::ConstIterator | An const iterator class for the csHash class
csRedBlackTree< K, Allocator, Ordering >::ConstIterator | Const iterator for tree
csRedBlackTreeMap< K, T, Allocator, Ordering >::ConstIterator | Const iterator for map
csRedBlackTree< K, Allocator, Ordering >::ConstReverseIterator | Const reverse iterator for tree
csRedBlackTreeMap< K, T, Allocator, Ordering >::ConstReverseIterator | Const reverse iterator for map
CS::Utility::ImportKit::Container | Contains multiple models
CS::RenderManager::RenderTree< TreeTraits >::ContextNode | A single context node, Groups meshes which should be rendered from the same view to the same target
CS::RenderManager::RenderTreeStandardTraits::ContextNodeExtraDataType | Any extra data that should be defined for each context node
CS::RenderManager::StandardPortalSetup< RenderTreeType, ContextSetup >::ContextSetupData | Data 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::ControlPoint | This structure defines a control point
CS::Graphics::CoreRenderMesh | Data required by the renderer to draw a mesh
CS::CowWrapper< T, MemoryAllocator > | Copy-on-write wrapper for arbitrary types
CS::Utility::Checksum::CRC32 | Compute CRC32 checksum for some data
csAddonReference | An object representing an addon
csAlphaMode | Describes how to deal with alpha values in textures
csAnimatedPixmap | A pixmap with a 2d animation
csAnimationTemplate | A 2d animation template. This class is used to create animated pixmaps
csAnsiParser | Helper to parse a string for ANSI codes
csApplicationFramework | Application framework class
csApplicationRunner< T > | Helper template to run a csApplicationFramework-derived application class
csArchive | This class can be used to work with standard ZIP archives
csArray< T, ElementHandler, MemoryAllocator, CapacityHandler > | A templated array class
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
csArrayThresholdVariable | CsArray variable threshold for capacity handlers
csBakeKeyColor | Functions to bake keycolor into the alpha channel of images
csBaseEventHandler | Base implementation of a generic event handler
csBaseRenderStepLoader | Base class for render step loaders
csBaseRenderStepType | Base class for render step loaders
csBaseTextureFactory | Base class for texture factories, with support for common parameters
csBigEndian | Big endian to native conversion routines
csBitArray | A one-dimensional array of bits, similar to STL bitset
csBitArrayTweakable< InlinedBits, Allocator > | A one-dimensional array of bits, similar to STL bitset
csBitmapMetrics | Metrics for a glyph that are dependent from whether a simple or antialiased image is used
csBitmaskToString | Small helper to get a "pretty" string for a combination of bit masks
csBlockAllocator< T, Allocator, ObjectDispose, 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
csBox2 | A bounding box in 2D space
csBox2Int | A 2D bounding box with integer coordinates
csBox3 | A bounding box in 3D space
csBoxClipper | Able to clip convex polygons to a rectangle (such as the screen)
CS::RenderManager::StandardPortalSetup_Base::PersistentData::csBoxClipperCached | Cache-helper for box clipper caching
csBSpline | A B-spline
csBSPTree | This BSP-tree is a binary tree that organizes a triangle mesh
csCallStack | Call stack
csCallStackHelper | Helper to create a call stack
csCatmullRomSpline | A CatmullRom spline
csChainHull2D | This is Andrew's monotone chain 2D convex hull algorithm
csClipInfo | Structure for use with ClipToPlane
csClipper | Abstract parent to all 2D clipping objects
csCLQAttenuation | Constant, Linear, Quadratic attenuation Out = in /(const + distance*lin + distance^2*quad)
csColliderActor | With csColliderActor you can more easily manage collision detection of a player or character model with gravity handling
csColliderHelper | This is a class containing a few static member functions to help work with csColliderWrapper and collision detection in general
csColliderWrapper | This is a convenience object that you can use in your own games to attach an iCollider object (from the CD plugin system) to any other csObject (including CS entities)
csCollisionPair | A structure used to return collision pairs
csColor | A class used to represent a color in RGB space
csColor4 | A class used to represent a color in RGBA space
csColorQuantizer | Color quantizer
csCommandEventData | Structure that collects the data a command event carries
csCommandEventHelper | Helper class to conveniently deal with command events
csCommandLineHelper | This class can be used to print the commandline help, eg when the '-help' option has been used
csCommandLineOption | Representation of a commandline option
csCommandLineParser | Utility class that makes it easier to parse the command line
csCommonImageFile | A base class for image loader plugin iImage implementations
csCommonImageFileLoader | Base image loader implementation
csComparator< T1, T2 > | A template providing various comparison and ordering functions
csComparator< const char *, const char * > | CsComparator<> specialization for strings that uses strcmp()
csComparator< csBitArray, csBitArray > | CsComparator<> specialization for csBitArray to allow its use as e.g
csComparator< csInputDefinition, csInputDefinition > | CsComparator<> specialization for csInputDefinition to allow its use as e.g
csComparator< csRGBcolor *, csRGBcolor * > | CsComparator<> specialization for csColor*
csComparator< csRGBcolor, csRGBcolor > | CsComparator<> specialization for csRGBcolor
csComparator< csString, csString > | CsComparator<> specialization for csString that uses strcmp()
csComparatorBitArray< BitArray > | Base comparator for bit arrays
csComparatorString< T > | Template that can be used as a base class for comparators for string types
csComparatorStruct< T > | Template that can be used as a base class for comparators for POD (plain old data) types
csCompressVertex | This structure is used by csVector3Array::CompressVertices()
csCompressVertexInfo | This structure is used by csVertexCompressor::Compress()
csConfigAccess | This is a simple convenience class that can be used to deal with the sytem config manager
csConfigDocument | IConfigFile implementation for configurations stored in documents
csConfigFile | Configuration file which implements the iConfigFile SCF interface
csConfigManager | A configuration manager makes a number of individual iConfigFile objects appear to be a single configuration object
csConstPtrKey< T > | A helper template to use const pointers as keys for hashes
csCoverageTile | Coverage tile
csCtoW | Helper class to convert char* (UTF-8 encoded )to wchar_t* strings for use as function parameters
csCubicSpline | A cubic spline
csCursorConverter | Helper class to convert images into data formats suitable for mouse cursor creation on various platforms and toolkits
csDebugImageWriter | Helper class allowing in debug builds for to quickly dump an iImage object onto disk for visual inspection
csDIntersect3 | Some functions to perform various intersection calculations with 3D line segments
csDirectionalLightProc< AttenuationProc > | Preform directional light lighting calculation without shadowing
csDirectXError | Obtain symbols and descriptions for DirectX error codes
csDirtyAccessArray< T, ElementHandler, MemoryAllocator, CapacityHandler > | A templated array class
csDirtyAccessArrayRefCounted< T, ElementHandler, MemoryAllocator, CapacityHandler > | A variant of csDirtyAccessArray with reference-counted contents
csDMath3 | Various assorted 3D mathematical functions
csDMatrix3 | A 3x3 matrix
csDocumentAttributeCommon | Partial iDocumentAttribute implementation with commonly duplicated logic
csDocumentNodeCommon | Partial iDocumentNode implementation with commonly duplicated logic
csDocumentNodeReadOnly | Partial iDocumentNode implementation with commonly duplicated logic and dummy implementations for manipulation methods
csDPlane | A plane in 3D space
csDSquaredDist | Some functions to perform squared distance calculations
csDualQuaternion | Dual quaternion is a combination q = q0 + e*qe where e is the dual identity element (e^2 = 0) For the background, read "Preliminary Sketch of Biquaternions" [W Clifford, 1873]
csDVector3 | A 3D vector
csEllipsoid | This class represents an ellipsoid
csEmptyDocumentAttributeIterator | Document attribute iterator does not return any attributes
csEmptyDocumentNodeIterator | Document node iterator does not return any nodes
csEngineTools | This is a class with static helper functions for working on engine data
csEvent | This class represents a system event
csEventCord | Event cord
csEventFlattener | Standard event flattener(also known as serializer)
csEventHandlerRegistry | The csEventHandlerRegistry maintains a global one-to-one mapping from strings to csHandlerIDs, and a one-to-(zero or one) mapping from csHandlerIDs to iEventHandler pointers
csEventNameRegistry | The csEventNameRegistry transforms textual event names (e.g., "crystalspace.input.joystick.3.button") into easier-to-manage csEventID's (which, in non-debug builds, are really just csStringID's)
csEventOutlet | A class which implements the iEventOutlet interface
csEventQueue | This class represents a general event queue
csEventTimer | This class implements a timer
csEventTree | This class is used to represent the event namespace (tree)
csFIFO< T, ElementHandler, MemoryAllocator, CapacityHandler > | A FIFO implemented on top of csArray, but faster than using just a single array
csFileReadHelper | Convenience class for simple file element reading
csFileTime | File time structure - used to query and set the last-modification time of a file
csFixed16 | Encapsulation of a 16.16 fixed-point number
csFixed24 | Encapsulation of a 8.24 fixed-point number
csFixedSizeAllocator< Size, Allocator > | This class implements a memory allocator which can efficiently allocate objects that all have the same size
csFlags | Set of flags which can be accessed through masks
csFmtDefaultReader< T > | Standard format string source for csPrintfFormatter
csFmtDefaultWriter< T > | Standard formatted string destination for csPrintfFormatter
csFog | Sector fog structure
csFogInfo | Information for vertex based fog
csFogMath | Fog math utilities
csFontCache | A cache for font glyphs
csFrameDataHolder< T > | Helper template to retrieve an instance of some type that has not yet been used in a frame
csFrustum | A general frustum
csGetFromAddress | Sized data type access helpers
csGLDriverDatabase | OpenGL driver database
csGLExtensionFlags | Struct containing all GL extension test flags
csGLExtensionFunctions | Struct containing all GL extension functions
csGLExtensionManager | GL extensions manager
csGLFontCache | OpenGL font cache
csGLScreenShot | OpenGL screen shot
csGLStateCache | OpenGL state cache
csGlyphMetrics | Metrics for a glyph that are independent from whether a simple or antialiased image is used
csGradient | A simple color gradient
csGradientShade | An entry in an iGradient gradient
csGraphics2D | This is the base class for 2D canvases
csGraphics2DGLCommon | Basic OpenGL version of the 2D driver class
csGraphics3DCaps | Information about 3d renderer capabilities
csHash< T, K, ArrayMemoryAlloc, ArrayElementHandler > | A generic hash table class, which grows dynamically and whose buckets are unsorted arrays
csHashComputer< T > | Template for hash value computing
csHashComputer< const char * > | CsHashComputer<> specialization for strings that uses csHashCompute()
csHashComputer< csBitArray > | CsHashComputer<> specialization for csBitArray to allow its use as hash key type
csHashComputer< csInputDefinition > | CsHashComputer<> specialization for csInputDefinition to allow its use as hash key type
csHashComputer< 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
csHitBeamResult | Return structure for the iMeshWrapper::HitBeam() routines
csIdentStrings | Helper class that contains a list of identifiers and their names
csIEEEfloat | Convert IEEE 32-bit floats from or to native machine floats
csImageBase | Base class for iImage implementations
csImageCubeMapMaker | Wrapper class to create a cube map from a number of 2D images as the cube faces
csImageIOFileFormatDescription | Description for a file format supported by an image loader
csImageLoaderOptionsParser | Helper class to parse options strings passed to iImageIO::Save()
csImageManipulate | Helper class to manipulate iImage objects
csImageMemory | Memory image
csImageTools | Some helper functions to deal with iImage objects
csImageVolumeMaker | Wrapper class to create a volume aka 3D texture from a number of 2D images as the volume slices
csInitializer | This class contains several static member functions that can help setup an application
csInputBinder | Use this class to bind input events (keypress, button press, mouse move, etc.) to commands which are represented by an unsigned integer
csInputDefinition | This class holds a description of a physical source of input events, such as a keyboard key, mouse or joystick button, or a mouse or joystick axis
csInputDriver | Superclass of all the generic input drivers
csInputEventHelper | Helper class to conveniently pull generic data out of input events
csInstallationPathsHelper | A helper class containing a number of functions to deal with Crystal Space installation paths
csInterleavedSubBufferOptions | Structure describing the properties of the individual buffers to be interleaved
csIntersect2 | Some functions to perform various intersection calculations with 2D line segments
csIntersect3 | Some functions to perform various intersection calculations with 3D line segments
csIntersectingTriangle | An intersection triangle for CollideRay
csInverseAttenuation | Inverse linear attenuation
csJoystickDriver | Generic Joystick driver
csJoystickEventData | Structure that collects the data a joystick event carries
csJoystickEventHelper | Helper class to conveniently deal with joystick events
csKDTree | A KD-tree
csKDTreeChild | A child in the KD-tree (usually some object)
csKeyboardDriver | Generic Keyboard Driver
csKeyEventData | Structure that collects the data a keyboard event carries
csKeyEventHelper | Helper class to conveniently deal with keyboard events
csKeyValuePair | A Key Value pair
csLibraryReference | An object representing a reference to a library
csLightProperties | Light properties, as needed by the attenuation and lighting functors
csLightShaderVarCache | Helper to cache names of shader variables relevant to lighting
csLinearAttenuation | Linear attenuation
csList< T, MemoryAllocator > | A lightweight double-linked list template
csLittleEndian | Little endian to native conversion routines
csLoaderReturn | Return structure for threaded loader functions
csLoadResult | Return structure for the iLoader::Load() routines
csLockedHeightData | Locked height data
csLockedMaterialMap | Locked material data
csLockedNormalData | Locked normal data
csMapNode | A node
csMath2 | Various functions in 2D, such as 2D vector functions
csMath3 | Various assorted 3D mathematical functions
csMatrix2 | A 2x2 matrix
csMatrix3 | A 3x3 matrix
csMemFile | Essentially a raw memory buffer which implements the abstract iFile interface
csMemoryMappedIO | Defines a simple memory-mapped IO class that is portable
csMemoryMapping | Memory mapping, as returned by csMemoryMappedIO::GetData()
csMemoryPool | A quick-allocation pool for storage of arbitrary data
csMeshFactory | This is the abstract implementation of iMeshObjectFactory
csMeshObject | This is an abstract implementation of iMeshObject
csMeshOnTexture | This class manages the rendering of a mesh on a texture
csMeshType | This is the abstract implementation of iMeshObjectType
csMouseDriver | Generic Mouse Driver
csMouseEventData | Structure that collects the data a mouse event carries
csMouseEventHelper | Helper class to conveniently deal with mouse events
csNoAttenuation | No attenuation
csNodeIterator | A node iterator
csNormalCalculator | A normal calculator
csNormalizationCubeAccessor | Shader variable accessor for a normalization cubemap
csNormalMappingTools | Some helpers for stuff related to normal maps
csNullCacheManager | This is a general cache that doesn't cache anything at all
csOBB | Oriented bounding box (OBB)
csOBBFrozen | Version of the csOBB with frozen corners (for optimization purposes)
csObject | A generic csObject class
csObjectModel | Helper class to make it easier to implement iObjectModel in mesh objects
csObjectRegistry | This is an implementation of iObjectRegistry
csOptionDescription | Description of a configuration option, to be used by the iPluginConfig interfaces
csOrthoTransform | A class which defines a reversible transformation from one coordinate system to another by maintaining an inverse transformation matrix
csPackRGB | RGB data packing
csPackRGBA | RGBA data packing
csParasiticDataBuffer | A databuffer pointing into another databuffer
csParasiticDataBufferBase | Base class for pooled and unpooled parasitic data buffer
csParasiticDataBufferPooled | A databuffer pointing into another databuffer, pooled version
csPartialOrder< T > | A generic finite partial order class
csParticle | Data representation of a single particle
csParticleAux | Auxiliary data per particle, not used as often
csParticleBuffer | Buffer holder for particle buffers
csParticleParameterSet | Parameters that can be modified based on age for the linear effector (iParticleBuiltinEffectorLinear)
csPath | A path in 3D
csPathsList | Class to manage a list of paths
csPathsUtilities | A helper class with path-related utilities
csPDelArray< T, MemoryAllocator, CapacityHandler > | An array of pointers
csPen | A pen specialized for CS
csPhysicalFile | An implementation of the abstract iFile interface for real files within the physical filesystem
csPixelCoord | Simple 2D pixel coordinate
csPixmap | This class is an simple set of inline routines good as an abstraction for simple 2D sprites
csPlane2 | A plane in 2D space
csPlane3 | A plane in 3D space
csPlatformMemoryMappingDummy | Memory mapping for platforms without memory mapping support - it does nothing, so the software emulation kicks in when csMemoryMappedIO is used
csPlatformMemoryMappingPosix | Memory mapping for platforms with POSIX mmap() support
csPlatformMemoryMappingWin32 | Memory mapping for Win32
csPluginLoader | This utility class helps to load plugins based on request, config file, and commandline
csPluginManager | This is the standard implementation of the plugin manager
csPluginReference | An object representing a reference to a library
csPluginRequest | This class represents a single plugin request for csInitializer::RequestPlugins()
csPointLightProc< AttenuationProc > | Preform pointlight lighting calculation without shadowing
csPoly2D | The following class represents a general 2D polygon
csPoly2DFactory | This factory is responsible for creating csPoly2D objects or subclasses of csPoly2D
csPoly2DPool | This is an object pool which holds objects of type csPoly2D
csPoly3D | The following class represents a general 3D polygon
csPolygonClipper | Can be used for clipping any polygon against any other convex polygon
csPolyIndexed | The following class represents a general polygon
csPoolEvent | This class is a system event designed for the pool system
csPrefixConfig | This is an implementation of iConfigFile that stores an ID string at construction, which it then prepends to all config keys on read/write operations
csPrimitives | A primitive mesh generator
csPrintfFormatter< Twriter, Treader > | Templated class for printf()-style string formatting
csProcAnimated | Procedural texture for animated images
csProcTexture | Generic superclass for procedural textures
csProgressPulse | Simple twirling textual cursor built out of the characters '-', '\', '|', and '/'
csPtr< T > | A pointer encapsulator
csPtrKey< T > | A helper template to use pointers as keys for hashes
csPtrWrap< T > | Simple pointer wrapper class
csQuaternion | Class for a quaternion
csRadixSorter | A radix-sorter for signed and unsigned integers as well as floats
csRandomFloatGen | Fast simple random number generator for floating point values
csRandomGen | Portable random number generator class
csRandomVectorGen | Random number generator that generates random vector with spherical distribution
csRealisticAttenuation | Inverse quadratic attenuation
csRect | Rectangle class: simple class for manipulating 2D rectangles
csRectRegion | A rect region is a class that implements splittable 2d rectangles
csRedBlackTree< K, 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
csRefCount | This is a class which provides basic reference-counting semantics
csRefTrackerAccess | Helper to facilitate access to the global reference tracker
csRegExpMatch | Information about (sub)expression matches
csRegExpMatcher | Matcher for regular expressions
csRenderBuffer | Render buffer - basic container for mesh geometry data
csRenderBufferHolder | Holder of standard renderbuffers
csRenderBufferLock< T, TbufferKeeper > | Helper class for convenient locking/unlocking of an iRenderBuffer
csRenderContext | This structure keeps track of the current render context
csRenderMeshHolder | Helper class to retrieve an unused csRenderMesh
csRenderMeshList | This class is used when we need to store, sort and then render a list of rendermeshes
csRenderStepParser | Parser for render steps and render step lists
csReporterHelper | Helper class for csReport()
csReversibleTransform | A class which defines a reversible transformation from one coordinate system to another by maintaining an inverse transformation matrix
csRGBcolor | An RGB color
csRGBpixel | An RGB pixel
csSafeCopyArray< T, Allocator, CapacityHandler > | Convenience class to make a version of csArray that does a safe-copy in case of reallocation of the array
csSaverFile | An object containing information about where to save a file
csSchedule | Easy way to get timers in applications
csScreenBoxResult | Return structure for iMeshWrapper::GetScreenBoundingBox()
csScreenTargetResult | This structure is returned by csEngineTools::FindScreenTarget()
csScriptCommon | This intermediate class can be subclassed by implementors of iScript
csScriptObjectCommon | This intermediate class can be subclassed by implementors of iScriptObject
csSectorHitBeamResult | Return structure for the iSector::HitBeam() and iSector::HitBeamPortals() routines
csSectorVisibleRenderMeshes | Container for render meshes for one mesh wrapper
csSegment2 | A 2D line segment
csSegment3 | A 3D line segment
csSet< T, Allocator > | This class implements a basic set for objects
csSetToAddress | Sized data type access helpers
csShaderExpression | An evaluable expression attached to a shader variable
csShaderExpressionAccessor | Shader variable accessor that evaluates a shader expression when the SV value is queried
csShaderMetadata | Shader metadata
csShaderProgram | Base class for iShaderProgram plugins
csShaderVarBlockAlloc< ObjectDispose > | A block allocator for shader variables
csShaderVariable | Storage class for "shader vars", inheritable variables in the shader system
csShaderVariableContext | Complete SCF class implementing iShaderVariableContext
csShaderVariableFrameHolder | Helper class to obtain a shader variable that was guaranteedly not used in a frame yet
csShaderVariableStack | A "shader variable stack"
csShaderVarMapping | Mapping of a shader variable to some shader-specific destination
csShortestDistanceResult | Result structure for csEngineTools::FindShortestDistance()
csSimplePixmap | This is the simple implementation of csPixmap that uses a single texture
csSimpleRenderMesh | A simple render mesh
csSndSysSoundFormat | The sound format
csSolidSpace | This structure keeps track of solid space
csSparse3D | General 3D sparse matrix class
csSphere | This class represents a sphere
csSpline | A spline superclass
csSpotLightProc< AttenuationProc > | Perform spotlight lighting calculation without shadowing
csSprite2DVertex | A single 2D Sprite vertex
csSquaredDist | Some functions to perform squared distance calculations
csString | Thin wrapper around csStringFast with its default buffer size
csStringArray | An array of strings
csStringBase | This is a string class with a range of useful operators and type-safe overloads
csStringFast< LEN > | Subclass of csStringBase that contains an internal buffer which is faster than the always dynamically allocated buffer of csStringBase
csStringHashReversible | A csStringHash providing a reverse hash for fast string lookups when given an ID
csStringReader | This is a convenience class that reads an input buffer line by line
csSwapBytes | Methods to unconditionally swap the byte order of specifically sized types
csTerrainColliderCollideSegmentResult | Return structure for the iTerrainCollider::CollideSegment(iTerrainCell*, const csVector3&, const csVector3&) routine
csTestRectData | A structure used by csTiledCoverageBuffer::TestRectangle() and initialized by csTiledCoverageBuffer::PrepareTestRectangle()
csTextProgressMeter | Displays a simple percentage-style textual progress meter
csTiledCoverageBuffer | The tiled coverage Buffer
csTinyDocumentSystem | This is an SCF compatible wrapper for the TinyXml parser in csutil
csTraceBeamResult | Return structure for the csColliderHelper::TraceBeam() method
csTransform | A class which defines a transformation from one coordinate system to another
csTreeNode | A generic tree class
csTriangle | A triangle
csTriangleLODAlgo | Algorithm class that calculates the cost of a vertex
csTriangleLODAlgoEdge | This subclass of csTriangleLODAlgo uses a very simple cost metric to calculate the vertex cost
csTriangleMesh | A mesh of triangles
csTriangleMeshBox | A convenience triangle mesh implementation that represents a cube
csTriangleMeshEdge | A definition of one edge
csTriangleMeshLOD | A static class which performs the calculation of the best order to do the collapsing of a triangle mesh
csTriangleMeshPointer | A convenience triangle mesh which takes vertex and triangle pointers from another source
csTriangleMeshTools | A set of tools to work with iTriangleMesh instances
csTriangleMinMax | A triangle with minimum/maximum information on x
csTriangleVertex | The representation of a vertex in a triangle mesh
csTriangleVertexCost | The representation of a vertex in a triangle mesh
csTriangleVertices | A class which holds vertices and connectivity information for a triangle mesh
csTriangleVerticesCost | A class which holds vertices and connectivity information for a triangle mesh
csTriangleVerticesSorted | This class works closely with csTriangleVerticesCost and maintains a sorted (on cost) view of the vertices
csTriangulate2 | This triangulates a simple polygon
csTuple2< First, Second > | A two length tuple (fixed size collection of elements) Tuples are typically used for quickly bounding grouped values around with a low overhead
csTypedObjectIterator< T > | Typed object iterator class
csUnicodeTransform | Contains functions to convert between several UTF encodings
csUserRenderBufferManager | Helper class to manage multiple render buffers, usually provided by the user
csVariant | Variant, ie a value whose type is set at runtime
csVector2 | A 2D vector
csVector3 | A 3D vector
csVector3Array | This is actually the same class as csPoly3D
csVector4 | A 4D vector with "float" components
csVector4T< T > | A 4D vector with variable type components
csVerbosityManager | Default iVerbosityManager implementation
csVerbosityParser | Utility for parsing verbosity flags such as those provided by the `--verbose=flags` command-line option
csVertexCompressor | A vertex compressor
csVertexLightCalculator< LightProc > | IVertexLightCalculator implementation that takes one of csPointLightProc, csDirectionalLightProc or csSpotLightProc for LightProc to compute lighting for a light of the respective type
csVertexListWalker< Tbase, Tcomplex > | Helper class to make it easier to iterate over elements from renderbuffers, with automatic conversion to Tbase
csVertexStatus | The clipper can output additional information about each vertex in output polygon
csVfsCacheManager | This is a general cache that can cache data on VFS
csVfsDirectoryChanger | Helper class to change the current VFS directory and restore the previous directory when an instance goes out of scope
csView | Encapsulates the top-level Crystal Space renderer interface
csVirtualClock | This is an implementation of a virtual clock
csWeakRef< T > | A weak reference
csWeakRefArray< T, 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
csWideSparse3D | This implementation of csSparse3D is very suited where the accesses will be very widely spaced (for example: one element at (-1000,0,0) and one at (1000,0,0))
csWin32CustomCursors | Class to create native Win32 mouse cursors from images
csWin32RegistryConfig | An iConfigFile, storing the settings in the Windows registry
cswinCallStackHelper | Call stack creation helper (Win32-specific)
cswinCtoA | Small helper to convert an UTF-8 to an ANSI string, useful when passing arguments to a function
cswinWtoA | Small helper to convert a wide to an ANSI string, useful when passing arguments to a function
csWtoC | Helper class to convert wchar_t* to char* (UTF-8 encoded) strings for use as function parameters
csXRotMatrix3 | An instance of csMatrix3 that is initialized as a rotation about X
csXScaleMatrix3 | An instance of csMatrix3 that is initialized to scale the X dimension
csYRotMatrix3 | An instance of csMatrix3 that is initialized as a rotation about Y
csYScaleMatrix3 | An instance of csMatrix3 that is initialized to scale the Y dimension
csZRotMatrix3 | An instance of csMatrix3 that is initialized as a rotation about Z
csZScaleMatrix3 | An instance of csMatrix3 that is initialized to scale the Z dimension
CS::Math::Noise::Module::Curve | Noise module that maps the output value from a source module onto an arbitrary function curve
CS::Memory::CustomAllocated | Class that overrides operator new/operator delete/etc
CS::Memory::CustomAllocatedDerived< T > | Class that overrides operator new/operator delete/etc
CS::Math::Noise::Model::Cylinder | Model that defines the surface of a cylinder
CS::Math::Noise::Module::Cylinders | Noise module that outputs concentric cylinders
CS::DataBuffer< Allocator > | This is an implementation of iDataBuffer interface
csFixedSizeAllocator< Size, Allocator >::DefaultDisposer | Default disposer mixin, just reporting leaks
CS::Container::DefaultRedBlackTreeAllocator< K > | Default allocator for red black trees
CS::Utility::DemoApplication | Crystal Space demo application framework class
CS::Geometry::DensityTextureMapper | Density 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::DigestFormat | Helper class to provide Digest<> formatting methods
CS::Math::Noise::Module::Displace | Noise 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::Entry | This structure contains information about a plugin path
csBaseEventHandler::EventHandlerImpl | Actual iEventHandler implementation
CS::Math::Noise::Module::Exponent | Noise 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::File | Functions 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::FixedSizeBestChoiceLRUPolicy | LRU 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::FixedSizeLRUPolicy | LRU 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::FixedSizePseudoLRUPolicy | LRU policy using bit-tree base pseudo-LRU
csFontCache::FontDeleteNotify | Font deletion callback
FrameBegin3DDraw | FrameBegin3DDraw 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_Base | Base class for FramebufferTex, containing types and members which are independent of the template arguments that can be provided to FramebufferTex
FramePrinter | FramePrinter handles every csevFrame event in the FRAME (final) phase
CS::Geometry::GeneralMeshBuilder | Tools related to creating genmesh instances and factories
CS::Utility::GenericResourceCache< T, _TimeType, _ResourceSorting, _ReuseCondition, _PurgeCondition > | Generic cache for resources
getopt_option | Describe the long-named options requested by the application
CS::Container::WeakKeyedHash< T, K, ArrayMemoryAlloc, ArrayElementHandler >::GlobalIterator | An iterator class for WeakKeyedHash
csHash< T, K, ArrayMemoryAlloc, ArrayElementHandler >::GlobalIterator | An iterator class for the csHash class
csSet< T, Allocator >::GlobalIterator | An iterator class for the set
csFontCache::GlyphCacheData | Some basic data associated with a glyph
CS::Utility::GraphEdge | Represent an edge in a graph
CS::Container::HashElement< T, K > | An element of a hash
CS::RenderManager::HDRHelper | To help setting up a post effects manager for HDR rendering
CS::RenderManager::HDRSettings | Read HDR settings from a config file
CS::Memory::Heap | A separate heap from which memory can be allocated
CS::Memory::HeapAccessPointer< HeapContainer > | Heap accessor for AllocatorHeapBase
CS::Physics::Bullet::HitBeamResult | Return structure for the CS::Physics::Bullet::iDynamicSystem::HitBeam() routine
iAddonReference | This interface represents a reference to an addon
CS::Memory::iAllocator | Allocator interface
CS::Physics::Bullet::iAnchorAnimationControl | This class can be implemented in order to update the position of an anchor of a CS::Physics::Bullet::iSoftBody
iAnimatedImage | If an image file has animation capabilities, then this interface is exhibited
CS::Mesh::iAnimatedMesh | State and setting for an instance of an animated mesh
CS::Mesh::iAnimatedMeshFactory | State of an animated mesh object factory
CS::Mesh::iAnimatedMeshMorphTarget | A morph target
CS::Mesh::iAnimatedMeshSocket | Sockets attached to animated meshes
CS::Mesh::iAnimatedMeshSocketFactory | Factory for sockets attached to iAnimatedMesh's
CS::Mesh::iAnimatedMeshSubMesh | Sub mesh (part) of an animated mesh
CS::Mesh::iAnimatedMeshSubMeshFactory | Sub mesh (part) of an animated mesh factory
iAnimTimeUpdateHandler | By default, csSpriteCal3DMeshObject::Advance() updates the model's via CalModel::update() with the elapsed time since the last advancement
iArrayChangeAll< T > | Array interface template, completely changeable
iArrayChangeElements< T > | Array interface template, elements are changeable
iArrayReadOnly< T > | Array interface template, read-only
iBase | This is the basic interface: all other interfaces should be derived from this one, this will allow us to always use at least some minimal functionality given any interface pointer
iBaseHalo | This is the basic interface for all types of halos
iBinaryLoaderPlugin | This is a binary plugin for the loader
iBinarySaverPlugin | }
CS::Physics::Bullet::iBody | A generic body in Bullet's dynamic simulation
CS::Animation::iBodyBone | A body bone holds the physical description of the bone of an animated mesh
CS::Animation::iBodyBoneCollider | These are the properties of the collider associated to a bone
CS::Animation::iBodyBoneJoint | These are the properties of the joint associated to a bone
CS::Animation::iBodyBoneProperties | These are the main properties of a bone's rigid body
CS::Animation::iBodyChain | A body chain is a subtree of the skeleton of an animated mesh
CS::Animation::iBodyChainNode | A node in a body chain tree
iBodyGroup | Body Group is a collection of bodies which don't collide with each other
CS::Animation::iBodyManager | A class to manage the creation and deletion of bodies' skeletons
CS::Animation::iBodySkeleton | This class holds the physical description of the skeleton of an animated mesh
iBugPlug | Using this interface you can communicate with the BugPlug plugin
iBugPlugRenderObject | An application/module can implement this interface to render something
iCacheManager | A generic cache system
iCamera | Camera class
iCameraListener | Implement this interface if you are interested in learning when the camera changes sector or moves
CS::Utility::iCameraManager | A generic tool to control the motion of the camera through the keyboard and/or the mouse
iCameraPosition | A camera position
iCameraPositionList | A list of camera position objects
iCameraSectorListener | Implement this interface if you are interested in learning when the camera changes sector
iCEGUI | Interface for the CS CEGUI wrapper
iClipper2D | This interfaces represents a 2D clipper for polygons
iColladaConvertor | Representation of a convertor from COLLADA files to Crystal Space files
iCollection | A collection is used to store related objects in a simple structure to guarentee that they won't be freed by the engine and to help management
iCollectionArray | Used for a readonly array of csRef<iCollection>
iCollider | A mesh collider
iCollideSystem | This is the Collide plug-in
iCommandLineParser | A utility class that makes it easier to parse the command line
iComponent | This interface describes a generic component in Crystal Space
iConfigFile | Configuration file interface
iConfigIterator | Iterator which allows sequential access to configuration information contained in an iConfigFile object
iConfigListener | Configuration listener interface
iConfigManager | The configuration manager is used to make a number of iConfigFile object appear like a single object
iConfigNotifier | Configuration notifier interface
iConsoleExecCallback | Command execution callback
iConsoleInput | This is a plugin that can handle keyboard input and display it on an associated console
iConsoleOutput | This is the Crystal Space Console interface
iConsoleWatcher | This interface is implemented by objects interested in knowing when the console's visibility status has changed
CS::Platform::Win32::IconTools | Helpers for dealing with Windows icons
iCrossHalo | This is a halo which resembles a cross
iCursor | This interface is used to access the custom cursor plugin, which handles processing for displaying pixmaps as cursors
iCustomMatrixCamera | An implementation of iCamera that renders a world with a custom projection matrix
iDataBuffer | The iDataBuffer interface can be used to exchange buffers with abstract data between plugins
iDebugHelper | Some object that wants to implement unit testing, debugging and/or benchmarking can implement this interface
iDecal | A decal created by the iDecalManager
iDecalAnimationControl | A decal animation control, to be used by the iMeshObject when the vertices of the decal have to be animated
iDecalBuilder | Interface for mesh objects to use to build decals for their mesh object
iDecalManager | Creates and manages decals
iDecalTemplate | Interface for a decal template which dictates the appearance of a newly created iDecal
iDocument | Representation of a document containing a hierarchical structure of nodes
iDocumentAttribute | An attribute for an iDocumentNode
iDocumentAttributeIterator | An iterator over iDocumentNode attributes
iDocumentNode | Representation of a node in a document
iDocumentNodeIterator | An iterator over iDocumentNode
iDocumentSystem | An iDocument factory
iDynamics | This is the interface for the actual plugin
iDynamicsColliderCollisionCallback | This is the interface for attaching a collision callback to a collider
iDynamicsCollisionCallback | This is the interface for attaching a collider callback to the body
CS::Debug::iDynamicsDebuggerManager | Creation of dynamic system debuggers
iDynamicsMoveCallback | This is the interface for a dynamics move callback
iDynamicsStepCallback | This is the interface for a dynamics step callback, eg when a step is performed in the simulation
iDynamicsSystemCollider | This is the interface for a dynamics system collider
iDynamicSystem | This is the interface for the dynamics core
CS::Physics::Bullet::iDynamicSystem | The Bullet implementation of iDynamicSystem also implements this interface
CS::Debug::iDynamicSystemDebugger | A class to help visualization and debugging of physical simulations made through the iDynamicSystem plugin
iEmitBox | Box value emitter - returns points in an (axis aligned) box
iEmitCone | Cone value emitter - returns points in a cone
iEmitCylinder | Cylinder value emitter - returns values in a cylinder
iEmitCylinderTangent | Cylinder tangential value emitter - gives direction tangential to cylinder Uses the given point, gives a tangential direction for that
iEmitFactoryState | This interface describes the API for the emitter mesh factory object
iEmitFixed | Fixed value emitter - returns a particular point value
iEmitGen3D | This interface is for objects that can generate 3d vectors, which are used for emitting
iEmitLine | Line value emitter - returns values on the line between start and end
iEmitMix | Mix value emitter - returns a weighted random mix of other emitters
iEmitSphere | Sphere value emitter - returns points in a sphere
iEmitSphereTangent | Sphere tangential value emitter - gives direction tangential to sphere Uses the given point, gives a tangential direction for that
iEmitState | This interface describes the API for the emitter mesh object
iEngine | This interface is the main interface to the 3D engine
iEngineFrameCallback | A callback that will be fired whenever the engine starts drawing a frame
iEngineSectorCallback | A callback that will be fired whenever a sector is created or removed from the engine
iEngineSequenceManager | Sequence manager specifically designed for working on the engine
iEngineSequenceParameters | An interface for passing on parameters to the engine sequence manager
iEvent | This interface describes any system event
iEventAttributeIterator | Event attribute iterator
iEventCord | The iEventCord is an interface provided by an event queue to any event handlers wanting to receive some subclasses of events ASAP in a specified priority, bypassing the queue itself
iEventHandler | This interface describes an entity that can receive events
iEventHandlerRegistry | This interface represents a general event handler registry/resolver
iEventNameRegistry | This interface represents a general event name resolver
iEventOutlet | The iEventOutlet is the interface to an object that is provided by an event queue to every event plug when it registers itself
iEventPlug | Event plug interface, also referred as "event source"
iEventQueue | This interface represents a general event queue
iEventTimer | A timer
iFactory | IFactory is an interface that is used to create instances of shared classes
iFile | A replacement for FILE type in the virtual file space
iFireTexture | Interface to the 'fire' procedural texture
iFlareHalo | This is a halo which resembles a (solar) flare
iFont | A font object
iFontDeleteNotify | Called before a font is deleted
iFontServer | A font server interface
CS::Animation::iFurAnimatedMeshControl | Animation controller for animated mesh
CS::Animation::iFurAnimationControl | Simple Animation Controller
CS::Mesh::iFurMesh | State and setting for an instance of a fur mesh
CS::Mesh::iFurMeshFactory | State of a fur mesh object factory
CS::Mesh::iFurMeshMaterialProperties | Store the material used for the iFurMesh
CS::Mesh::iFurMeshState | Access to the properties used for the iFurMesh
CS::Mesh::iFurMeshType | This plugin describes a specific type of fur mesh objects
CS::Animation::iFurPhysicsControl | Controller that updates the iFurMesh's geometry
iGeneralFactoryState | This interface describes the API for the general mesh factory
iGeneralFactorySubMesh | A submesh of a genmesh factory
iGeneralFactorySubMeshObject | An instance of a submesh of a genmesh factory
iGeneralMeshCommonState | The common interface between genmesh meshes and factories
iGeneralMeshState | This interface describes the API for the general mesh object
iGeneralMeshSubMesh | A submesh of a genmesh
iGenericRenderStep | A generic render step
iGenMeshAnimationControl | Implementing this class allows to control the animation of the vertex, texel, normal, color and bounding box data of the genmesh
iGenMeshAnimationControlFactory | This class is a factory for creating animation controls
iGenMeshAnimationControlState | This interface describes the API for setting up the animation control as implemented by the 'gmeshanim' plugin
iGenMeshAnimationControlType | This class is the animation control type
iGenMeshSkeletonControlState | This interface describes the API for setting up the skeleton animation control as implemented by the 'gmeshskelanim' plugin
iGradient | A simple color gradient
iGradientShades | An array of gradient shades
iGraphics2D | This is the interface for 2D renderer
iGraphics3D | This is the standard 3D graphics interface
iGraphicsMemory | This is the interface used to access the csGraphicsMemory plugin
iHalo | IHalo: used to render halos (aka "light globes")
iHazeFactoryState | This interface describes the API for the sprite factory mesh object
iHazeHull | A mesh specially meant for use by the haze
iHazeHullBox | A predefined hull
iHazeHullCone | A predefined hull
iHazeHullCreation | This interface is implemented by the haze factory in order to be able to create the predefined haze hulls
iHazeState | This interface describes the API for the sprite factory mesh object
iHierarchicalCache | A generic, hierarchical cache system
CS::Utility::iHUDManager | A 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
iImage | The iImage interface is used to work with image objects
iImageFileLoader | An image file loader
iImageIO | The iImageIO interface is used to save and load graphic files
iImposterFactory | IImposterFactory defines the interface a mesh factory must implement for its meshes to be used as imposters by the engine
iInputBinder | SCF interface for csInputBinder, used to bind input events (keypress, button press, mouse move, etc.) to commands which are represented by an unsigned integer
iJob | A unit of work passed to iJobQueue
iJobQueue | Interface to simple job management system
iJoint | A joint that can constrain the relative motion between two iRigidBody
iJoystickDriver | Generic Joystick driver
iKDTreeObjectDescriptor | If you implement this interface then you can give that to the KDtree
iKDTreeUserData | The data type for user data to be attached to the KDTree
iKeyboardDriver | Generic Keyboard Driver
iKeyComposer | Keyboard input handler
iKeyValuePair | A Key Value pair
CS::Physics::Bullet::iKinematicCallback | A callback to be implemented when you are using kinematic bodies
iKitchenSink | Interface to interact with a kitchen sink
iLibraryReference | This interface represents a reference to a library file
iLight | The iLight interface is the SCF interface for the csLight class
iLightCallback | Set a callback which is called when this light color is changed
iLightIterator | Iterator to iterate over all static lights in the engine
iLightIterRenderStep |
iLightList | This structure represents a list of lights
iLightManager | An engine (3D or iso) can implement this interface for the benefit of mesh objects so that they can request lighting information from the engine
iLightningFactoryState |
iLightRenderStep |
iLightVisibleCallback | A callback that is fired whenever a light is visible
iLoader | This interface represents the map loader
iLoaderContext | This interface gives the context for the loader
iLoaderPlugin | This is a plugin for the loader based on document tree
iLODControl | The iLODControl interface represents an object that has controllable Level Of Detail (LOD) features
CS::ImageAutoConvert | Small wrapper class to automatically convert an image into a different storage format, if needed
iMapNode | A node
iMaterial | This class represents a material as seen from the engine view
iMaterialArray | An array of materials
iMaterialEngine | This interface represents the engine part of the material definition
iMaterialList | This class represents a list of materials
iMaterialWrapper | A material wrapper is an engine-level object that wraps around an actual material (iMaterial)
iMemoryTracker | This interface is used with CS_MEMORY_TRACKER
iMeshDrawCallback | Set a callback which is called just before the object is drawn
iMeshFactoryList | A list of mesh factories
iMeshFactoryWrapper | A mesh factory wrapper is an engine-level object that wraps around a mesh object factory (iMeshObjectFactory)
iMeshFactoryWrapperIterator | This is an iterator mesh factory wrappers
iMeshGenerator | IMeshGenerator defines the interface for a mesh generator
iMeshGeneratorGeometry | This interface defines one piece of geometry for the mesh generator
iMeshList | A list of meshes
iMeshObject | This is a general mesh object that the engine can interact with
iMeshObjectDrawCallback | Set a callback which is called just before the object is drawn
iMeshObjectFactory | This object is a factory which can generate mesh objects of a certain type
iMeshObjectType | This plugin describes a specific type of mesh objects
iMeshWrapper | A mesh wrapper is an engine-level object that wraps around an actual mesh object (iMeshObject)
iMeshWrapperIterator | This is an iterator of mesh wrappers
iMissingLoaderData | This callback is called when the loader can't find some material, texture, factory, mesh, light, shader, or sector
iModelLoader | Some loader plugins implement this as an easier way to load a factory from code
iModifiableDataFeeder | Modifiable Terrain data feederclass
iMouseDriver | Generic Mouse Driver
iMovable | This interface represents the position and orientation of an object relative to its parent (this is the transformation between local object space of the model and world space (ie where it is in the world))
iMovableListener | Implement this class if you're interested in hearing about movable changes
iMovieRecorder | Using this interface you can communicate with the MovieRecorder plugin and programmatically start, pause and stop the recorder
CS::Utility::ImportKit | Crystal Space Import Kit
iNativeWindow | This interface represents a native window
iNativeWindowManager | This interface represents the native window manager system
iNovaHalo | This is a halo which resembles a nova
CS::Utility::InternalRefCount | This class is used to hold a reference count seperate to the normal one
iNullFactoryState | This interface describes the API for the null mesh object factory
iNullMeshState | This interface describes the API for the null mesh object
CS::InvalidStringID< Tag > | An invalid csStringID
CS::Math::Noise::Module::Invert | Noise module that inverts the output value from a source module
iObject | This interface is an SCF interface for encapsulating csObject
CS::Geometry::iObjectDescriptor | If you implement this interface then you can give that to the KDtree
iObjectIterator | This is an iterator for child objects of a csObject
iObjectModel | This interface represents data related to some geometry in object space
iObjectModelListener | Implement this class if you're interested in hearing about when the object model changes
iObjectNameChangeListener | A callback that you can implement to get notified of name changes in an iObject
iObjectRegistry | This interface serves as a registry of other objects
iObjectRegistryIterator | Use an instance of this class to iterate over objects in the object registry
iObjectWatcher | This is a generic object watcher
iObjectWatcherListener | Implement this class if you're interested in hearing about object watcher events
iODEAMotorJoint | ODE AMotor joint
iODEBallJoint | ODE ball and socket joint (contrainted translation and free rotation)
iODEDynamicState | This class exposes parameters specific to odedynam as an implementation of iDynamics
iODEDynamicSystemState | This class exposes parameters specific to odedynam as an implementation of iDynamicsSystem
iODEFrameUpdateCallback | This class can be passed in as a callback during the physics update it is only called if FrameRate is enabled
iODEGeneralJointState | General joint state
iODEHinge2Joint | ODE hinge 2 joint
iODEHingeJoint | ODE hinge joint (contrainted translation and 1 free rotation axis)
iODEJointState | General joint state
iODEUniversalJoint | A universal joint is like a ball and socket joint that constrains an extra degree of rotational freedom
iOpenGLDriverDatabase | Interface to read custom GL driver databases
iOpenGLInterface | A common interface to be implemented by the platform specific opengl canvases
iOSXAssistant | This is an interface for an object which provides assistance to MacOS/X-specific canvases and Objective-C bridging code for application run-loop support
iPagingFormerState | IPagingFormerState exposes implementation specific methods for the PagingTerraformer plugin
iParameterESM | This interface is a parameter resolver
iParticle | A iParticle can be used in particle Systems
iParticleBuiltinEffectorFactory | Factory for builtin effectors
iParticleBuiltinEffectorForce | Simple force/acceleration applied to particles
iParticleBuiltinEffectorLight | This effector will create and attach a iLight to each particle of the system
iParticleBuiltinEffectorLinColor | Simple linear interpolation of particle color based on particle lifetime
iParticleBuiltinEffectorLinear | Linear interpolation of various parameters based on particle lifetime
iParticleBuiltinEffectorVelocityField | Velocity field effector
iParticleBuiltinEmitterBase | Base interface for the emitters already built-in
iParticleBuiltinEmitterBox | An emitter spawning the new particles around a box geometry
iParticleBuiltinEmitterCone | An emitter spawning the new particles around a cone geometry
iParticleBuiltinEmitterCylinder | An emitter spawning the new particles around a cylinder geometry
iParticleBuiltinEmitterFactory | Factory for built-in emitters
iParticleBuiltinEmitterSphere | An emitter spawning the new particles around a sphere geometry
iParticleEffector | Base interface for particle effectors
iParticleEmitter | A particle emitter
iParticleState | This interface describes the API for the particle mesh object
iParticleSystem | Properties for particle system object
iParticleSystemBase | Base properties for particle system
iParticleSystemFactory | Properties for particle system factory
iPath | A path in 3D
iPen | A pen is used to draw vector shapes
iPerspectiveCamera | An implementation of iCamera that renders a world with a classical perspective
CS::Physics::Bullet::iPivotJoint | A joint to attach to a rigid body in order to manipulate it
iPluginConfig | Interface to a configurator object
iPluginIterator | An iterator to iterate over all plugins in the plugin manager
iPluginManager | This is the plugin manager
iPluginReference | This interface represents a reference to a plugin
iPortal | This is the interface to the Portal objects
iPortalCallback | When a sector is missing this callback will be called
iPortalContainer | A container for portals
iProcTexCallback | A callback for when a iTextureWrapper is used
iProcTexture | Interface to a texture factory
iProfiler | Interface to profiler
iProfilerFactory | Interface to profile factory
iProgressMeter | This is a general interface for a progress meter
iProtoFactoryState | The proto mesh is a demonstration or tutorial mesh
iProtoMeshState | This interface describes the API for the proto mesh object
iRefTracker | The reference tracker interface
iRenderBuffer | This is a general buffer
iRenderBufferAccessor | Interface for renderbuffer accessor
iRenderBufferCallback | Callback function used upon destruction of render buffer
iRenderBufferPersistence | Render buffer persistence information
iRenderLoop | Render loop
iRenderLoopManager | Render loop manager
iRenderManager | Common render manager interface
iRenderManagerPostEffects | Interface to add post-effects layers
iRenderManagerTargets | Interface for automatic view-to-texture rendering
iRenderManagerVisCull | Interface for render managers which implement a visibility culler
iRenderStep |
iRenderStepContainer | Container for render steps
iRenderStepFactory | Interface to a render step factory
iRenderStepType | Render step type
iRenderView | This interface represents all information needed to render some object in a current draw context
iReporter | This is the interface for the error/message reporter plugin
iReporterIterator | An iterator to iterate over all messages in the reporter
iReporterListener | Implement this interface if you're interested in hearing about new messages on the reporter
iRigidBody | This is the interface for a rigid body
CS::Physics::Bullet::iRigidBody | The Bullet implementation of iRigidBody also implements this interface
iSaver | This interface is used to serialize the engine contents
iSaverFile | This interface represents a CS file to save to
iSaverPlugin | This is a plugin to save with
CS::Meta::IsBaseOf< Type1, Type2 > | Check if Type1 is a base of Type2
iSceneNode | This interface represents a node in the scene graph
iSceneNodeArray | An array of scene node interfaces
iSCF | ISCF is the interface that allows using SCF functions from shared classes
iScript | This provides the interface to a scripting language interpreter
iScriptObject | This provides the interface to an object in an object-oriented scripting language
iScriptValue | This provides the interface to a value stored in the scripting language's native format, be it a numeric or string value or a reference to an object
iSector | The iSector interface is used to work with "sectors"
iSectorCallback | Set a callback which is called when this sector is traversed
iSectorIterator | An iterator to iterate over sectors
iSectorList | A list of sectors
iSectorMeshCallback | Set a callback which is called when a mesh is added or removed from this sector
iSelfDestruct | An object implementing this interface can remove itself from its 'natural parent'
iSequence | A sequence of operations tagged with relative time information
iSequenceCondition | A sequence condition
iSequenceManager | The sequence manager
iSequenceOperation | A sequence operation
iSequenceTimedOperation | A timed operation for the engine sequence manager
iSequenceTrigger | A sequence trigger
iSequenceWrapper | A sequence wrapper
iShader | Specific shader
iShaderCompiler | Compiler of shaders
iShaderDestinationResolver | Interface to allow resolution of friendly destination names
iShaderManager | A manager for all shaders
iShaderPriorityList | A list of priorities as returned by iShaderCompiler::GetPriorities()
iShaderProgram | A helper for shaders that which to use the general plugins
iShaderProgramPlugin | Plugins which provide iShaderProgram should implement this as a factory for iShaderProgram
iShaderVariableAccessor | Interface to an accessorcallback for shadervariables
iShaderVariableContext | This is a baseclass for all interfaces which provides shadervariables both dynamically and static
iShaderVarStringSet | String set for shader variable names
iSharedVariable | This class implements a refcounted value which can be shared across many objects and updated efficiently
iSharedVariableList | A list of shared variables
iSharedVariableListener | A listener so that you can get notified when a variable is changed
iSimpleFormerState | ISimpleFormerState exposes implementation specific methods for the SimpleTerraformer plugin
iSkeleton | The skeleton interface provides needed functionality of a skeleton animation
CS::Animation::iSkeleton | A skeleton instance defines the state of a CS::Mesh::iAnimatedMesh
CS::Animation::iSkeletonAnimation | Data structure for raw skeletal animations
iSkeletonAnimation | This interface provides animation of a skeleton
iSkeletonAnimationCallback | This is a callback function of an animation
iSkeletonAnimationInstance | This interface provides played animation instance of a skeleton
iSkeletonAnimationKeyFrame | The script key frame contains all bones that will be transformed in a specific time of a skeleton script
CS::Animation::iSkeletonAnimationNode | Raw animation node
CS::Animation::iSkeletonAnimationNodeFactory | Factory for raw animation nodes
CS::Animation::iSkeletonAnimCallback | A callback to be implemented if you want to be notified when the state of an animation or animation tree is changed
CS::Animation::iSkeletonAnimNode | Base type for the animation nodes in the hierarchical blending tree of the skeletal animation system
CS::Animation::iSkeletonAnimNodeFactory | Base 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::iSkeletonAnimPacket | An animation packet instance
CS::Animation::iSkeletonAnimPacketFactory | Defines a factory for a skeletal animation packet (iSkeletonAnimPacket)
CS::Animation::iSkeletonBlendNode | An animation node that blends together the sub-nodes based on their weights
CS::Animation::iSkeletonBlendNodeFactory | Factory for blend nodes, ie nodes which blend together any number of sub-nodes
iSkeletonBone | The skeleton bone class
iSkeletonBoneFactory | The skeleton bone factory is class that is used to create skeleton bones of a iSkeleton object
iSkeletonBoneUpdateCallback | This callback fires every time when bone changes it's transform
CS::Animation::iSkeletonDebugNode | An animation node that let visualize the dynamics of any animation node
CS::Animation::iSkeletonDebugNodeFactory | Factory for the 'debug' animation node (see CS::Animation::iSkeletonDebugNode)
CS::Animation::iSkeletonDebugNodeManager | A class to manage the creation and deletion of debug animation node factories
iSkeletonFactory | The skeleton factory is class that is used to create skeleton objects in the scene
CS::Animation::iSkeletonFactory | A skeleton factory is an object defining the base pose and topology from which CS::Animation::iSkeleton instances can be created
CS::Animation::iSkeletonFSMNode | An animation node that uses a Finite State Machine (FSM) to determine the animation to be played
CS::Animation::iSkeletonFSMNodeFactory | Factory for Finite State Machine (FSM) animation nodes
iSkeletonGraveyard | ISkeletonGraveyard is the interface that cares for all skeleton factories
CS::Animation::iSkeletonIKCCDNode | An implementation of the CS::Animation::iSkeletonIKNodeFactory based on a quaternion version of the Cyclic Coordinate Descent algorithm
CS::Animation::iSkeletonIKCCDNodeFactory | An implementation of the CS::Animation::iSkeletonIKNodeFactory based on a quaternion version of the Cyclic Coordinate Descent algorithm
CS::Animation::iSkeletonIKNode | An 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::iSkeletonIKNodeFactory | Factory for the Inverse Kinematics animation node
CS::Animation::iSkeletonIKNodeManager | A class to manage the creation and deletion of Inverse Kinematics animation node factories
CS::Animation::iSkeletonIKPhysicalNode | An implementation of the CS::Animation::iSkeletonIKNode based on physical simulation
CS::Animation::iSkeletonIKPhysicalNodeFactory | An implementation of the CS::Animation::iSkeletonIKNodeFactory based on physical simulation
CS::Animation::iSkeletonLookAtListener | A listener to be implemented if you want to be notified when the target has been reached or lost
CS::Animation::iSkeletonLookAtNode | An animation node that controls a bone of an animesh in order to make it look at a target
CS::Animation::iSkeletonLookAtNodeFactory | Factory for the 'LookAt' animation node
CS::Animation::iSkeletonLookAtNodeManager | A class to manage the creation and deletion of 'LookAt' animation node factories
CS::Animation::iSkeletonManager | Skeletal system base object, representing the entire skeletal and skeletal animation system
CS::Animation::iSkeletonPriorityNode | An animation node that blends together the sub-nodes based on their priority
CS::Animation::iSkeletonPriorityNodeFactory | Factory for priority blend nodes, ie nodes blending sub-nodes on the base of their current priority
CS::Animation::iSkeletonRagdollNode | An 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::iSkeletonRagdollNodeFactory | Factory for the ragdoll animation node
CS::Animation::iSkeletonRagdollNodeManager | A class to manage the creation and deletion of ragdoll animation node factories
CS::Animation::iSkeletonRandomNode | An animation node that selects randomly the sub-nodes to be played
CS::Animation::iSkeletonRandomNodeFactory | Factory for blending nodes playing randomly their sub-nodes
CS::Animation::iSkeletonRetargetNode | An animation node that can retarget an animation from one skeleton to another
CS::Animation::iSkeletonRetargetNodeFactory | Factory for the 'Retarget' animation node
CS::Animation::iSkeletonRetargetNodeManager | A class to manage the creation and deletion of 'Retarget' animation node factories
iSkeletonSocket | The skeleton socket object wraps a relative transform of a bone
iSkeletonSocketFactory | The skeleton socket factory is class that is used to create skeleton sockets of a iSkeleton object
CS::Animation::iSkeletonSpeedNode | An 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::iSkeletonSpeedNodeFactory | Factory for the 'speed' animation node
CS::Animation::iSkeletonSpeedNodeManager | A class to manage the creation and deletion of speed animation node factories
iSkeletonUpdateCallback | This is a callback function of a skeleton
CS::Meta::IsLog2< R > | Meta-programming IsLog2 function
iSndSysData | The sound data is an interface to the container object controlling raw sound data
iSndSysEventRecorder | An interface designed for the debugging needs of the sound system
iSndSysListener | The sound listener is a unique object created by the sound renderer
iSndSysListenerDoppler | Extension to the iSndSysListener interface, allowing Doppler shift effects
iSndSysLoader | The sound loader is used to load sound files given a raw input data stream
iSndSysManager | This is the sound manager for Crystal Space
iSndSysRenderer | The sound renderer is the core interface for the sound system
iSndSysRendererCallback | Sound System renderer interface for callback notification
iSndSysRendererOpenAL | OpenAL renderer specific interface extensions
iSndSysRendererSoftware | Software renderer specific interface extensions
iSndSysSoftwareDriver | This is the interface for the low-level, system-dependent sound driver that is used by the software sound renderer
iSndSysSoftwareFilter3D | A sound filter is an interface to an object that modifies sequences of sound samples
iSndSysSoftwareOutputFilter | Temporary filter interface definition
iSndSysSource | A sound source is the origin of a sound in Crystal Space
iSndSysSource3D | Extension to the iSndSysSource interface, allowing sources to be positioned in space
iSndSysSource3DDirectional | Extension to the iSndSysSource3D interface, allowing directional orientation of sound sources
iSndSysSource3DDirectionalSimple | Extension to the iSndSysSource3D interface, allowing simple directional orientation of sound sources
iSndSysSource3DDoppler | Extension to the iSndSysSource3D interface, allowing Doppler shift effects
iSndSysSourceOpenAL | Interface for OpenAL sound sources
iSndSysSourceSoftware | Sound source extensions for the software renderer
iSndSysStream | The primary interface for a sound stream used by the audio system
iSndSysStreamCallback | Sound System stream interface for callback notification
iSndSysWrapper | A wrapper/holder for a loaded sound
CS::Physics::Bullet::iSoftBody | A soft body is a physical body that can be deformed by the physical simulation
CS::Animation::iSoftBodyAnimationControl | Animation control for a genmesh animated by a CS::Physics::Bullet::iSoftBody
CS::Animation::iSoftBodyAnimationControlFactory | Animation control factory for a genmesh animated by a CS::Physics::Bullet::iSoftBody
CS::Animation::iSoftBodyAnimationControlType | Animation control type for a genmesh animated by a CS::Physics::Bullet::iSoftBody
iSprite2DFactoryState | This interface describes the API for the sprite factory mesh object
iSprite2DState | This interface describes the API for the sprite factory mesh object
iSprite2DUVAnimation | The animation works by having all frames of an animation sequence in a texture at different (u,v) locations, hence the name
iSprite2DUVAnimationFrame | This is a single frame in a UV animation
iSprite3DFactoryState | This interface describes the API for the 3D sprite factory mesh object
iSprite3DState | This interface describes the API for the 3D sprite mesh object
iSpriteAction | An action frameset for 3D sprite animation
iSpriteCal3DFactoryState | This interface describes the API for the 3D sprite factory mesh object
iSpriteCal3DSocket | A socket for specifying where sprites can plug into other sprites
iSpriteCal3DState | This interface describes the API for changing the Cal3D sprite mesh object's animations playing and other current traits
iSpriteFrame | A frame for 3D sprite animation
iSpriteSocket | A socket for specifying where sprites can plug into other sprites
CS::Meta::IsReference< Type > | Check if Type is a reference or simple type
CS::Meta::IsSame< Type1, Type2 > | Check if two types are the same
iStandardReporterListener | Interface to control the settings of the reporter listener plugin
iStreamDataCallback | This callback will be fired when the data is ready
iStreamSource | This interface represents a stream source
iString | This is a SCF-compatible interface for csString
iStringArray | This is an SCF-compatible interface for csStringArray
iStringSet | General string ID string set
iStringSetBase< Tag > | The string set is a collection of unique strings
iSyntaxService | This component provides services for other loaders to easily parse properties of standard CS world syntax
iSystemOpenManager | Manager for system open events
csArray< T, ElementHandler, MemoryAllocator, CapacityHandler >::Iterator | Iterator for the csArray class
csList< T, MemoryAllocator >::Iterator | Iterator for the list
csHash< T, K, ArrayMemoryAlloc, ArrayElementHandler >::Iterator | An iterator class for the csHash class
csRedBlackTree< K, Allocator, Ordering >::Iterator | Iterator for tree
csRedBlackTreeMap< K, T, Allocator, Ordering >::Iterator | Iterator for map
iTerraFormer | TerraFormer objects are used to retrieve terrain data
iTerrainCell | Terrain cell class
iTerrainCellCollisionProperties | This is a base class for per-cell collider-specific properties
iTerrainCellFeederProperties | This is a base class for per-cell feeder-specific properties
iTerrainCellHeightDataCallback | Callbacks for cell height data modifications
iTerrainCellLoadCallback | Callbacks for cell load/unload events
iTerrainCellRenderProperties | This is a base class for per-cell renderer-specific properties
iTerrainCollider | Provides an interface for custom collision
CS::Physics::Bullet::iTerrainCollider | A terrain collider for the dynamic simulation
iTerrainCollisionPairArray | Class for an array of csCollisionPair. Used for communication with plugins
iTerrainDataFeeder | Provides an interface for reading cell data
iTerrainFactory | Provides an interface for creating terrain system
iTerrainFactoryCell | Factory representation of a cell
iTerrainFactoryState | Allows the setting of a set of generic terrain parameters outside any specific algorithm
iTerrainModifier | Terrain modifier class
iTerrainObjectState | This will override the settings for material in the parent
iTerrainRenderer | Provides an interface for custom rendering
iTerrainSystem | This class represents the terrain object as a set of cells
iTerrainVector3Array | Class for an array of csVector3. Used for communication with plugins
iTerraSampler | TerraSampler objects are used for the actual queries of terrain data Sampler regions are requested from the iTerraFormer plugin, and sampled for data via the Sample methods
iTextureCallback | A callback for when a iTextureWrapper is used
iTextureFactory | Interface to a texture factory
iTextureHandle | A texture handle as returned by iTextureManager
iTextureList | This class represents a list of texture wrappers
iTextureLoaderContext | Interface passed to a texture loader, holding some common texture properties
iTextureManager | This is the standard texture manager interface
iTextureType | Texture type
iTextureWrapper | A texture wrapper is an engine-level object that wraps around an actual texture (iTextureHandle)
iThreadedLoader | This interface represents the threaded map loader methods
iThreadManager | This is the thread manager
iTimerEvent | A timer event
iTranslator | Translator interface
iTriangleMesh | This interface reprents a mesh of triangles
iTriangleMeshIterator | Iterator to iterate over all data mesh ID's in an object model
iUserRenderBufferIterator | Interface to iterate over all buffers stored in a csUserRenderBufferManager
iVerbosityManager | Helper interface which applications and plugins can use to determine whether they should be verbose
iVertexLightCalculator | Interface to calculate lighting for a number of vertices
iVFS | The Virtual Filesystem Class is intended to be the only way for Crystal Space engine to access the files
iView | Encapsulates the top-level Crystal Space renderer interface
iVirtualClock | A virtual game clock
iVisibilityCuller | This interface represents a visibility culling system
iVisibilityCullerListener | Implement this interface when you want to get notified about visible objects detected by the visibility cullers
iVisibilityObject | An object that wants to know if it is visible or not for some visibility culler needs to implement this interface
iVisibilityObjectIterator | Iterator to iterate over some visibility objects
CS::Debug::iVisualDebugger | Visual debugging tools
iWaterFactoryState | The water mesh is a simple mesh representation for a horizontal square
iWaterMeshState | This interface describes the API for the water mesh object
iWin32Assistant | This interface describes actions specific to the Windows platform
iWin32Canvas | This interface provides some extra functionality for Win32 canvases
iWxWindow | Interface to communicate with with a wxWidgets-based canvas
iXMLShader | Access XMLShader-specific data
iXWindow | Document me! @@
CS::Geometry::KDTree | A KD-tree
CS::Geometry::KDTreeChild | A child in the KD-tree (usually some object)
csFontCache::KnownFont | A font known to the cache
CS::RenderManager::PostEffectManager::Layer | An effect layer
CS::RenderManager::LayerHelper< RenderTree, LayerConfigType, NewLayersType > | Helper to duplicate render layers
CS::RenderManager::PostEffectManager::LayerInputMap | Custom input mapping for a layer
CS::RenderManager::PostEffectManager::LayerOptions | Options for a postprocessing layer
CS::RenderManager::LightingSorter::LightInfo | Information associated with a light
CS::RenderManager::LightingSorter | Lighting sorter
CS::RenderManager::LightingVariablesHelper | Helper class to deal with shader variables setup for lighting
CS::RenderManager::LightSettings | Compatibility 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::Line | Model that defines the displacement of a line segment
CS::RenderManager::HDR::Exposure::Linear | A simple exposure controller, just scaling color values by a factor
csList< T, MemoryAllocator >::ListElement | Template which describes the data stored in the linked list For example a list of ints uses ListElement<int>
CS::Memory::LocalBufferAllocator< T, N, ExcessAllocator, SingleAllocation > | An allocator with a small local buffer
CS::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::LRUEntry | An entry in the LRU list
csBitmaskToString::MaskNames | Structure containing a name for possible bit masks
CS::Utility::ImportKit::Container::Material | A material for a mesh
CS::Material::MaterialBuilder | Tools related to creating materials
CS::Math::Matrix4 | A 4x4 matrix
CS::Math::Noise::Module::Max | Noise module that outputs the larger of the two output values from two source modules
CS::Utility::Checksum::MD5 | Compute a MD5 message digest
CS::MeasureTime | Simple helper class to measure execution time of a block
CS::Utility::ImportKit::Container::Model::Mesh | Model mesh, contains actual geometry
CS::RenderManager::RenderTreeStandardTraits::MeshExtraDataType | Any extra data per mesh in a single mesh
CS::RenderManager::RenderTree< TreeTraits >::MeshNode | A mesh node is a single list of meshes that can be rendered in one go without any explicit order considerations
CS::RenderManager::RenderTreeStandardTraits::MeshNodeExtraDataType | Any extra data that should be defined for each mesh node
CS::RenderManager::RenderTreeStandardTraits::MeshNodeKeyType | The data type to use as node key for mesh nodes
CS::PluginCommon::ShaderCacheHelper::MicroArchive | A simple archive format
CS::PluginCommon::ShaderCacheHelper::MicroArchiveCache | IHierarchicalCache implementation storing everything in a MicroArchive
CS::Math::Noise::Module::Min | Noise module that outputs the smaller of the two output values from two source modules
CS::Animation::MocapParser | Tool for parsing motion capture ressource files and importing them into an animation data suitable for the CS::Mesh::iAnimatedMesh
CS::Animation::MocapParserResult | Return structure for CS::Animation::MocapParser::ParseData()
CS::Utility::ImportKit::Container::Model | A model
CS::Math::Noise::Module::Module | Abstract base class for noise modules
CS::RenderManager::MultipleRenderLayer | Render layer implementation providing multiple render layers
CS::Math::Noise::Module::Multiply | Noise module that outputs the product of the two output values from two source modules
CS::Threading::MutexImpl< BaseMutex > | General mutex class
CS::Animation::NameBoneMappingHelper | This helper class can generate a bone mapping by simply taking the corresponding bones that have the same name
CS::DocSystem::NodeAttributeCompare | Node comparator
CS::DocSystem::NodeAttributeRegexpTest | Check if a regular expression matches(case-insensitive) with the value of the given attribute
CS::DocSystem::NodeAttributeValueTest | Compare (case-sensitive) node attribute to given
CS::DocSystem::NodeNameCompare | Node comparator
CS::DocSystem::NodeValueTest | Compare (case-sensitive) node value to given
CS::Implementation::NonCopyable_ | Base-class which ensures that derived classes are not copy-constructible or assignable
CS::RenderManager::Implementation::NoOperationBlock< IterationObject > | Object blocker for iterator methods below
CS::Meta::Implementation::NoType | Boolean false type
CS::NumberedFilenameHelper | Helper to deal with numbered filename
CS::Math::Ode45 | Embedded Runge-Kutta 4/5th order ODE solver for non-stiff ODEs
CS::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::OperationNumbered | Give each operation a number passed along to functor. Single execution
CS::RenderManager::OperationNumberedParallel | Give 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::OperationUnordered | No forced order of operation. Single execution
CS::RenderManager::OperationUnorderedParallel | No 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::Outline | This table also contains an array of sides visible from that region
CS::Graphics::OverlayShaderVariableContextImpl | IShaderVariableContext implementation that overlays (or merges) it's variables over the variables of a given parent context
CS::SndSys::PCMSampleConverter | A PCMSampleConverter object converts PCM data from one format to another
CS::Math::Noise::Module::Perlin | Noise module that outputs 3-dimensional Perlin noise
CS::RenderManager::ShadowPSSM< RenderTree, LayerConfigType >::PersistentData | Data used by the shadow handler that needs to persist over multiple frames
CS::RenderManager::LightingVariablesHelper::PersistentData | Data used by the helper that needs to persist over multiple frames
CS::RenderManager::ShadowNone< RenderTree, LayerConfigType >::PersistentData | Data used by the shadow handler that needs to persist over multiple frames
CS::RenderManager::RenderTree< TreeTraits >::PersistentData | Data used by the render tree that needs to persist over multiple frames
CS::RenderManager::AutoFX::FramebufferTex_Base::PersistentData | Data used by the helper that needs to persist over multiple frames
CS::RenderManager::LightingSorter::PersistentData | Data used by the helper that needs to persist over multiple frames
CS::RenderManager::AutoFX::ReflectRefract_Base::PersistentData | Data used by the helper that needs to persist over multiple frames
CS::RenderManager::StandardPortalSetup_Base::PersistentData | Data used by the helper that needs to persist over multiple frames
CS::RenderManager::LightSetup< RenderTree, LayerConfigType, ShadowHandler >::PersistentData | Data used by the light setup helper that needs to persist over multiple frames
CS::RenderManager::RenderTreeStandardTraits::PersistentDataExtraDataType | Any extra data that needs to persist between frames
CS::Math::Noise::Model::Plane | Model that defines the surface of a plane
csFontCache::PlaneGlyphs | Array of a number of glyphs
CS::RenderManager::StandardPortalSetup_Base::PersistentData::PortalBufferConstraint | GenericCache-constraints for PortalBuffer caching
CS::RenderManager::StandardPortalSetup_Base::PersistentData::PortalBuffers | Cache structure for portal render buffers
CS::RenderManager::RenderTree< TreeTraits >::ContextNode::PortalHolder | Information for a portal
CS::RenderManager::PostEffectLayersParser | Helper to parse post processing effect configurations
CS::RenderManager::PostEffectManager | Helper for post processing effects usage in render managers
CS::RenderManager::PostEffectsSupport | Add post effects support to a render manager
CS::Math::Noise::Module::Power | Noise 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::Primitive | Superclass for all primitives
CS::Geometry::Primitives | A primitive mesh generator
CS::Utility::PriorityQueue< T, Container, Comparator > | An implementation of a priority queue
CS::Platform::ProcessorSpecDetection | Class performing processor specifications and feature detection
csShaderProgram::ProgramParam | Program parameter, either a SV reference or a const value
CS::Math::Projections | Helpers to create standard projections
csRenderBuffer::Props | To scrape off a few bytes use bitfields; assumes values are in sane limits
CS::Utility::ResourceCache::PurgeConditionAfterTime< TimeType > | Purge condition: a resource is purged after a certain time has passed
CS::Utility::ResourceCache::PurgeIfOnlyOneRef | Purge 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::Quote | Helper functions to decorate strings with nice-looking quote characters
CS::Threading::ReadWriteMutex | A 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_Base | Base class for ReflectRefract, containing types and members which are independent of the template arguments that can be provided to ReflectRefract
CS::RenderBufferPersistent | Render buffer wrapper with additional persistence information
CS::RenderManager::RenderCommon< RenderTree > | Common mesh render functions
CS::Graphics::RenderMesh | Mesh data as returned by mesh plugins
CS::Graphics::RenderMeshIndexRange | Start and end for a range of indices to render
CS::Graphics::RenderMeshModes | Mesh render mode information
CS::Graphics::RenderPriority | Rendering priority
CS::RenderManager::RenderTree< TreeTraits > | RenderTree is the main data-structure for the rendermanagers
CS::RenderManager::RenderTreeBase | Helper class containing stuff which doesn't require any of the template parameters to RenderTree
CS::RenderManager::RenderTreeStandardTraits | Standard traits for customizing the render tree class
CS::RenderManager::RenderView | This structure represents all information needed for drawing a scene
CS::RenderManager::RenderViewCache | Stores a cache of RenderView objects, mapped by iView objects
CS::RenderViewClipper | Helper to clip in the context of a render view
CS::Utility::ResourceCache::ReuseAlways | Reuse condition: allow immediate reuse
CS::Utility::ResourceCache::ReuseConditionAfterTime< TimeType > | Reuse condition: a resource is reused after a certain time has passed
CS::Utility::ResourceCache::ReuseConditionFlagged | Reuse condition: a resource is reused after being flagged as such
CS::Utility::ResourceCache::ReuseIfOnlyOneRef | Reuse condition: a resource is reused if only one reference is held to it
csArray< T, ElementHandler, MemoryAllocator, CapacityHandler >::ReverseConstIterator | Reverse iterator for the csArray class
csRedBlackTreeMap< K, T, Allocator, Ordering >::ReverseIterator | Reverse iterator for map
csArray< T, ElementHandler, MemoryAllocator, CapacityHandler >::ReverseIterator | Reverse iterator for the csArray class
csRedBlackTree< K, Allocator, Ordering >::ReverseIterator | Reverse iterator for tree
CS::Math::Noise::Module::RidgedMulti | Noise module that outputs 3-dimensional ridged-multifractal noise
CS::RenderManager::RMDebugCommon< RenderTreeType > | Common debug helpers in render manager plugins
CS::Utility::RootedHierarchicalCache | IHierarchicalCache providing a 'view' into a path of another cache
CS::Math::Noise::Module::RotatePoint | Noise module that rotates the input value around the origin before returning the output value from a source module
CS::Threading::Runnable | Abstract base class for objects acting as executor in separate threads
CS::Math::Noise::Module::ScaleBias | Noise module that applies a scaling factor and a bias to the output value from a source module
CS::Math::Noise::Module::ScalePoint | Noise module that scales the coordinates of the input value before returning the output value from a source module
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
scfImplementationHelper | Various helpers for scfImplementation
scfImplementationPooled< Super, Allocator, Locked > | Derive an SCF implementation from this class to have it pooled
scfInterfaceMetadata | Metadata about a single interface implemented within a class
scfInterfaceMetadataList | A chain list of metadata for interfaces implemented within a class
scfInterfaceTraits< Interface > | Interface information query class
scfString | This is a thin SCF wrapper around csString
scfStringArray | This class is a thin wrapper around csStringArray with SCF capability
CS::ScfStringSet< IF > | The string set is a collection of unique strings
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::Math::Noise::Module::Select | Noise 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::SHA256 | Compute a SHA-256 message digest
CS::PluginCommon::ShaderCacheHelper::ShaderDocHasher | Computes a hash for all referenced documents documents (ie external files pulled in via "file" attributes or ?Include? PIs) of a shader document
CS::PluginCommon::ShaderProgramPluginGL | Common 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::ShaderVariableContextImpl | Simple implementation for iShaderVariableContext
CS::ShaderVarName | Helper class to obtain an ID for a shader variable
CS::Graphics::ShaderVarNameParser | Helper 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 >::ShadowParameters | Shadow method specific parameters
CS::RenderManager::ShadowPSSM< RenderTree, LayerConfigType > | PSSM shadow handler
CS::RenderManager::ShadowSettings | Helper 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::SimpleStaticLighter | The functions in this class all provide a simple way to initialize the "static color" of a mesh (usually genmesh) to provide a way to do simple static 'lighting'
CS::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::SingleMesh | A 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::SingleRenderLayer | Render layer implementation for a single render layer
CS::Animation::SkeletonAnimNodeFactory | Base implementation of a CS::Animation::iSkeletonAnimNodeFactory
CS::Animation::SkeletonAnimNodeFactoryMulti | Base implementation of a CS::Animation::iSkeletonAnimNodeFactory with more than one child
CS::Animation::SkeletonAnimNodeFactorySingle | Base 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::SkeletonAnimNodeSingleBase | Methods of SkeletonAnimNodeSingle not dependent on the factory type
CS::Physics::Bullet::SoftBodyHelper | General helper class for CS::Physics::Bullet::iSoftBody
CS::Utility::ResourceCache::SortingNone | Resource sorting that does not sort
CS::SndSys::SoundCyclicBuffer | An implementation of a cyclic buffer oriented for sound functionality
CS::Math::Noise::Model::Sphere | Model that defines the surface of a sphere
CS::Geometry::Sphere | A sphere
CS::Math::Noise::Module::Spheres | Noise 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_Base | Base 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::StaticLightsSettings | Layer settings for handling static lights
CS::SndSys::SndSysBasicStream::StreamNotificationEvent | Structure 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::StringStoreReader | Helper to read strings written with StringStoreWriter
CS::PluginCommon::ShaderCacheHelper::StringStoreWriter | Helper to write strings in an efficient way (each string once)
CS::StructuredTextureFormat | Structured representation of a texture format
CS::SubRectangles::SubRect | Sub-rectangle
CS::SubRectangles | A class managing allocations of sub-rectangles
CS::SubRectanglesCompact | A variation of SubRectangles that tries to place rectangles in a rectangular fashion
csEventTree::SubscriberIterator | The SubscriberIterator is a wrapper for the messy internals of figuring out which event handler to call next
CS::RenderManager::SVArrayHolder | Holder for SV arrays
CS::Geometry::TableTextureMapper | Table texture mapper
CS::RenderManager::ShadowSettings::Target | Shadow map target
CS::RenderManager::DependentTargetManager< RenderTree, TargetHandler >::TargetSettings | The settings for a handle
CS::RenderManager::RenderTree< TreeTraits >::ContextNode::TargetTexture | A single render target
CS::Math::Noise::Module::Terrace | Noise module that maps the output value from a source module onto a terrace-forming curve
CS::Geometry::TesselatedBox | A Tesselated box
CS::Geometry::TesselatedQuad | A tesselated quad
CS::RenderManager::TextureCacheT< ReuseCondition, PurgeCondition > | Cache for caching precreated textures
CS::TextureFormatStrings | Texture format string parser routines
CS::Geometry::TextureMapper | Class for controlling texture mapping on the generated meshes
CS::RenderManager::PostEffectManager::DimensionData::TexturesBucket | Textures which have the same properties are managed in one "bucket"
CS::RenderManager::Implementation::TextureSizeConstraint | Helper for generic resource cache storing texture handles
CS::Threading::Thread | Object representing a separate execution thread
CS::Threading::ThreadGroup | A group of threads handled as one unit
CS::Threading::ThreadLocal< T > | Thread local storage of arbitrary C++ objects
CS::Threading::ThreadLocalBase | Thread local storage of a pointer value (void*)
CS::RenderManager::TicketSetup< RenderTree, LayerConfigType > | Default shader ticket setup
CS::Math::Noise::Module::TranslatePoint | Noise 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::Math::Noise::Module::Turbulence | Noise 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::UberScreenshotMaker | Helper to create "&uuml;berscreenshots", screenshots with a resolution larger than the current framebuffer resolution
csShaderProgram::VariableMapEntry | Holder of variable mapping
CS::Utility::VfsHierarchicalCache | This is a general cache that can cache data on VFS
CS::RenderManager::ShadowPSSM< RenderTree, LayerConfigType >::ViewSetup | Shadow per-view specific data
CS::RenderManager::Implementation::ViscullCallback< RenderTree > | Helper class implementing the visculler callback functionality and adds rendermeshes via AddRenderMeshToContext function
CS::Debug::VisualDebuggerHelper | Helper class for visual debugging tools
CS::Math::Noise::Module::Voronoi | Noise module that outputs Voronoi cells
CS::Container::WeakKeyedHash< T, K, ArrayMemoryAlloc, ArrayElementHandler > | Hash type that allows (certain) changes of key objects
CS::Utility::WeakReferenced | This is a class which provides basic weak reference-counting semantics
CS::Meta::Implementation::Wrap< T > | Simple dummy-wrapper