Crystal Space: Class List (Crystal Space Public API Reference)

| ## Public API Reference

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

- Alphabetical List
- Class List
- Class Hierarchy
- Class Members

# Crystal Space Class List

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

_csKeyModifiers | Flags for all currently pressed modifiers
ADDRESS64 |
CS::Memory::AllocatorAlign< A > | This class implements an allocator policy which aligns the first element on given byte boundary
CS::Memory::AllocatorHeap< HeapPtr > | A memory allocator that allocates from a heap
CS::Memory::AllocatorHeapBase< HeapAccess > | A memory allocator that allocates from a heap
CS::Memory::AllocatorMalloc | A default memory allocator that allocates with cs_malloc()
CS::Memory::AllocatorPointerWrapper< T, Allocator > | Class to store a pointer that is allocated from Allocator, to eliminate overhead from a possibly empty Allocator
CS::AllocPlatform |
CrystalSpace::COMPILE_ASSERT_FAILURE< x > |
CrystalSpace::COMPILE_ASSERT_FAILURE< true > |
CrystalSpace::CompileAssertTest< x > |
CS::ConditionAnd< T1, T2 > |
CS::CowWrapper< T, MemoryAllocator > | Copy-on-write wrapper for arbitrary types
csAddonReference | An object representing an addon
csAlphaMode | Describes how to deal with alpha values in textures
csAnimatedPixmap | A pixmap with a 2d animation
csAnimationTemplate | A 2d animation template. This class is used to create animated pixmaps
csAnsiParser | Helper to parse a string for ANSI codes
csAnsiParser::CommandParams | Parameters to ANSI command
csAnsiParser::CursorParams |
csApplicationFramework | Application framework class
csApplicationRunner< T > | Helper template to run a csApplicationFramework-derived application class
csArchive | This class can be used to work with standard ZIP archives
csArray< T, ElementHandler, MemoryAllocator, CapacityHandler > | A templated array class
csArray< T, ElementHandler, MemoryAllocator, CapacityHandler >::ConstIterator | Iterator for the Array<> class
csArray< T, ElementHandler, MemoryAllocator, CapacityHandler >::Iterator | Iterator for the Array<> class
csArrayCapacityDefault |
csArrayCapacityLinear< Threshold > | CsArray capacity handler
csArrayCmp< T, K > | A functor template which encapsulates a key and a comparison function for use with key-related csArray<> searching methods, such as FindKey() and FindSortedKey()
csArrayElementHandler< T > | The default element handler for csArray
csArraySafeCopyElementHandler< T > | Special element handler for csArray that makes sure that when the array is reallocated that the objects are properly constructed and destructed at their new position
csArrayThresholdFixed< N > | CsArray fixed threshold for capacity handlers
csArrayThresholdVariable | CsArray variable threshold for capacity handlers
csBakeKeyColor | Functions to bake keycolor into the alpha channel of images
csBaseEventHandler | Base implementation of a generic event handler
csBaseEventHandler::EventHandlerImpl | Actual iEventHandler implementation
csBaseRenderStepLoader | Base class for render step loaders
csBaseRenderStepType | Base class for render step loaders
csBaseTextureFactory | Base class for texture factories, with support for common parameters
csBigEndian | Big endian to native conversion routines
csBitArray | A one-dimensional array of bits, similar to STL bitset
csBitArrayTweakable< InlinedBits, Allocator > | A one-dimensional array of bits, similar to STL bitset
csBitArrayTweakable< InlinedBits, Allocator >::BitProxy |
csBitmapMetrics | Metrics for a glyph that are dependent from whether a simple or antialiased image is used
csBitmaskToString | Small helper to get a "pretty" string for a combination of bit masks
csBitmaskToString::MaskNames | Structure containing a name for possible bit masks
csBlockAllocator< T, Allocator, ObjectDispose > | This class implements a memory allocator which can efficiently allocate objects that all have the same size
csBlockAllocatorDisposeDelete< T > | Block allocator disposal mixin that just destructs an instance
csBlockAllocatorDisposeLeaky< T > | Block allocator disposal mixin that destructs, unless upon final cleanup, where a warning is emitted stating that objects leaked
csBox2 | A bounding box in 2D space
csBox2Int | A 2D bounding box with integer coordinates
csBox3 | A bounding box in 3D space
csBox3::bEdge |
csBox3::Outline | This table also contains an array of sides visible from that region
csBoxClipper | Able to clip convex polygons to a rectangle (such as the screen)
csBSpline | A B-spline
csBSPTree | This BSP-tree is a binary tree that organizes a triangle mesh
csCallStack | Call stack
csCallStackHelper | Helper to create a call stack
csCatmullRomSpline | A CatmullRom spline
csChainHull2D | This is Andrew's monotone chain 2D convex hull algorithm
csClipInfo | Structure for use with ClipToPlane
csClipper | Abstract parent to all 2D clipping objects
csCLQAttenuation | Constant, Linear, Quadratic attenuation Out = in /(const + distance*lin + distance^2*quad)
csColliderActor | With csColliderActor you can more easily manage collision detection of a player or character model with gravity handling
csColliderHelper | This is a class containing a few static member functions to help work with csColliderWrapper and collision detection in general
csColliderWrapper | This is a convenience object that you can use in your own games to attach an iCollider object (from the CD plugin system) to any other csObject (including CS entities)
csCollisionPair | A structure used to return collision pairs
csColor | A class used to represent a color in RGB space
csColor4 | A class used to represent a color in RGBA space
csColorQuantizer | Color quantizer
csCommandEventData | Structure that collects the data a command event carries
csCommandEventHelper | Helper class to conveniently deal with command events
csCommandLineHelper | This class can be used to help parsing the commandline
csCommandLineOption | Representation of a commandline option
csCommandLineParser | Utility class that makes it easier to parse the command line
csCommonImageFile | A base class for image loader plugin iImage implementations
csCommonImageFile::LoaderJob |
csCommonImageFileLoader | Base image loader implementation
csComparator< T1, T2 > | A template providing various comparison and ordering functions
csComparator< const char *, const char * > | CsComparator<> specialization for strings that uses strcmp()
csComparator< csBitArray, csBitArray > | CsComparator<> specialization for csBitArray to allow its use as e.g
csComparator< csInputDefinition, csInputDefinition > | CsComparator<> specialization for csInputDefinition to allow its use as e.g
csComparator< csRGBcolor *, csRGBcolor * > | CsComparator<> specialization for csColor*
csComparator< csRGBcolor, csRGBcolor > | CsComparator<> specialization for csRGBcolor
csComparator< csString, csString > | CsComparator<> specialization for csString that uses strcmp()
csComparator< csStringBase, csStringBase > |
csComparator< csStrKey, csStrKey > | CsComparator<> specialization for csStrKey that uses strcmp()
csComparatorBitArray< BitArray > | Base comparator for bit arrays
csComparatorString< T > | Template that can be used as a base class for comparators for string types
csComparatorStruct< T > | Template that can be used as a base class for comparators for POD (plain old data) types
csCompressVertex | This structure is used by csVector3Array::CompressVertices()
csCompressVertexInfo | This structure is used by csVertexCompressor::Compress()
csCondition | A condition object
csConfigAccess | This is a simple convenience class that can be used to deal with the sytem config manager
csConfigDocument | IConfigFile implementation for configurations stored in documents
csConfigFile | Configuration file which implements the iConfigFile SCF interface
csConfigManager | A configuration manager makes a number of individual iConfigFile objects appear to be a single configuration object
csCoreRenderMesh | Data required by the renderer to draw a mesh
csCoverageTile | Coverage tile
csCtoW | Helper class to convert char* (UTF-8 encoded )to wchar_t* strings for use as function parameters
csCubicSpline | A cubic spline
csCursorConverter | Helper class to convert images into data formats suitable for mouse cursor creation on various platforms and toolkits
csDataBuffer | This is an implementation of iDataBuffer interface
csDebuggingGraph | This is a static class that helps with debugging
csDebugImageWriter | Helper class allowing in debug builds for to quickly dump an iImage object onto disk for visual inspection
csDIntersect3 | Some functions to perform various intersection calculations with 3D line segments
csDirectionalLightProc< AttenuationProc > | Preform directional light lighting calculation without shadowing
csDirectionalLightProc< AttenuationProc >::PerVertex |
csDirectXError | Obtain symbols and descriptions for DirectX error codes
csDirtyAccessArray< T, ElementHandler > | A templated array class
csDirtyAccessArrayRefCounted< T, ElementHandler > | A variant of csDirtyAccessArray with reference-counted contents
csDMath3 | Various assorted 3D mathematical functions
csDMatrix3 | A 3x3 matrix
csDocumentAttributeCommon | Partial iDocumentAttribute implementation with commonly duplicated logic
csDocumentNodeCommon | Partial iDocumentNode implementation with commonly duplicated logic
csDocumentNodeReadOnly | Partial iDocumentNode implementation with commonly duplicated logic and dummy implementations for manipulation methods
csDPlane | A plane in 3D space
csDSquaredDist | Some functions to perform squared distance calculations
csDVector3 | A 3D vector
csEllipsoid | This class represents an ellipsoid
csEmptyDocumentAttributeIterator | Document attribute iterator does not return any attributes
csEmptyDocumentNodeIterator | Document node iterator does not return any nodes
csEngineTools | This is a class with static helper functions for working on engine data
csEvent | This class represents a system event
csEventAttributeIterator |
csEventCord | Event cord
csEventCord::PluginData |
csEventFlattener | Standard event flattener(also known as serializer)
csEventHandlerRegistry | The csEventHandlerRegistry maintains a global one-to-one mapping from strings to csHandlerIDs, and a one-to-(zero or one) mapping from csHandlerIDs to iEventHandler pointers
csEventNameRegistry | The csEventNameRegistry transforms textual event names (e.g., "crystalspace.input.joystick.3.button") into easier-to-manage csEventIDs (which, in non-debug builds, are really just csStringIDs)
csEventOutlet | A class which implements the iEventOutlet interface
csEventQueue | This class represents a general event queue
csEventQueue::FinalProcessFrameEventDispatcher |
csEventQueue::iTypedFrameEventDispatcher | As a transitional measure, the csevPreProcess, csevProcess, csevPostProcess and csevFinalProcess events are actually sub-events dispatched by a csevFrame handler
csEventQueue::PostProcessFrameEventDispatcher |
csEventQueue::PreProcessFrameEventDispatcher |
csEventQueue::ProcessFrameEventDispatcher |
csEventTimer | This class implements a timer
csEventTree | This class is used to represent the event namespace (tree)
csEventTree::SubscriberIterator | The SubscriberIterator is a wrapper for the messy internals of figuring out which event handler to call next
csFIFO< T, ElementHandler, MemoryAllocator > | A FIFO implemented on top of csArray<>, but faster than using just a single array
csFileReadHelper | Convenience class for simple file element reading
csFileTime | File time structure - used to query and set the last-modification time of a file
csFixed16 | Encapsulation of a 16.16 fixed-point number
csFixed24 | Encapsulation of a 8.24 fixed-point number
csFixedSizeAllocator< Size, Allocator > | This class implements a memory allocator which can efficiently allocate objects that all have the same size
csFixedSizeAllocator< Size, Allocator >::BlockKey |
csFixedSizeAllocator< Size, Allocator >::BlocksWrapper |
csFixedSizeAllocator< Size, Allocator >::DefaultDisposer | Default disposer mixin, just reporting leaks
csFixedSizeAllocator< Size, Allocator >::FreeNode |
csFlags | Set of flags which can be accessed through masks
csFmtDefaultReader< T > | Standard format string source for csPrintfFormatter
csFmtDefaultWriter< T > | Standard formatted string destination for csPrintfFormatter
csFog | Sector fog structure
csFogInfo | Information for vertex based fog
csFogMath | Fog math utilities
csFontCache | A cache for font glyphs
csFontCache::FontDeleteNotify | Font deletion callback
csFontCache::GlyphCacheData | Some basic data associated with a glyph
csFontCache::KnownFont | A font known to the cache
csFontCache::LRUEntry | An entry in the LRU list
csFontCache::PlaneGlyphElementHandler |
csFontCache::PlaneGlyphs | Array of a number of glyphs
csFrameDataHolder< T > | Helper template to retrieve an instance of some type that has not yet been used in a frame
csFrustum | A general frustum
csFrustumContext | This structure keeps track of the current frustum context
csG2DDrawBox< Tpixel, Tpixmixer > | Draw a box to a (software) canvas
csG2DDrawLine< Tpixel, Tpixmixer > | Class to draw a line
csG2DDrawText< Tpixel, Tpixmixer1, Tpixmixer2, Tpixmixer3 > | Class to write some text
csGenerateImage | This class will compute a texture for a terrain
csGenerateImageLayer | This class is used to store the layers of textures per value
csGenerateImageTexture | A base class which represents a texture that can be displayed on the terrain
csGenerateImageTextureBlend | Class for a texture that is made by blending together other textures based on a value
csGenerateImageTextureSingle | A class for a single texture
csGenerateImageTextureSolid | A class for a solid coloured texture
csGenerateImageValue | A base class which represents a value that can be computed for blending purposes for each pixel
csGenerateImageValueFunc | This class will generate a value using a given function
csGenerateImageValueFuncConst | This class will generate a constant value
csGenerateImageValueFuncTex | This class will generate a value using a texture
csGeomDebugHelper | This is a class that does unit testing (and other debug stuff) for most of csgeom classes
csGetFromAddress | Sized data type access helpers
csGLDriverDatabase | OpenGL driver database
csGLExtensionFlags | Struct containing all GL extension test flags
csGLExtensionFunctions | Struct containing all GL extension functions
csGLExtensionManager | GL extensions manager
csGLFontCache | OpenGL font cache
csGLScreenShot | OpenGL screen shot
csGLStateCache | OpenGL state cache
csGLStateCacheContext |
csGlyphMetrics | Metrics for a glyph that are independent from whether a simple or antialiased image is used
csGradient | A simple color gradient
csGradient::scfGradientShadesArray |
csGradientShade | An entry in an iGradient gradient
csGraphics2D | This is the base class for 2D canvases
csGraphics2DGLCommon | Basic OpenGL version of the 2D driver class
csGraphics2DGLCommon::csGLPixelFormatPicker |
csGraphics3DCaps | Information about 3d renderer capabilities
csHash< T, K, ArrayMemoryAlloc > | A generic hash table class, which grows dynamically and whose buckets are unsorted arrays
csHash< T, K, ArrayMemoryAlloc >::ConstGlobalIterator | An const iterator class for the hash
csHash< T, K, ArrayMemoryAlloc >::ConstIterator | An const iterator class for the hash
csHash< T, K, ArrayMemoryAlloc >::Element |
csHash< T, K, ArrayMemoryAlloc >::GlobalIterator | An iterator class for the hash
csHash< T, K, ArrayMemoryAlloc >::Iterator | An iterator class for the hash
csHashComputer< T > | Template for hash value computing
csHashComputer< const char * > | CsHashComputer<> specialization for strings that uses csHashCompute()
csHashComputer< const csEventID > |
csHashComputer< const csHandlerID > |
csHashComputer< csBitArray > | CsHashComputer<> specialization for csBitArray to allow its use as hash key type
csHashComputer< csInputDefinition > | CsHashComputer<> specialization for csInputDefinition to allow its use as hash key type
csHashComputer< double > |
csHashComputer< float > |
csHashComputer< iEventHandler * > |
csHashComputer< int > |
csHashComputer< long > |
csHashComputer< longlong > |
csHashComputer< ulonglong > |
csHashComputer< unsigned int > |
csHashComputer< unsigned long > |
csHashComputer< void * > | CsHashComputer<> specialization for an integral type
csHashComputerBitArray< BitArray > | Base hash computer for bit arrays
csHashComputerIntegral< T > | Template for hash value computing, suitable for integral types and types that can be casted to such
csHashComputerString< T > | Template that can be used as a base class for hash computers for string types (must support cast to const char*)
csHashComputerStruct< T > | Template that can be used as a base class for hash computers for POD structs
csHashReversible< T, K > | A csHash<> that maintains a reverse hash for indexing keys by values
csHitBeamResult | Return structure for the iMeshWrapper->HitBeam() routines
csIdentStrings | Helper class that contains a list of identifiers and their names
csIdentStrings::csIdentString |
csIEEEfloat | Convert IEEE 32-bit floats from or to native machine floats
csImageArea | This structure is used for saving/restoring areas of screen
csImageBase | Base class for iImage implementations
csImageCubeMapMaker | Wrapper class to create a cube map from a number of 2D images as the cube faces
csImageIOFileFormatDescription | Description for a file format supported by an image loader
csImageLoaderOptionsParser | Helper class to parse options strings passed to iImageIO::Save()
csImageManipulate | Helper class to manipulate iImage objects
csImageMemory | Memory image
csImageTools | Some helper functions to deal with iImage objects
csImageVolumeMaker | Wrapper class to create a volume aka 3D texture from a number of 2D images as the volume slices
csInitializer | This class contains several static member functions that can help setup an application
csInputBinder | Use this class to bind input events (keypress, button press, mouse move, etc
csInputDefinition | This class holds a description of a physical source of input events, such as a keyboard key, mouse or joystick button, or a mouse or joystick axis
csInputDriver | Superclass of all the generic input drivers
csInputEventHelper | Helper class to conveniently pull generic data out of input events
csInstallationPathsHelper | A helper class containing a number of functions to deal with Crystal Space installation paths
csInterleavedSubBufferOptions | Structure describing the properties of the individual buffers to be interleaved
csIntersect2 | Some functions to perform various intersection calculations with 2D line segments
csIntersect3 | Some functions to perform various intersection calculations with 3D line segments
csIntersectingTriangle | An intersection triangle for CollideRay
csInverseAttenuation | Inverse linear attenuation
csJoystickDriver | Generic Joystick driver
csJoystickEventData | Structure that collects the data a joystick event carries
csJoystickEventHelper | Helper class to conveniently deal with joystick events
csKDTree | A KD-tree
csKDTreeChild | A child in the KD-tree (usually some object)
csKeyboardDriver | Generic Keyboard Driver
csKeyComposer |
csKeyEventData | Structure that collects the data a keyboard event carries
csKeyEventHelper | Helper class to conveniently deal with keyboard events
csKeyValuePair | A Key Value pair
csLibraryReference | An object representing a reference to a library
csLightProperties | Light properties, as needed by the attenuation and lighting functors
csLightShaderVarCache | Helper to cache names of shader variables relevant to lighting
csLinearAttenuation | Linear attenuation
csLineOperation |
csList< T > | A lightweight double-linked list template
csList< T >::csListElement | Template which describes the data stored in the linked list For example a list of ints uses csListElement<int>
csList< T >::Iterator | Iterator for the list
csLittleEndian | Little endian to native conversion routines
csMapNode | A node
csMath2 | Various functions in 2D, such as 2D vector functions
csMath3 | Various assorted 3D mathematical functions
csMatrix2 | A 2x2 matrix
csMatrix3 | A 3x3 matrix
csMD5 | This is an encapsulation of a C-implementation of MD5 digest algorithm by Peter Deutsch <ghost@aladdin.com>
csMD5::Digest | An MD5 digest is 16 unsigned characters (not 0-terminated)
csMD5::md5_state_t |
csMemFile | Essentially a raw memory buffer which implements the abstract iFile interface
csMemoryMappedIO | Defines a simple memory-mapped IO class that is portable
csMemoryMapping | Memory mapping, as returned by csMemoryMappedIO::GetData()
csMemoryPen | The memory pen is a caching pen object
csMemoryPool | A quick-allocation pool for storage of arbitrary data
csMeshedPolygon | A polygon
csMeshFactory | This is the abstract implementation of iMeshObjectFactory
csMeshObject | This is an abstract implementation of iMeshObject
csMeshOnTexture | This class manages the rendering of a mesh on a texture
csMeshType | This is the abstract implementation of iMeshObjectType
csMouseDriver | Generic Mouse Driver
csMouseEventData | Structure that collects the data a mouse event carries
csMouseEventHelper | Helper class to conveniently deal with mouse events
csMutex | A mutual-exclusion object
csNewtonianParticleSystem | This class has a set of particles that behave with phsyics
csNoAttenuation | No attenuation
csNodeIterator | A node iterator
csNormalCalculator | A normal calculator
csNormalizationCubeAccessor | Shader variable accessor for a normalization cubemap
csNormalMappingTools | Some helpers for stuff related to normal maps
csNullCacheManager | This is a general cache that doesn't cache anything at all
csOBB | Oriented bounding box (OBB)
csOBBFrozen | Version of the csOBB with frozen corners (for optimization purposes)
csObject | A generic csObject class
csObjectModel | Helper class to make it easier to implement iObjectModel in mesh objects
csObjectRegistry | This is an implementation of iObjectRegistry
csOptionDescription | Configuration option description
csOrthoTransform | A class which defines a reversible transformation from one coordinate system to another by maintaining an inverse transformation matrix
csPackRGB | RGB data packing
csPackRGBA | RGBA data packing
csParasiticDataBuffer | A databuffer pointing into another databuffer
csParasiticDataBufferBase | Base class for pooled and unpooled parasitic data buffer
csParasiticDataBufferPooled | A databuffer pointing into another databuffer, pooled version
csPartialOrder< T > | A generic finite partial order class
csPartialOrder< T >::Node |
csParticle | Data representation of a single particle
csParticleAux | Auxiliary data per particle, not used as often
csParticleBuffer | Buffer holder for particle buffers
csParticleSystem | This class represents a particle system
csParticleSystem::PerFrameData |
csPath | A path in 3D
csPathsList | Class to manage a list of paths
csPathsList::Entry | This structure contains information about a plugin path
csPathsUtilities | A helper class with path-related utilities
csPDelArray< T > | An array of pointers
csPDelArrayElementHandler< T > |
csPen | A pen specialized for CS
csPhysicalFile | An implementation of the abstract iFile interface for real files within the physical filesystem
csPixelCoord | Simple 2D pixel coordinate
csPixelFormat | Structure describing the pixel format
csPixmap | This class is an simple set of inline routines good as an abstraction for simple 2D sprites
csPixMixerCopy< Tpixel > | PixMixer that ignores alpha
csPixMixerNoop< Tpixel > | PixMixer that doesn't do anything
csPixMixerRGBA< Tpixel > | PixMixer that mixes the pixel into the background with alpha
csPlane2 | A plane in 2D space
csPlane3 | A plane in 3D space
csPlatformMemoryMappingDummy | Memory mapping for platforms without memory mapping support - it does nothing, so the software emulation kicks in when csMemoryMappedIO is used
csPlatformMemoryMappingDummy::PlatformMemoryMapping |
csPlatformMemoryMappingPosix | Memory mapping for platforms with POSIX mmap() support
csPlatformMemoryMappingPosix::PlatformMemoryMapping |
csPlatformMemoryMappingWin32 | Memory mapping for Win32
csPlatformMemoryMappingWin32::PlatformMemoryMapping |
csPluginList |
csPluginLoader | This utility class helps to load plugins based on request, config file, and commandline
csPluginLoadRec |
csPluginManager | This is the standard implementation of the plugin manager
csPluginRequest | This class represents a single plugin request for csInitializer::RequestPlugins()
csPointLightProc< AttenuationProc > | Preform pointlight lighting calculation without shadowing
csPointLightProc< AttenuationProc >::PerVertex |
csPoly2D | The following class represents a general 2D polygon
csPoly2DFactory | This factory is responsible for creating csPoly2D objects or subclasses of csPoly2D
csPoly2DPool | This is an object pool which holds objects of type csPoly2D
csPoly3D | The following class represents a general 3D polygon
csPolygonClipper | Can be used for clipping any polygon against any other convex polygon
csPolygonMesh | A convenience polygon mesh implementation that you can feed with vertices and polygons from another source
csPolygonMeshBox | A convenience polygon mesh implementation that represents a cube
csPolygonMeshEdge | A definition of one edge
csPolygonMeshTools | A set of tools to work with iPolygonMesh instances
csPolygonRange | A range structure for specifing polygon ranges
csPolyIndexed | The following class represents a general polygon
csPoolEvent | This class is a system event designed for the pool system
csPrefixConfig | This is an implementation of iConfigFile that stores an ID string at construction, which it then prepends to all config keys on read/write operations
csPrimitives | A primitive mesh generator
csPrintfFormatter< Twriter, Treader > | Templated class for printf()-style string formatting
csProcAnimated | Procedural texture for animated images
csProcessorCapability | This class is used to identify capabilities in the processor such as support for MMX and SSE
csProcTexture | Generic superclass for procedural textures
csProgressPulse | Simple twirling textual cursor built out of the characters '-', '\', '|', and '/'
csPtr< T > | A normal pointer
csPtrKey< T > | A helper template to use pointers as keys for hashes
csPtrWrap< T > | Simple pointer wrapper class
csQuaternion | Class for a quaternion
csRadixSorter | A radix-sorter for signed and unsigned integers as well as floats
csRandomFloatGen | Fast simple random number generator for floating point values
csRandomGen | Portable random number generator class
csRandomVectorGen | Random number generator that generates random vector with spherical distribution
csRealisticAttenuation | Inverse quadratic attenuation
csRect | Rectangle class: simple class for manipulating 2D rectangles
csRectRegion | A rect region is a class that implements splittable 2d rectangles
csRedBlackTree< K > | A red-black-tree
csRedBlackTree< K >::Node | A node in the tree
csRedBlackTreeMap< K, T > | Key-value-map, backed by csRedBlackTree
csRedBlackTreePayload< K, T > | Helper template to allow storage of a payload together with a key in a csRedBlackTree
csRef< T > | A smart pointer
csRefArray< T, Allocator > | An array of smart pointers
csRefArrayElementHandler< T > |
csRefArrayObject< T > | This class implements a typed array that correctly keeps track of reference count and also is able to find by name
csRefCount | This is a class which provides basic reference-counting semantics
csRefTrackerAccess | Helper to facilitate access to the global reference tracker
csRegExpMatch | Information about (sub)expression matches
csRegExpMatcher | Matcher for regular expressions
csRenderBuffer | Render buffer - basic container for mesh geometry data
csRenderBuffer::Props | To scrape off a few bytes use bitfields; assumes values are in sane limits
csRenderBufferHolder | Holder of standard renderbuffers
csRenderBufferLock< T, TbufferKeeper > | Helper class for convenient locking/unlocking of an iRenderBuffer
csRenderContext | This structure keeps track of the current render context
csRenderMesh | Mesh data as returned by mesh plugins
csRenderMeshHolder | Helper class to retrieve an unused csRenderMesh
csRenderMeshList | This class is used when we need to store, sort and then render a list of rendermeshes
csRenderMeshModes | Mesh render mode information
csRenderStepParser | Parser for render steps and render step lists
csReporterHelper | Helper class for csReport()
csReversibleTransform | A class which defines a reversible transformation from one coordinate system to another by maintaining an inverse transformation matrix
csRGBcolor | An RGB color
csRGBpixel | An RGB pixel
csRunnable | Abstract interface for objects which can be run in a thread
csSafeCopyArray< T > | Convenience class to make a version of csArray<> that does a safe-copy in case of reallocation of the array
csSaverFile | An object containing information about where to save a file
csScfStringSet | The string set is a collection of unique strings
csSchedule | Easy way to get timers in applications
csScopedLock< T > |
csScopedMutexLock | This is a utility class for locking a Mutex
csScreenBoxResult | Return structure for iMeshWrapper->GetScreenBoundingBox()
csScreenShot | Simple iImage implementation for canvas screenshots
csScreenTargetResult | This structure is returned by csEngineTools::FindScreenTarget()
csSectorHitBeamResult | Return structure for the iSector->HitBeam() routines
csSegment2 | A 2D line segment
csSegment3 | A 3D line segment
csSemaphore | A semaphore object
csSequenceOp |
csSet< T, Allocator > | This class implements a basic set for objects
csSet< T, Allocator >::GlobalIterator | An iterator class for the set
csSetToAddress | Sized data type access helpers
csShaderExpression | An evaluable expression attached to a shader variable
csShaderExpression::oper |
csShaderExpression::oper_arg |
csShaderExpressionAccessor | Shader variable accessor that evaluates a shader expression when the SV value is queried
csShaderMetadata | Shader metadata
csShaderProgram | Base class for iShaderProgram plugins
csShaderProgram::ProgramParam | Program parameter, either a SV reference or a const value
csShaderProgram::VariableMapEntry | Holder of variable mapping
csShaderVarBlockAlloc< ObjectDispose > | A block allocator for shader variables
csShaderVariable | Storage class for "shader vars", inheritable variables in the shader system
csShaderVariableContext | Complete SCF class implementing iShaderVariableContext
csShaderVariableFrameHolder | Helper class to obtain a shader variable that was guaranteedly not used in a frame yet
csShaderVarMapping | Mapping of a shader variable to some shader-specific destination
csShortestDistanceResult | Result structure for csEngineTools::FindShortestDistance()
csSimplePixmap | This is the simple implementation of csPixmap that uses a single texture
csSimpleRenderMesh | A simple render mesh
csSndSysSoundFormat | The sound format
csSoftFontCache | Font cache base class for software canvases
csSoftFontCache::SoftGlyphCacheData |
csSoftFontCacheImpl< Tpixel, Tpixmixer > | An actual implementation of a font cache for software canvases
csSolidSpace | This structure keeps track of solid space
csSparse3D | General 3D sparse matrix class
csSphere | This class represents a sphere
csSpline | A spline superclass
csSpotLightProc< AttenuationProc > | Perform spotlight lighting calculation without shadowing
csSpotLightProc< AttenuationProc >::PerVertex |
csSprite2DVertex | A single 2D Sprite vertex
csSpriteCal3DActiveAnim |
csSquaredDist | Some functions to perform squared distance calculations
csString | Thin wrapper around csStringFast<> with its default buffer size
csStringArray | An array of strings
csStringArrayElementHandler |
csStringBase | This is a string class with a range of useful operators and type-safe overloads
csStringFast< LEN > | Subclass of csStringBase that contains an internal buffer which is faster than the always dynamically allocated buffer of csStringBase
csStringFast< 0 > |
csStringHash | A string-to-ID hash table
csStringReader | This is a convenience class that reads an input buffer line by line
csStringSet | The string set is a collection of unique strings
csStrKey | This is a simple helper class to make a copy of a const char*
csSubRectangles | A class managing allocations of sub-rectangles
csSubRectangles::SubRect | Sub-rectangle
csSubRectangles::SubRect::AllocInfo |
csSwapBytes | Methods to unconditionally swap the byte order of specifically sized types
csTestRectData | A structure used by TestRectangle() and initialized by PrepareTestRectangle()
csTextProgressMeter | Displays a simple percentage-style textual progress meter
csTextureHandle | This class is the top-level representation of a texture
csTextureManager | General version of the texture manager
csTextureTrans | This is a static class which encapsulates a few functions that can transform texture information into a texture matrix/vector
csThread | Representation of a thread of executation
csThreadJobQueue | IJobQueue implementation that lets the jobs run in a thread
csTiledCoverageBuffer | The tiled coverage Buffer
csTinyDocumentSystem | This is an SCF compatible wrapper for the TinyXml parser in csutil
csTraceBeamResult | Return structure for the csColliderHelper::TraceBeam() method
csTransform | A class which defines a transformation from one coordinate system to another
csTreeNode | A generic tree class
csTriangle | A triangle
csTriangleLODAlgo | Algorithm class that calculates the cost of a vertex
csTriangleLODAlgoEdge | This subclass of csTriangleLODAlgo uses a very simple cost metric to calculate the vertex cost
csTriangleMesh | A mesh of triangles
csTriangleMeshLOD | A static class which performs the calculation of the best order to do the collapsing of a triangle mesh
csTriangleMinMax | A triangle with minimum/maximum information on x
csTriangleVertex | The representation of a vertex in a triangle mesh
csTriangleVertexCost | The representation of a vertex in a triangle mesh
csTriangleVertices | A class which holds vertices and connectivity information for a triangle mesh
csTriangleVerticesCost | A class which holds vertices and connectivity information for a triangle mesh
csTriangleVerticesSorted | This class works closely with csTriangleVerticesCost and maintains a sorted (on cost) view of the vertices
csTriangulate2 | This triangulates a simple polygon
csTypedObjectIterator< T > | Typed object iterator class
csUnicodeTransform | Contains functions to convert between several UTF encodings
csUserRenderBufferManager | Helper class to manage multiple render buffers, usually provided by the user
csVariant | Variant, means that type of contained data is set at runtime
csVector2 | A 2D vector
csVector3 | A 3D vector
csVector3Array | This is actually the same class as csPoly3D
csVector4 | A 4D vector with "float" components
csVector4T< T > | A 4D vector with variable type components
csVerbosityManager | Default iVerbosityManager implementation
csVerbosityParser | Utility for parsing verbosity flags such as those provided by the `--verbose=flags` command-line option
csVertexCompressor | A vertex compressor
csVertexLightCalculator< LightProc > | IVertexLightCalculator implementation that takes one of csPointLightProc, csDirectionalLightProc or csSpotLightProc for LightProc to compute lighting for a light of the respective type
csVertexListWalker< Tbase, Tcomplex > | Helper class to make it easier to iterate over elements from renderbuffers, with automatic conversion to Tbase
csVertexStatus | The clipper can output additional information about each vertex in output polygon
csVfsCacheManager | This is a general cache that can cache data on VFS
csVfsDirectoryChanger | Helper class to change the current VFS directory and restore the previous directory when an instance goes out of scope
csView | Encapsulates the top-level Crystal Space renderer interface
csVirtualClock | This is an implementation of a virtual clock
csWeakRef< T > | A weak reference
csWeakRefArray< T > | An array of weak references
csWideSparse3D | This implementation of csSparse3D is very suited where the accesses will be very widely spaced (for example: one element at (-1000,0,0) and one at (1000,0,0))
csWin32CustomCursors | Class to create native Win32 mouse cursors from images
csWin32RegistryConfig | An iConfigFile, storing the settings in the Windows registry
cswinCallStackHelper | Call stack creation helper (Win32-specific)
cswinCtoA | Small helper to convert an UTF-8 to an ANSI string, useful when passing arguments to a function
cswinMinidumpWriter | Helper to write minidumps on Win32
cswinWtoA | Small helper to convert a wide to an ANSI string, useful when passing arguments to a function
csWtoC | Helper class to convert wchar_t* to char* (UTF-8 encoded) strings for use as function parameters
csXRotMatrix3 | An instance of csMatrix3 that is initialized as a rotation about X
csXScaleMatrix3 | An instance of csMatrix3 that is initialized to scale the X dimension
csYRotMatrix3 | An instance of csMatrix3 that is initialized as a rotation about Y
csYScaleMatrix3 | An instance of csMatrix3 that is initialized to scale the Y dimension
csZRotMatrix3 | An instance of csMatrix3 that is initialized as a rotation about Z
csZScaleMatrix3 | An instance of csMatrix3 that is initialized to scale the Z dimension
DirectDetection | Master class of the device detection of direct3d and directdraw
DirectDetectionDevice | Description of DirectDraw device
dirent |
CS::DocumentHelper::Implementation::FilterDocumentNodeIterator< T > | Filtering iDocumentNodeIterator
FrameBegin3DDraw | FrameBegin3DDraw handles every csevFrame event in the 3D phase
FramePrinter | FramePrinter handles every csevFrame event in the FRAME (final) phase
FrameSignpost_2DConsole |
FrameSignpost_3D2D |
FrameSignpost_ConsoleDebug |
FrameSignpost_DebugFrame |
FrameSignpost_Logic3D |
getopt_option | Describe the long-named options requested by the application
CS::Memory::Heap | A separate heap from which memory can be allocated
CS::Memory::HeapAccessPointer< HeapContainer > | Heap accessor for AllocatorHeapBase
iAddonReference | This interface represents a reference to an addon
iAnimatedImage | If an image file has animation capabilities, this interface is exhibited
iAnimTimeUpdateHandler | By default, csSpriteCal3DMeshObject::Advance() updates the model's via CalModel::update() with the elapsed time since the last advancement
iArrayChangeAll< T > | Array interface template, completely changeable
iArrayChangeElements< T > | Array interface template, elements are changeable
iArrayReadOnly< T > | Array interface template, read-only
iBase | This is the basic interface: all other interfaces should be derived from this one, this will allow us to always use at least some minimal functionality given any interface pointer
iBaseHalo | This is the basic interface for all types of halos
iBezierFactoryState | This is the state interface to access the internals of a bezier mesh factory
iBezierState | This is the state interface to access the internals of a bezier mesh object
iBinaryLoaderPlugin | This is a binary plugin for the loader
iBinarySaverPlugin | This is a binary plugin to save with
iBodyGroup | Body Group is a collection of bodies which don't collide with each other
iBugPlug | Using this interface you can communicate with the BugPlug plugin
iBugPlugRenderObject | An application/module can implement this interface to render something
iCacheManager | A generic cache system
iCamera | Camera class
iCameraPosition | A camera position
iCameraPositionList | A list of camera position objects
iCameraSectorListener | Implement this interface if you are interested in learning when the camera changes sector
iCEGUI | Interface for the CS CEGUI wrapper
iClipper2D | This interfaces represents a 2D clipper for polygons
iCollection | A collection object is for convenience of the script language
iCollectionList | ICollection list
iCollider | A mesh collider
iCollideSystem | This is the Collide plug-in
iColoredVertices |
iCommandLineParser | A utility class that makes it easier to parse the command line
iComponent | This interface describes a generic component in Crystal Space
iConfigFile | Configuration file interface
iConfigIterator | Iterator which allows sequential access to configuration information contained in an iConfigFile object
iConfigManager | The configuration manager is used to make a number of iConfigFile object appear like a single object
iConsoleExecCallback | Command execution callback
iConsoleInput | This is a plugin that can handle keyboard input and display it on an associated console
iConsoleOutput | This is the Crystal Space Console interface
iConsoleWatcher | This interface is implemented by objects interested in knowing when the console's visibility status has changed
iCrossHalo | This is a halo which resembles a cross
iCursor | This interface is used to access the custom cursor plugin, which handles processing for displaying pixmaps as cursors
iCurve | This is the interface for a curve
iDataBuffer | The iDataBuffer interface can be used to exchange buffers with abstract data between plugins
iDebugHelper | Some object that wants to implement unit testing, debugging and/or benchmarking can implement this interface
CS::PluginCommon::SoftShader::iDefaultScanlineRenderer | Default software scanline renderer
CS::PluginCommon::SoftShader::iDefaultShader | Software renderer default shader plugin
iDocument | Representation of a document containing a hierarchical structure of nodes
iDocumentAttribute | An attribute for an iDocumentNode
iDocumentAttributeIterator | An iterator over iDocumentNode attributes
iDocumentNode | Representation of a node in a document
iDocumentNodeIterator | An iterator over iDocumentNode
iDocumentSystem | An iDocument factory
iDynamics | This is the interface for the actual plugin
iDynamicsColliderCollisionCallback | This is the interface for attaching a collider callback to the body
iDynamicsCollisionCallback | This is the interface for attaching a collider callback to the body
iDynamicsMoveCallback | This is the interface for a dynamics move callback
iDynamicsSystemCollider | This is the interface for a dynamics system collider
iDynamicSystem | This is the interface for the dynamics core
iEmitBox | Box value emitter - returns points in an (axis aligned) box
iEmitCone | Cone value emitter - returns points in a cone
iEmitCylinder | Cylinder value emitter - returns values in a cylinder
iEmitCylinderTangent | Cylinder tangential value emitter - gives direction tangential to cylinder Uses the given point, gives a tangential direction for that
iEmitFactoryState | This interface describes the API for the emitter mesh factory object
iEmitFixed | Fixed value emitter - returns a particular point value
iEmitGen3D | This interface is for objects that can generate 3d vectors, which are used for emitting
iEmitLine | Line value emitter - returns values on the line between start and end
iEmitMix | Mix value emitter - returns a weighted random mix of other emitters
iEmitSphere | Sphere value emitter - returns points in a sphere
iEmitSphereTangent | Sphere tangential value emitter - gives direction tangential to sphere Uses the given point, gives a tangential direction for that
iEmitState | This interface describes the API for the emitter mesh object
iEngine | This interface is the main interface to the 3D engine
iEngineFrameCallback | A callback that will be fired whenever the engine starts drawing a frame
iEngineSectorCallback | A callback that will be fired whenever a sector is created or removed from the engine
iEngineSequenceManager | Sequence manager specifically designed for working on the engine
iEngineSequenceParameters | An interface for passing on parameters to the engine sequence manager
iEvent | This interface describes any system event
iEventAttributeIterator | Event attribute iterator
iEventCord | The iEventCord is an interface provided by an event queue to any event handlers wanting to receive some subclasses of events ASAP in a specified priority, bypassing the queue itself
iEventHandler | This interface describes an entity that can receive events
iEventHandlerRegistry | This interface represents a general event handler registry/resolver
iEventNameRegistry | This interface represents a general event name resolver
iEventOutlet | The iEventOutlet is the interface to an object that is provided by an event queue to every event plug when it registers itself
iEventPlug | Event plug interface, also referred as "event source"
iEventQueue | This interface represents a general event queue
iEventTimer | A timer
iFactory | IFactory is an interface that is used to create instances of shared classes
iFile | A replacement for FILE type in the virtual file space
iFireTexture | Interface to the 'fire' procedural texture
iFlareHalo | This is a halo which resembles a (solar) flare
iFont | A font object
iFontDeleteNotify | Called before a font is deleted
iFontServer | A font server interface
iFrameEventSignpost |
iFrustumView | This structure represents all information needed for the frustum visibility calculator
iFrustumViewUserdata | User data which can be attached to iFrustumView
iGeneralFactoryState | This interface describes the API for the general mesh factory
iGeneralMeshCommonState | The common interface between genmesh meshes and factories
iGeneralMeshState | This interface describes the API for the general mesh object
iGeneralMeshSubMesh |
iGenerateImageFunction | This class represents a function for csGenerateImageValueFunc
iGenericRenderStep | A generic render step
iGenMeshAnimationControl | Implementing this class allows the creation of classes that control animation of vertex, texel, normal, and color data right before it is being used
iGenMeshAnimationControlFactory | This class is a factory for creating animation controls
iGenMeshAnimationControlState | This interface describes the API for setting up the animation control as implemented by the 'gmeshanim' plugin
iGenMeshAnimationControlType | This class is the animation control type
iGenMeshSkeletonControlState | This interface describes the API for setting up the skeleton animation control as implemented by the 'gmeshskelanim' plugin
iGradient | A simple color gradient
iGradientShades | An array of gradient shades
iGraphics2D | This is the interface for 2D renderer
iGraphics3D | This is the standard 3D graphics interface
iGraphicsMemory | This is the interface used to access the csGraphicsMemory plugin
iHalo | IHalo: used to render halos (aka "light globes")
iHazeFactoryState | This interface describes the API for the sprite factory mesh object
iHazeHull | A mesh specially meant for use by the haze
iHazeHullBox | A predefined hull
iHazeHullCone | A predefined hull
iHazeHullCreation | This interface is implemented by the haze factory in order to be able to create the predefined haze hulls
iHazeState | This interface describes the API for the sprite factory mesh object
iImage | The iImage interface is used to work with image objects
iImageFileLoader | An image file loader
iImageIO | The iImageIO interface is used to save and load graphic files
iImposter | IImposter defines the interface a mesh (or other) class must implement to be used as imposter mesh by the engine
iInputBinder | SCF interface for csInputBinder, used to bind input events (keypress, button press, mouse move, etc
iInstancingFactoryState | This interface describes the API for the instancing mesh factory
iInstancingMeshCommonState | The common interface between instancing meshes and factories
iInstancingMeshState | This interface describes the API for the instancing mesh object
iJob | A unit of work passed to iJobQueue
iJobQueue | Interface to simple job management
iJoint | This is the interface for a joint
iJoystickDriver | Generic Joystick driver
iKDTreeObjectDescriptor | If you implement this interface then you can give that to the KDtree
iKDTreeUserData | The data type for user data to be attached to the KDTree
iKeyboardDriver | Generic Keyboard Driver
iKeyComposer | Keyboard input handler
iKeyValuePair | A Key Value pair
iKitchenSink | Interface to interact with a kitchen sink
iLibraryReference | This interface represents a reference to a library file
iLight | The iLight interface is the SCF interface for the csLight class
iLightCallback | Set a callback which is called when this light color is changed
iLightingInfo | This interface is implemented by mesh objects that have some kind of lighting system
iLightingManager |
iLightingProcessData | The iLightingProcessData interface can be implemented by a mesh object so that it can attach additional information for the lighting process
iLightingProcessInfo | The iLightingProcessInfo interface holds information for the lighting system
iLightIterator | Iterator to iterate over all static lights in the engine
iLightIterRenderStep |
iLightList | This structure represents a list of lights
iLightManager | An engine (3D or iso) can implement this interface for the benefit of mesh objects so that they can request lighting information from the engine
iLightningFactoryState |
iLightningState |
iLightRenderStep |
iLightSectorInfluence | A light-sector influence (LSI)
iLightVisibleCallback | A callback that is fired whenever a light is visible
iLoader | This interface represents the map loader
iLoaderContext | This interface gives the context for the loader
iLoaderPlugin | This is a plugin for the loader based on document tree
iLoaderStatus | An object to query about the status of the threaded loader
iLODControl | The iLODControl interface represents an object that has controllable LOD features
CS::ImageAutoConvert | Small wrapper class to automatically convert an image into a different storage format, if needed
IMAGEHLP_LINE64 |
IMAGEHLP_LINEW64 |
IMAGEHLP_MODULE64 |
IMAGEHLP_MODULEW64 |
IMAGEHLP_STACK_FRAME |
iMapNode | A node
iMaterial | This class represents a material as seen from the engine view
iMaterialEngine | This interface represents the engine part of the material definition
iMaterialList | This class represents a list of materials
iMaterialWrapper | A material wrapper is an engine-level object that wraps around an actual material (iMaterial)
iMemoryTracker | This interface is used with CS_MEMORY_TRACKER
iMeshDrawCallback | Set a callback which is called just before the object is drawn
iMeshFactoryList | A list of mesh factories
iMeshFactoryWrapper | A mesh factory wrapper is an engine-level object that wraps around a mesh object factory (iMeshObjectFactory)
iMeshGenerator | IMeshGenerator defines the interface for a mesh generator
iMeshGeneratorGeometry | This interface defines one piece of geometry for the mesh generator
iMeshList | A list of meshes
iMeshObject | This is a general mesh object that the engine can interact with
iMeshObjectDrawCallback | Set a callback which is called just before the object is drawn
iMeshObjectFactory | This object is a factory which can generate mesh objects of a certain type
iMeshObjectType | This plugin describes a specific type of mesh objects
iMeshWrapper | A mesh wrapper is an engine-level object that wraps around an actual mesh object (iMeshObject)
iMeshWrapperIterator | This is an iterator mesh wrappers
iMissingLoaderData | This callback is called when the loader can't find some material, texture, factory, mesh, light, shader, or sector
iModelLoader | Some loader plugins implement this as an easier way to load a factory from code
iMouseDriver | Generic Mouse Driver
iMovable | This interface represents the position and orientation of an object relative to its parent (this is the transformation between local object space of the model and world space (i.e
iMovableListener | Implement this class if you're interested in hearing about movable changes
iMovieRecorder | Using this interface you can communicate with the MovieRecorder plugin
CS::ImportKit | Crystal Space Import Kit
CS::ImportKit::Container | Contains multiple models
CS::ImportKit::Container::Material | A material for a mesh
CS::ImportKit::Container::Model | A model
CS::ImportKit::Container::Model::Mesh | Model mesh, contains actual geometry
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::PluginCommon::SoftShader::InterpolateEdgePersp | Interpolator for a polygon edge
CS::PluginCommon::SoftShader::InterpolateEdgePersp::PerFloat | A single interpolated buffer value
CS::PluginCommon::SoftShader::InterpolateScanlinePersp< maxFloats > | Interpolator over a scanline
CS::PluginCommon::SoftShader::InterpolateScanlinePersp< 0 > |
CS::PluginCommon::SoftShader::InterpolateScanlinePerspCommon | Interpolator over a scanline, common code
iNullFactoryState | This interface describes the API for the null mesh object factory
iNullMeshState | This interface describes the API for the null mesh object
iObject | This interface is an SCF interface for encapsulating csObject
iObjectIterator | This is an iterator for child objects of a csObject
iObjectModel | This interface represents data related to some geometry in object space
iObjectModelListener | Implement this class if you're interested in hearing about when the object model changes
iObjectNameChangeListener | A callback that you can implement to get notified of name changes in an iObject
iObjectRegistry | This interface serves as a registry of other objects
iObjectRegistryIterator | Use an instance of this class to iterate over objects in the object registry
iObjectWatcher | This is a generic object watcher
iObjectWatcherListener | Implement this class if you're interested in hearing about object watcher events
iODEAMotorJoint | ODE AMotor joint
iODEBallJoint | ODE ball and socket joint (contrainted translation and free rotation)
iODEDynamicState | This class exposes parameters specific to odedynam as an implementation of iDynamics
iODEDynamicSystemState | This class exposes parameters specific to odedynam as an implementation of iDynamics
iODEFrameUpdateCallback | This class can be passed in as a callback during the physics update it is only called if FrameRate is enabled
iODEGeneralJointState | General joint state
iODEHinge2Joint | ODE hinge 2 joint
iODEHingeJoint | ODE hinge joint (contrainted translation and 1 free rotation axis)
iODEJointState | General joint state
iODESliderJoint |
iODEUniversalJoint | A universal joint is like a ball and socket joint that constrains an extra degree of rotational freedom
iOffscreenCanvasCallback | When you create an offscreen canvas (CreateOffscreenCanvas()) then you can use this callback to get informed when the texture has been modified (FinishDraw() called) or a palette entry is modified
iOpenGLDriverDatabase | Interface to read custom GL driver databases
iOpenGLInterface | A common interface to be implemented by the platform specific opengl canvases
iOSXAssistant | This is an interface for an object which provides assistance to MacOS/X-specific canvases and Objective-C bridging code for application run-loop support
iPagingFormerState | IPagingFormerState exposes implementation specific methods for the PagingTerraformer plugin
iParameterESM | This interface is a parameter resolver
iParticle | A iParticle can be used in particle Systems
iParticleBuiltinEffectorFactory | Factory for builtin effectors
iParticleBuiltinEffectorForce | Simple force/acceleration applied to particles
iParticleBuiltinEffectorLinColor | Simple linear interpolation of particle color based on particle lifetime
iParticleBuiltinEffectorVelocityField | Velocity field effector
iParticleBuiltinEmitterBase |
iParticleBuiltinEmitterBox |
iParticleBuiltinEmitterCone |
iParticleBuiltinEmitterCylinder |
iParticleBuiltinEmitterFactory | Factory for builtin emitter-types
iParticleBuiltinEmitterSphere |
iParticleEffector | Base interface for particle effector
iParticleEmitter | A particle emitter
iParticleState | This interface describes the API for the particle mesh object
iParticleSystem | Properties for particle system object
iParticleSystemBase | Base properties for particle system
iParticleSystemFactory | Properties for particle system factory
iPath | A path in 3D
iPen | A pen is used to draw vector shapes
iPluginConfig | Interface to a configurator object
iPluginIterator | An iterator to iterate over all plugins in the plugin manager
iPluginManager | This is the plugin manager
iPolygonHandle | This is an interface that can be used to represent a polygon in situations where a SCF object is required
iPolygonMesh | This interface reprents a mesh of polygons
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
iProgressMeter | This is a general interface for a progress meter
iProtoFactoryState | The proto mesh is a demonstration or tutorial mesh
iProtoMeshState | This interface describes the API for the proto mesh object
iRefTracker | The reference tracker interface
iRegion | A region
iRegionList | A list of region objects
iRenderBuffer | This is a general buffer
iRenderBufferAccessor | Interface for renderbuffer accessor
iRendererLightmap | A lightmap registered with a renderer
iRenderLoop | Render loop
iRenderLoopManager | Render loop manager
iRenderStep |
iRenderStepContainer | Container for render steps
iRenderStepFactory | Interface to a render step factory
iRenderStepType | Render step type
iRenderView | This interface represents all information needed to render some object in a current draw context
iReporter | This is the interface for the error/message reporter plugin
iReporterIterator | An iterator to iterate over all messages in the reporter
iReporterListener | Implement this interface if you're interested in hearing about new messages on the reporter
iRigidBody | This is the interface for a rigid body
iSaver | This interface is used to serialize the engine contents
iSaverFile | This interface represents a CS file to save to
iSaverPlugin | This is a plugin to save with
CS::PluginCommon::SoftShader::iScanlineRenderer | Software renderer scanline renderer
CS::PluginCommon::SoftShader::iScanlineRenderer::RenderInfoMesh | Information for setting up rendering a mesh, filled by the scanline renderer
CS::PluginCommon::SoftShader::iScanlineRenderer::RenderInfoTriangle | Information for setting up rendering a triangle, filled by the scanline renderer
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
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
iShaderVarStack |
iShadowBlock | A block of shadows represent the shadows that are casted by one iShadowCaster object
iShadowBlockList | This is a list of shadow blocks
iShadowCaster | An object that can cast shadows
iShadowIterator | A shadow iterator allows someone to iterate over all shadows in a iShadowBlock or iShadowBlockList
iShadowReceiver | An object that is interested in getting shadow information
iSharedVariable | ISharedVariable implements a refcounted value which can be shared across many objects and updated efficiently
iSharedVariableList | A list of shared variables
iSharedVariableListener | A listener so that you can get notified when a variable is changed
iSimpleFormerState | ISimpleFormerState exposes implementation specific methods for the SimpleTerraformer plugin
iSkeleton | The skeleton interface provides needed functionality of a skeleton animation
iSkeletonBone | The skeleton bone class
iSkeletonBoneFactory | The skeleton bone factory is class that is used to create skeleton bones of a iSkeleton object
iSkeletonBoneRagdollInfo |
iSkeletonBoneUpdateCallback | This callback fires every time when bone changes it's transform
iSkeletonFactory | The skeleton factory is class that is used to create skeleton objects in the scene
iSkeletonGraveyard | ISkeletonGraveyard is the interface that cares for all skeleton factories
iSkeletonScript | Skeleton script is the interface that provides animation of a skeleton
iSkeletonScriptCallback | This is a callback function of an animation script
iSkeletonScriptKeyFrame | The script key frame contains all bones that will be transformed in a specific time of a skeleton script
iSkeletonSocket | The skeleton socket object wraps a relative transform of a bone
iSkeletonSocketFactory | The skeleton socket factory is class that is used to create skeleton sockets of a iSkeleton object
iSkeletonUpdateCallback | This is a callback function of a skeleton
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
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 |
iSndSysRendererCallback | Sound System renderer interface for callback notification
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
iSndSysSoftwareFilter3DProperties |
iSndSysSoftwareOutputFilter | Temporary filter interface definition
iSndSysSource |
iSndSysSourceSoftware |
iSndSysSourceSoftware3D |
iSndSysStream | The primary interface for a sound stream used by the audio system
iSndSysStreamCallback | Sound System stream interface for callback notification
iSndSysWrapper | A wrapper/holder for a loaded sound
CS::PluginCommon::SoftShader::iSoftShaderRenderInterface | Interface specific to the software renderer to allow shaders to communicate with it
iSprite2DFactoryState | This interface describes the API for the sprite factory mesh object
iSprite2DState | This interface describes the API for the sprite factory mesh object
iSprite2DUVAnimation | The animation works by having all frames of an animation sequence in a texture at different (u,v) locations, hence the name
iSprite2DUVAnimationFrame | This is a single frame in a UV animation
iSprite3DFactoryState | This interface describes the API for the 3D sprite factory mesh object
iSprite3DState | This interface describes the API for the 3D sprite mesh object
iSpriteAction | An action frameset for 3D sprite animation
iSpriteCal3DFactoryState | This interface describes the API for the 3D sprite factory mesh object
iSpriteCal3DSocket | A socket for specifying where sprites can plug into other sprites
iSpriteCal3DState | This interface describes the API for changing the Cal3D sprite mesh object's animations playing and other current traits
iSpriteFrame | A frame for 3D sprite animation
iSpriteSocket | A socket for specifying where sprites can plug into other sprites
CS::TypeTraits::IsReference< Type > | Check if Type is a reference or simple type
CS::TypeTraits::Implementation::IsReferenceImpl< T > |
CS::TypeTraits::IsSame< Type1, Type2 > | Check if two types are the same
CS::TypeTraits::Implementation::IsSameImpl< T, U > |
iStandardReporterListener | Interface to control the settings of the reporter listener plugin
iStreamDataCallback | This callback will be fired when the data is ready
iStreamSource | This interface represents a stream source
iString | This is a SCF-compatible interface for csString
iStringArray | This is an SCF-compatible interface for csStringArray
iStringSet | The string set is a collection of unique strings
iSuperLightmap | A super light map
iSyntaxService | This component provides services for other loaders to easily parse properties of standard CS world syntax
iTerraFormer | TerraFormer objects are used to retrieve terrain data
iTerrainFactoryState | Allows the setting of a set of generic terrain parameters outside any specific algorithm
iTerrainObjectState | This will override the settings for material in the parent
iTerraSampler | TerraSampler objects are used for the actual queries of terrain data Sampler regions are requested from the iTerraFormer plugin, and sampled for data via the Sample methods
iTextureCallback | A callback for when a iTextureWrapper is used
iTextureFactory | Interface to a texture factory
iTextureHandle | A texture handle as returned by iTextureManager
iTextureList | This class represents a list of texture wrappers
iTextureLoaderContext | Interface passed to a texture loader, holding some common texture properties
iTextureManager | This is the standard texture manager interface
iTextureType | Texture type
iTextureWrapper | A texture wrapper is an engine-level object that wraps around an actual texture (iTextureHandle)
iThingEnvironment | This interface is implemented by the iObjectType for things
iThingFactoryState | This is the state interface to access the internals of a thing mesh factory
iThingState | This is the state interface to access the internals of a thing mesh object
iTimerEvent | A timer event
iUserRenderBufferIterator | Interface to iterate over all buffers stored in a csUserRenderBufferManager
iVerbosityManager | Helper interface which applications and plugins can use to determine whether they should be verbose
iVertexLightCalculator | Interface to calculate lighting for a number of vertices
iVFS | The Virtual Filesystem Class is intended to be the only way for Crystal Space engine to access the files
iView | Encapsulates the top-level Crystal Space renderer interface
iVirtualClock | A virtual game clock
iVisibilityCuller | This interface represents a visibility culling system
iVisibilityCullerListener | Implement this interface when you want to get notified about visible objects detected by the visibility cullers
iVisibilityObject | An object that wants to know if it is visible or not for some visibility culler needs to implement this interface
iVisibilityObjectIterator | Iterator to iterate over some visibility objects
iWin32Assistant | This interface describes actions specific to the Windows platform
iWin32Canvas | This interface provides some extra functionality for Win32 canvases
iWxWindow | Interface to communicate with with a wxWidgets-based canvas
KDHELP64 |
CS::Memory::LocalBufferAllocator< T, N, ExcessAllocator > | An allocator with a small local buffer
CS::MeasureTime | Simple helper class to measure execution time of a block
MINIDUMP_CALLBACK_INFORMATION |
MINIDUMP_CALLBACK_INPUT |
MINIDUMP_CALLBACK_OUTPUT |
MINIDUMP_DIRECTORY |
MINIDUMP_EXCEPTION_INFORMATION |
MINIDUMP_HEADER |
MINIDUMP_INCLUDE_MODULE_CALLBACK |
MINIDUMP_INCLUDE_THREAD_CALLBACK |
MINIDUMP_LOCATION_DESCRIPTOR |
MINIDUMP_MEMORY_DESCRIPTOR |
MINIDUMP_MEMORY_LIST |
MINIDUMP_MODULE_CALLBACK |
MINIDUMP_THREAD_CALLBACK |
MINIDUMP_THREAD_EX_CALLBACK |
MINIDUMP_USER_STREAM |
MINIDUMP_USER_STREAM_INFORMATION |
CS::DocumentHelper::NodeAttributeCompare | Node comparator
CS::DocumentHelper::NodeAttributeRegexpTest | Check if a regular expression matches(case-insensitive) with the value of the given attribute
CS::DocumentHelper::NodeAttributeValueTest | Compare (case-sensitive) node attribute to given
CS::DocumentHelper::NodeNameCompare | Node comparator
CS::DocumentHelper::NodeValueTest | Compare (case-sensitive) node value to given
CS::TypeTraits::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
OSXDelegate2D |
OSXView |
OSXWindow |
CS::SndSys::PCMSampleConverter | A PCMSampleConverter object converts PCM data from one format to another
CS::PluginCommon::SoftShader::Pixel |
CS::PluginCommon::SoftShader::Pixel::tag_c |
CS::SndSys::QEntry< T > |
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::PluginCommon::SoftShader::ScanlineComp | Undivided buffer values
CS::PluginCommon::SoftShader::ScanlineCompDivZ | Buffer values div Z
scfArray< IF, Backend > | Implementation for iArrayReadOnly<>-, iArrayChangeElements<>- and iArrayChangeAll<>-derived interfaces, backed by a per-instance array
scfArrayWrap< IF, Backend > | Implementation for iArrayReadOnly<>-, iArrayChangeElements<>- and iArrayChangeAll<>-derived interfaces, backed by a reference to another array
scfArrayWrapConst< IF, Backend > | Implementation for iArrayReadOnly<>-derived interfaces, backed by a reference to another array
scfFakeInterface< If > | Fugly helper to resolve some bad situations
scfFakeInterface< If >::InterfaceTraits |
scfImplementation< Class > | Baseclass for the SCF implementation templates
scfImplementation0< Class > |
scfImplementation1< Class, I1 > |
scfImplementation2< Class, I1, I2 > |
scfImplementation3< Class, I1, I2, I3 > |
scfImplementation4< Class, I1, I2, I3, I4 > |
scfImplementation5< Class, I1, I2, I3, I4, I5 > |
scfImplementation6< Class, I1, I2, I3, I4, I5, I6 > |
scfImplementation7< Class, I1, I2, I3, I4, I5, I6, I7 > |
scfImplementationExt0< Class, Super > |
scfImplementationExt1< Class, Super, I1 > |
scfImplementationExt2< Class, Super, I1, I2 > |
scfImplementationExt3< Class, Super, I1, I2, I3 > |
scfImplementationExt4< Class, Super, I1, I2, I3, I4 > |
scfImplementationExt5< Class, Super, I1, I2, I3, I4, I5 > |
scfImplementationExt6< Class, Super, I1, I2, I3, I4, I5, I6 > |
scfImplementationExt7< Class, Super, I1, I2, I3, I4, I5, I6, I7 > |
scfImplementationPooled< Super > | Derive an SCF implementation from this class to have it pooled
scfImplementationPooled< Super >::Pool |
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::ShaderVariableContextImpl | Simple implementation for iShaderVariableContext
CS::ShaderVarName | Helper class to obtain an ID for a shader variable
CS::SndSys::SndSysBasicData |
CS::SndSys::SndSysBasicStream |
CS::SndSys::SndSysBasicStream::StreamNotificationEvent | Structure containing the data for each notification event
CS::PluginCommon::SoftShader::SoftwareTexture |
CS::SndSys::SoundCyclicBuffer | An implementation of a cyclic buffer oriented for sound functionality
CS::SpinLock |
STACKFRAME64 |
SYMBOL_INFO |
SYMBOL_INFOW |
CS::TypeTraits::Implementation::TraitAnd< b1, b2, b3, b4, b5, b6, b7 > |
CS::TypeTraits::Implementation::TraitAnd< true, true, true, true, true, true, true > |
CS::TriangleIndicesStream< T > | Helper class to extract triangles from an index buffer
CS::UberScreenshotMaker | Helper to create "&uuml;berscreenshots", screenshots with a resolution larger than the current framebuffer resolution
CS::TypeTraits::Implementation::Wrap< T > | Simple dummy-wrapper
ZIP_central_directory_file_header |
ZIP_end_central_dir_record |
ZIP_local_file_header |